Index: configure.in =================================================================== RCS file: /data/cvs/libvirt/configure.in,v retrieving revision 1.97 diff -u -r1.97 configure.in --- configure.in 27 Nov 2007 14:39:42 -0000 1.97 +++ configure.in 29 Nov 2007 16:04:04 -0000 @@ -26,34 +26,20 @@ GNUTLS_REQUIRED="1.0.25" AVAHI_REQUIRED="0.6.0" -dnl Checks for programs. +dnl Checks for C compiler. AC_PROG_CC +AM_PROG_CC_STDC +AC_C_CONST AC_PROG_INSTALL AC_PROG_CPP -AC_PATH_PROG(RM, rm, /bin/rm) -AC_PATH_PROG(MV, mv, /bin/mv) -AC_PATH_PROG(TAR, tar, /bin/tar) -AC_PATH_PROG(XMLLINT, xmllint, /usr/bin/xmllint) -AC_PATH_PROG(XSLTPROC, xsltproc, /usr/bin/xsltproc) - -dnl External programs that we can use if they are available. -dnl We will hard-code paths to these programs unless we cannot -dnl detect them, in which case we'll search for the program -dnl along the $PATH at runtime and fail if it's not there. -AC_PATH_PROG(DNSMASQ, dnsmasq, dnsmasq, - [/sbin:/usr/sbin:/usr/local/sbin:$PATH]) -AC_PATH_PROG(BRCTL, brctl, brctl, - [/sbin:/usr/sbin:/usr/local/sbin:$PATH]) - -AC_DEFINE_UNQUOTED([DNSMASQ],["$DNSMASQ"], - [Location or name of the dnsmasq program]) -AC_DEFINE_UNQUOTED([BRCTL],["$BRCTL"], - [Location or name of the brctl program (see bridge-utils)]) dnl Make sure we have an ANSI compiler AM_C_PROTOTYPES test "x$U" != "x" && AC_MSG_ERROR(Compiler not ANSI compliant) +dnl Support building Win32 DLLs (must appear *before* AM_PROG_LIBTOOL) +AC_LIBTOOL_WIN32_DLL + AM_PROG_LIBTOOL AM_PROG_CC_C_O @@ -66,6 +52,14 @@ dnl Availability of various common headers (non-fatal if missing). AC_CHECK_HEADERS([paths.h sys/syslimits.h]) +dnl Availability of getaddrinfo and getnameinfo. +dnl Use replacement from http://www.sra.co.jp/people/m-kasahr/getaddrinfo/ +dnl if not available. +AC_CHECK_FUNCS([getaddrinfo getnameinfo]) +if test "$ac_cv_func_getaddrinfo$ac_cv_func_getnameinfo" != yesyes ; then + AC_LIBOBJ(getaddrinfo) +fi + dnl Need -lrpc? (Cygwin needs this) AC_SEARCH_LIBS(xdrmem_create,rpc) @@ -78,6 +72,27 @@ [$ac_cv_path_RPCGEN -t /dev/null 2>&1]) fi +dnl Miscellaneous external programs. +AC_PATH_PROG(RM, rm, /bin/rm) +AC_PATH_PROG(MV, mv, /bin/mv) +AC_PATH_PROG(TAR, tar, /bin/tar) +AC_PATH_PROG(XMLLINT, xmllint, /usr/bin/xmllint) +AC_PATH_PROG(XSLTPROC, xsltproc, /usr/bin/xsltproc) + +dnl External programs that we can use if they are available. +dnl We will hard-code paths to these programs unless we cannot +dnl detect them, in which case we'll search for the program +dnl along the $PATH at runtime and fail if it's not there. +AC_PATH_PROG(DNSMASQ, dnsmasq, dnsmasq, + [/sbin:/usr/sbin:/usr/local/sbin:$PATH]) +AC_PATH_PROG(BRCTL, brctl, brctl, + [/sbin:/usr/sbin:/usr/local/sbin:$PATH]) + +AC_DEFINE_UNQUOTED([DNSMASQ],["$DNSMASQ"], + [Location or name of the dnsmasq program]) +AC_DEFINE_UNQUOTED([BRCTL],["$BRCTL"], + [Location or name of the brctl program (see bridge-utils)]) + dnl Specific dir for HTML output ? AC_ARG_WITH(html-dir, AC_HELP_STRING([--with-html-dir=path], [path to base html directory, default $datadir/doc/html]), @@ -529,6 +544,28 @@ ALL_LINGUAS="af am ar as be bg bn_IN bn ca cs cy da de el en_GB es et eu_ES fa fi fr gl gu he hi hr hu hy id is it ja ka kn ko ku lo lt lv mk ml mr ms my nb nl nn no nso or pa pl pt_BR pt ro ru si sk sl sq sr@Latn sr sv ta te th tr uk ur vi zh_CN zh_TW zu" fi +dnl Extra link-time flags for Cygwin. +dnl Copied from libxml2 configure.in, but I removed mingw changes +dnl for now since I'm not supporting mingw at present. - RWMJ +cygwin= +CYGWIN_EXTRA_LDFLAGS= +CYGWIN_EXTRA_LIBADD= +CYGWIN_EXTRA_PYTHON_LIBADD= +case "$host" in + *-*-cygwin*) + cygwin=yes + CYGWIN_EXTRA_LDFLAGS="-no-undefined" + CYGWIN_EXTRA_LIBADD="${INTLLIBS}" + if test "x$PYTHON_VERSION" != "x"; then + CYGWIN_EXTRA_PYTHON_LIBADD="-L/usr/lib/python${PYTHON_VERSION}/config -lpython${PYTHON_VERSION}" + fi + ;; +esac +AC_SUBST(CYGWIN_EXTRA_LDFLAGS) +AC_SUBST(CYGWIN_EXTRA_LIBADD) +AC_SUBST(CYGWIN_EXTRA_PYTHON_LIBADD) +AM_CONDITIONAL(CYGWIN,[test "x$cygwin" = "xyes"]) + # very annoying rm -f COPYING cp COPYING.LIB COPYING Index: python/Makefile.am =================================================================== RCS file: /data/cvs/libvirt/python/Makefile.am,v retrieving revision 1.10 diff -u -r1.10 Makefile.am --- python/Makefile.am 15 Nov 2007 13:04:28 -0000 1.10 +++ python/Makefile.am 29 Nov 2007 16:04:04 -0000 @@ -23,8 +23,6 @@ libvirt-python-api.xml \ $(DOCS) -libvirtmod_la_LDFLAGS = -module -avoid-version -L$(top_builddir)/src/.libs - if WITH_PYTHON mylibs = $(top_builddir)/src/libvirt.la @@ -33,10 +31,14 @@ python_LTLIBRARIES = libvirtmod.la libvirtmod_la_SOURCES = libvir.c types.c libvirt-py.c libvirt-py.h -libvirtmod_la_LIBADD = $(mylibs) # Python header files contain a redundant decl, hence: libvirtmod_la_CFLAGS = -Wno-redundant-decls +libvirtmod_la_LDFLAGS = -module -avoid-version -L$(top_builddir)/src/.libs \ + @CYGWIN_EXTRA_LDFLAGS@ +libvirtmod_la_LIBADD = $(mylibs) \ + @CYGWIN_EXTRA_LIBADD@ @CYGWIN_EXTRA_PYTHON_LIBADD@ + GENERATE = generator.py API_DESC = $(top_srcdir)/docs/libvirt-api.xml $(srcdir)/libvirt-python-api.xml GENERATED= libvirt-export.c \ @@ -61,6 +63,13 @@ @(for doc in $(DOCS) ; \ do @INSTALL@ -m 0644 $$doc $(DESTDIR)$(DOCS_DIR) ; done) +if CYGWIN +install-data-hook: + cd $(DESTDIR)$(pythondir) && \ + rm -f libvirtmod.dll && \ + ln -s cygvirtmod.dll libvirtmod.dll +endif + uninstall-local: rm -f $(DESTDIR)$(pythondir)/libvirt.py Index: qemud/qemud.c =================================================================== RCS file: /data/cvs/libvirt/qemud/qemud.c,v retrieving revision 1.63 diff -u -r1.63 qemud.c --- qemud/qemud.c 26 Nov 2007 11:56:41 -0000 1.63 +++ qemud/qemud.c 29 Nov 2007 16:04:05 -0000 @@ -61,6 +61,10 @@ #include "mdns.h" #endif +#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO) +#include "../src/getaddrinfo.h" +#endif + static int godaemon = 0; /* -d: Be a daemon */ static int verbose = 0; /* -v: Verbose mode */ static int timeout = -1; /* -t: Shutdown timeout */ Index: qemud/remote_protocol.c =================================================================== RCS file: /data/cvs/libvirt/qemud/remote_protocol.c,v retrieving revision 1.6 diff -u -r1.6 remote_protocol.c --- qemud/remote_protocol.c 21 Aug 2007 10:08:12 -0000 1.6 +++ qemud/remote_protocol.c 29 Nov 2007 16:04:06 -0000 @@ -1,1268 +1,1820 @@ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - +#include #include "remote_protocol.h" #include "libvirt/libvirt.h" + bool_t -xdr_remote_nonnull_string (XDR *xdrs, remote_nonnull_string *objp) +xdr_remote_nonnull_string(xdrs, objp) + XDR *xdrs; + remote_nonnull_string *objp; { - - if (!xdr_string (xdrs, objp, REMOTE_STRING_MAX)) - return FALSE; - return TRUE; + if (!xdr_string(xdrs, objp, REMOTE_STRING_MAX)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_string (XDR *xdrs, remote_string *objp) +xdr_remote_string(xdrs, objp) + XDR *xdrs; + remote_string *objp; { - - if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string)) - return FALSE; - return TRUE; + if (!xdr_pointer(xdrs, (char **)objp, sizeof(remote_nonnull_string), xdr_remote_nonnull_string)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_uuid (XDR *xdrs, remote_uuid objp) +xdr_remote_uuid(xdrs, objp) + XDR *xdrs; + remote_uuid objp; { - - if (!xdr_opaque (xdrs, objp, VIR_UUID_BUFLEN)) - return FALSE; - return TRUE; + if (!xdr_opaque(xdrs, objp, VIR_UUID_BUFLEN)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_nonnull_domain (XDR *xdrs, remote_nonnull_domain *objp) +xdr_remote_nonnull_domain(xdrs, objp) + XDR *xdrs; + remote_nonnull_domain *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->name)) - return FALSE; - if (!xdr_remote_uuid (xdrs, objp->uuid)) - return FALSE; - if (!xdr_int (xdrs, &objp->id)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->name)) { + return (FALSE); + } + if (!xdr_remote_uuid(xdrs, objp->uuid)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->id)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_nonnull_network (XDR *xdrs, remote_nonnull_network *objp) +xdr_remote_nonnull_network(xdrs, objp) + XDR *xdrs; + remote_nonnull_network *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->name)) - return FALSE; - if (!xdr_remote_uuid (xdrs, objp->uuid)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->name)) { + return (FALSE); + } + if (!xdr_remote_uuid(xdrs, objp->uuid)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain (XDR *xdrs, remote_domain *objp) +xdr_remote_domain(xdrs, objp) + XDR *xdrs; + remote_domain *objp; { - - if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_domain), (xdrproc_t) xdr_remote_nonnull_domain)) - return FALSE; - return TRUE; + if (!xdr_pointer(xdrs, (char **)objp, sizeof(remote_nonnull_domain), xdr_remote_nonnull_domain)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_network (XDR *xdrs, remote_network *objp) +xdr_remote_network(xdrs, objp) + XDR *xdrs; + remote_network *objp; { - - if (!xdr_pointer (xdrs, (char **)objp, sizeof (remote_nonnull_network), (xdrproc_t) xdr_remote_nonnull_network)) - return FALSE; - return TRUE; + if (!xdr_pointer(xdrs, (char **)objp, sizeof(remote_nonnull_network), xdr_remote_nonnull_network)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_error (XDR *xdrs, remote_error *objp) +xdr_remote_error(xdrs, objp) + XDR *xdrs; + remote_error *objp; { - - if (!xdr_int (xdrs, &objp->code)) - return FALSE; - if (!xdr_int (xdrs, &objp->domain)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->message)) - return FALSE; - if (!xdr_int (xdrs, &objp->level)) - return FALSE; - if (!xdr_remote_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->str1)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->str2)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->str3)) - return FALSE; - if (!xdr_int (xdrs, &objp->int1)) - return FALSE; - if (!xdr_int (xdrs, &objp->int2)) - return FALSE; - if (!xdr_remote_network (xdrs, &objp->net)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->code)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->domain)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->message)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->level)) { + return (FALSE); + } + if (!xdr_remote_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->str1)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->str2)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->str3)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->int1)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->int2)) { + return (FALSE); + } + if (!xdr_remote_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_vcpu_info (XDR *xdrs, remote_vcpu_info *objp) +xdr_remote_vcpu_info(xdrs, objp) + XDR *xdrs; + remote_vcpu_info *objp; { - - if (!xdr_u_int (xdrs, &objp->number)) - return FALSE; - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->cpu_time)) - return FALSE; - if (!xdr_int (xdrs, &objp->cpu)) - return FALSE; - return TRUE; + if (!xdr_u_int(xdrs, &objp->number)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->state)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->cpu_time)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->cpu)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_sched_param_value (XDR *xdrs, remote_sched_param_value *objp) +xdr_remote_sched_param_value(xdrs, objp) + XDR *xdrs; + remote_sched_param_value *objp; { - - if (!xdr_int (xdrs, &objp->type)) - return FALSE; + if (!xdr_int(xdrs, &objp->type)) { + return (FALSE); + } switch (objp->type) { case VIR_DOMAIN_SCHED_FIELD_INT: - return FALSE; + if (!xdr_int(xdrs, &objp->remote_sched_param_value_u.i)) { + return (FALSE); + } break; case VIR_DOMAIN_SCHED_FIELD_UINT: - if (!xdr_u_int (xdrs, &objp->remote_sched_param_value_u.ui)) - return FALSE; + if (!xdr_u_int(xdrs, &objp->remote_sched_param_value_u.ui)) { + return (FALSE); + } break; case VIR_DOMAIN_SCHED_FIELD_LLONG: - if (!xdr_quad_t (xdrs, &objp->remote_sched_param_value_u.l)) - return FALSE; + if (!xdr_int64_t(xdrs, &objp->remote_sched_param_value_u.l)) { + return (FALSE); + } break; case VIR_DOMAIN_SCHED_FIELD_ULLONG: - if (!xdr_u_quad_t (xdrs, &objp->remote_sched_param_value_u.ul)) - return FALSE; + if (!xdr_u_int64_t(xdrs, &objp->remote_sched_param_value_u.ul)) { + return (FALSE); + } break; case VIR_DOMAIN_SCHED_FIELD_DOUBLE: - if (!xdr_double (xdrs, &objp->remote_sched_param_value_u.d)) - return FALSE; + if (!xdr_double(xdrs, &objp->remote_sched_param_value_u.d)) { + return (FALSE); + } break; case VIR_DOMAIN_SCHED_FIELD_BOOLEAN: - if (!xdr_int (xdrs, &objp->remote_sched_param_value_u.b)) - return FALSE; + if (!xdr_int(xdrs, &objp->remote_sched_param_value_u.b)) { + return (FALSE); + } break; default: - return FALSE; + return (FALSE); } - return TRUE; + return (TRUE); } + + + bool_t -xdr_remote_sched_param (XDR *xdrs, remote_sched_param *objp) +xdr_remote_sched_param(xdrs, objp) + XDR *xdrs; + remote_sched_param *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->field)) { + return (FALSE); + } + if (!xdr_remote_sched_param_value(xdrs, &objp->value)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_remote_nonnull_string (xdrs, &objp->field)) - return FALSE; - if (!xdr_remote_sched_param_value (xdrs, &objp->value)) - return FALSE; - return TRUE; + +bool_t +xdr_remote_open_args(xdrs, objp) + XDR *xdrs; + remote_open_args *objp; +{ + if (!xdr_remote_string(xdrs, &objp->name)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_open_args (XDR *xdrs, remote_open_args *objp) +xdr_remote_supports_feature_args(xdrs, objp) + XDR *xdrs; + remote_supports_feature_args *objp; { + if (!xdr_int(xdrs, &objp->feature)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_remote_string (xdrs, &objp->name)) - return FALSE; - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - return TRUE; + +bool_t +xdr_remote_supports_feature_ret(xdrs, objp) + XDR *xdrs; + remote_supports_feature_ret *objp; +{ + if (!xdr_int(xdrs, &objp->supported)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_supports_feature_args (XDR *xdrs, remote_supports_feature_args *objp) +xdr_remote_get_type_ret(xdrs, objp) + XDR *xdrs; + remote_get_type_ret *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->type)) { + return (FALSE); + } + return (TRUE); +} + + + - if (!xdr_int (xdrs, &objp->feature)) - return FALSE; - return TRUE; +bool_t +xdr_remote_get_version_ret(xdrs, objp) + XDR *xdrs; + remote_get_version_ret *objp; +{ + if (!xdr_int64_t(xdrs, &objp->hv_ver)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_supports_feature_ret (XDR *xdrs, remote_supports_feature_ret *objp) +xdr_remote_get_hostname_ret(xdrs, objp) + XDR *xdrs; + remote_get_hostname_ret *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->hostname)) { + return (FALSE); + } + return (TRUE); +} - if (!xdr_int (xdrs, &objp->supported)) - return FALSE; - return TRUE; + + + +bool_t +xdr_remote_get_max_vcpus_args(xdrs, objp) + XDR *xdrs; + remote_get_max_vcpus_args *objp; +{ + if (!xdr_remote_string(xdrs, &objp->type)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_get_type_ret (XDR *xdrs, remote_get_type_ret *objp) +xdr_remote_get_max_vcpus_ret(xdrs, objp) + XDR *xdrs; + remote_get_max_vcpus_ret *objp; { + if (!xdr_int(xdrs, &objp->max_vcpus)) { + return (FALSE); + } + return (TRUE); +} + - if (!xdr_remote_nonnull_string (xdrs, &objp->type)) - return FALSE; - return TRUE; + + +bool_t +xdr_remote_node_get_info_ret(xdrs, objp) + XDR *xdrs; + remote_node_get_info_ret *objp; +{ + if (!xdr_vector(xdrs, (char *)objp->model, 32, sizeof(char), xdr_char)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->memory)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->cpus)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->mhz)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->nodes)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->sockets)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->cores)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->threads)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_get_version_ret (XDR *xdrs, remote_get_version_ret *objp) +xdr_remote_get_capabilities_ret(xdrs, objp) + XDR *xdrs; + remote_get_capabilities_ret *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->capabilities)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_quad_t (xdrs, &objp->hv_ver)) - return FALSE; - return TRUE; + +bool_t +xdr_remote_domain_get_scheduler_type_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_scheduler_type_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_get_hostname_ret (XDR *xdrs, remote_get_hostname_ret *objp) +xdr_remote_domain_get_scheduler_type_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_scheduler_type_ret *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->type)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->nparams)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_remote_nonnull_string (xdrs, &objp->hostname)) - return FALSE; - return TRUE; + +bool_t +xdr_remote_domain_get_scheduler_parameters_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_scheduler_parameters_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->nparams)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_get_max_vcpus_args (XDR *xdrs, remote_get_max_vcpus_args *objp) +xdr_remote_domain_get_scheduler_parameters_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_scheduler_parameters_ret *objp; { + if (!xdr_array(xdrs, (char **)&objp->params.params_val, (u_int *)&objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX, sizeof(remote_sched_param), xdr_remote_sched_param)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_remote_string (xdrs, &objp->type)) - return FALSE; - return TRUE; + +bool_t +xdr_remote_domain_set_scheduler_parameters_args(xdrs, objp) + XDR *xdrs; + remote_domain_set_scheduler_parameters_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_array(xdrs, (char **)&objp->params.params_val, (u_int *)&objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX, sizeof(remote_sched_param), xdr_remote_sched_param)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_get_max_vcpus_ret (XDR *xdrs, remote_get_max_vcpus_ret *objp) +xdr_remote_domain_block_stats_args(xdrs, objp) + XDR *xdrs; + remote_domain_block_stats_args *objp; { + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->path)) { + return (FALSE); + } + return (TRUE); +} + - if (!xdr_int (xdrs, &objp->max_vcpus)) - return FALSE; - return TRUE; + + +bool_t +xdr_remote_domain_block_stats_ret(xdrs, objp) + XDR *xdrs; + remote_domain_block_stats_ret *objp; +{ + if (!xdr_int64_t(xdrs, &objp->rd_req)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->rd_bytes)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->wr_req)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->wr_bytes)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->errs)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_node_get_info_ret (XDR *xdrs, remote_node_get_info_ret *objp) +xdr_remote_domain_interface_stats_args(xdrs, objp) + XDR *xdrs; + remote_domain_interface_stats_args *objp; { - register int32_t *buf; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->path)) { + return (FALSE); + } + return (TRUE); +} - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->model, 32, - sizeof (char), (xdrproc_t) xdr_char)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->memory)) - return FALSE; - buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->cpus)) - return FALSE; - if (!xdr_int (xdrs, &objp->mhz)) - return FALSE; - if (!xdr_int (xdrs, &objp->nodes)) - return FALSE; - if (!xdr_int (xdrs, &objp->sockets)) - return FALSE; - if (!xdr_int (xdrs, &objp->cores)) - return FALSE; - if (!xdr_int (xdrs, &objp->threads)) - return FALSE; - } else { - (void)IXDR_PUT_INT32(buf, objp->cpus); - (void)IXDR_PUT_INT32(buf, objp->mhz); - (void)IXDR_PUT_INT32(buf, objp->nodes); - (void)IXDR_PUT_INT32(buf, objp->sockets); - (void)IXDR_PUT_INT32(buf, objp->cores); - (void)IXDR_PUT_INT32(buf, objp->threads); - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->model, 32, - sizeof (char), (xdrproc_t) xdr_char)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->memory)) - return FALSE; - buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->cpus)) - return FALSE; - if (!xdr_int (xdrs, &objp->mhz)) - return FALSE; - if (!xdr_int (xdrs, &objp->nodes)) - return FALSE; - if (!xdr_int (xdrs, &objp->sockets)) - return FALSE; - if (!xdr_int (xdrs, &objp->cores)) - return FALSE; - if (!xdr_int (xdrs, &objp->threads)) - return FALSE; - } else { - objp->cpus = IXDR_GET_LONG(buf); - objp->mhz = IXDR_GET_LONG(buf); - objp->nodes = IXDR_GET_LONG(buf); - objp->sockets = IXDR_GET_LONG(buf); - objp->cores = IXDR_GET_LONG(buf); - objp->threads = IXDR_GET_LONG(buf); - } - return TRUE; + + +bool_t +xdr_remote_domain_interface_stats_ret(xdrs, objp) + XDR *xdrs; + remote_domain_interface_stats_ret *objp; +{ + if (!xdr_int64_t(xdrs, &objp->rx_bytes)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->rx_packets)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->rx_errs)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->rx_drop)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->tx_bytes)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->tx_packets)) { + return (FALSE); + } + if (!xdr_int64_t(xdrs, &objp->tx_errs)) { + return (FALSE); } + if (!xdr_int64_t(xdrs, &objp->tx_drop)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_vector (xdrs, (char *)objp->model, 32, - sizeof (char), (xdrproc_t) xdr_char)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->memory)) - return FALSE; - if (!xdr_int (xdrs, &objp->cpus)) - return FALSE; - if (!xdr_int (xdrs, &objp->mhz)) - return FALSE; - if (!xdr_int (xdrs, &objp->nodes)) - return FALSE; - if (!xdr_int (xdrs, &objp->sockets)) - return FALSE; - if (!xdr_int (xdrs, &objp->cores)) - return FALSE; - if (!xdr_int (xdrs, &objp->threads)) - return FALSE; - return TRUE; + +bool_t +xdr_remote_list_domains_args(xdrs, objp) + XDR *xdrs; + remote_list_domains_args *objp; +{ + if (!xdr_int(xdrs, &objp->maxids)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_get_capabilities_ret (XDR *xdrs, remote_get_capabilities_ret *objp) +xdr_remote_list_domains_ret(xdrs, objp) + XDR *xdrs; + remote_list_domains_ret *objp; { + if (!xdr_array(xdrs, (char **)&objp->ids.ids_val, (u_int *)&objp->ids.ids_len, REMOTE_DOMAIN_ID_LIST_MAX, sizeof(int), xdr_int)) { + return (FALSE); + } + return (TRUE); +} + + + - if (!xdr_remote_nonnull_string (xdrs, &objp->capabilities)) - return FALSE; - return TRUE; +bool_t +xdr_remote_num_of_domains_ret(xdrs, objp) + XDR *xdrs; + remote_num_of_domains_ret *objp; +{ + if (!xdr_int(xdrs, &objp->num)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_get_scheduler_type_args (XDR *xdrs, remote_domain_get_scheduler_type_args *objp) +xdr_remote_domain_create_linux_args(xdrs, objp) + XDR *xdrs; + remote_domain_create_linux_args *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->xml_desc)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); +} + + + - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; +bool_t +xdr_remote_domain_create_linux_ret(xdrs, objp) + XDR *xdrs; + remote_domain_create_linux_ret *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_get_scheduler_type_ret (XDR *xdrs, remote_domain_get_scheduler_type_ret *objp) +xdr_remote_domain_lookup_by_id_args(xdrs, objp) + XDR *xdrs; + remote_domain_lookup_by_id_args *objp; { + if (!xdr_int(xdrs, &objp->id)) { + return (FALSE); + } + return (TRUE); +} - if (!xdr_remote_nonnull_string (xdrs, &objp->type)) - return FALSE; - if (!xdr_int (xdrs, &objp->nparams)) - return FALSE; - return TRUE; + + + +bool_t +xdr_remote_domain_lookup_by_id_ret(xdrs, objp) + XDR *xdrs; + remote_domain_lookup_by_id_ret *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_get_scheduler_parameters_args (XDR *xdrs, remote_domain_get_scheduler_parameters_args *objp) +xdr_remote_domain_lookup_by_uuid_args(xdrs, objp) + XDR *xdrs; + remote_domain_lookup_by_uuid_args *objp; { + if (!xdr_remote_uuid(xdrs, objp->uuid)) { + return (FALSE); + } + return (TRUE); +} - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->nparams)) - return FALSE; - return TRUE; + + + +bool_t +xdr_remote_domain_lookup_by_uuid_ret(xdrs, objp) + XDR *xdrs; + remote_domain_lookup_by_uuid_ret *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_lookup_by_name_args(xdrs, objp) + XDR *xdrs; + remote_domain_lookup_by_name_args *objp; +{ + if (!xdr_remote_nonnull_string(xdrs, &objp->name)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_lookup_by_name_ret(xdrs, objp) + XDR *xdrs; + remote_domain_lookup_by_name_ret *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_get_scheduler_parameters_ret (XDR *xdrs, remote_domain_get_scheduler_parameters_ret *objp) +xdr_remote_domain_suspend_args(xdrs, objp) + XDR *xdrs; + remote_domain_suspend_args *objp; { - char **objp_cpp0 = (char **) (void *) &objp->params.params_val; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_resume_args(xdrs, objp) + XDR *xdrs; + remote_domain_resume_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_shutdown_args(xdrs, objp) + XDR *xdrs; + remote_domain_shutdown_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_reboot_args(xdrs, objp) + XDR *xdrs; + remote_domain_reboot_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_destroy_args(xdrs, objp) + XDR *xdrs; + remote_domain_destroy_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + + - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX, - sizeof (remote_sched_param), (xdrproc_t) xdr_remote_sched_param)) - return FALSE; - return TRUE; +bool_t +xdr_remote_domain_get_os_type_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_os_type_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_set_scheduler_parameters_args (XDR *xdrs, remote_domain_set_scheduler_parameters_args *objp) +xdr_remote_domain_get_os_type_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_os_type_ret *objp; { - char **objp_cpp0 = (char **) (void *) &objp->params.params_val; + if (!xdr_remote_nonnull_string(xdrs, &objp->type)) { + return (FALSE); + } + return (TRUE); +} - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->params.params_len, REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX, - sizeof (remote_sched_param), (xdrproc_t) xdr_remote_sched_param)) - return FALSE; - return TRUE; + + + +bool_t +xdr_remote_domain_get_max_memory_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_max_memory_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_block_stats_args (XDR *xdrs, remote_domain_block_stats_args *objp) +xdr_remote_domain_get_max_memory_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_max_memory_ret *objp; { + if (!xdr_u_int64_t(xdrs, &objp->memory)) { + return (FALSE); + } + return (TRUE); +} + - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->path)) - return FALSE; - return TRUE; + + +bool_t +xdr_remote_domain_set_max_memory_args(xdrs, objp) + XDR *xdrs; + remote_domain_set_max_memory_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->memory)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_block_stats_ret (XDR *xdrs, remote_domain_block_stats_ret *objp) +xdr_remote_domain_set_memory_args(xdrs, objp) + XDR *xdrs; + remote_domain_set_memory_args *objp; { + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->memory)) { + return (FALSE); + } + return (TRUE); +} - if (!xdr_quad_t (xdrs, &objp->rd_req)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->rd_bytes)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->wr_req)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->wr_bytes)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->errs)) - return FALSE; - return TRUE; + + + +bool_t +xdr_remote_domain_get_info_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_info_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_interface_stats_args (XDR *xdrs, remote_domain_interface_stats_args *objp) +xdr_remote_domain_get_info_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_info_ret *objp; { + if (!xdr_u_char(xdrs, &objp->state)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->max_mem)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->memory)) { + return (FALSE); + } + if (!xdr_u_short(xdrs, &objp->nr_virt_cpu)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->cpu_time)) { + return (FALSE); + } + return (TRUE); +} + - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->path)) - return FALSE; - return TRUE; + + +bool_t +xdr_remote_domain_save_args(xdrs, objp) + XDR *xdrs; + remote_domain_save_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->to)) { + return (FALSE); + } + return (TRUE); } + + + bool_t -xdr_remote_domain_interface_stats_ret (XDR *xdrs, remote_domain_interface_stats_ret *objp) +xdr_remote_domain_restore_args(xdrs, objp) + XDR *xdrs; + remote_domain_restore_args *objp; { + if (!xdr_remote_nonnull_string(xdrs, &objp->from)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_core_dump_args(xdrs, objp) + XDR *xdrs; + remote_domain_core_dump_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->to)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_dump_xml_args(xdrs, objp) + XDR *xdrs; + remote_domain_dump_xml_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_dump_xml_ret(xdrs, objp) + XDR *xdrs; + remote_domain_dump_xml_ret *objp; +{ + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_migrate_prepare_args(xdrs, objp) + XDR *xdrs; + remote_domain_migrate_prepare_args *objp; +{ + if (!xdr_remote_string(xdrs, &objp->uri_in)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->flags)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->dname)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->resource)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_migrate_prepare_ret(xdrs, objp) + XDR *xdrs; + remote_domain_migrate_prepare_ret *objp; +{ + if (!xdr_bytes(xdrs, (char **)&objp->cookie.cookie_val, (u_int *)&objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->uri_out)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_migrate_perform_args(xdrs, objp) + XDR *xdrs; + remote_domain_migrate_perform_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_bytes(xdrs, (char **)&objp->cookie.cookie_val, (u_int *)&objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->uri)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->flags)) { + return (FALSE); + } + if (!xdr_remote_string(xdrs, &objp->dname)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->resource)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_migrate_finish_args(xdrs, objp) + XDR *xdrs; + remote_domain_migrate_finish_args *objp; +{ + if (!xdr_remote_nonnull_string(xdrs, &objp->dname)) { + return (FALSE); + } + if (!xdr_bytes(xdrs, (char **)&objp->cookie.cookie_val, (u_int *)&objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->uri)) { + return (FALSE); + } + if (!xdr_u_int64_t(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_migrate_finish_ret(xdrs, objp) + XDR *xdrs; + remote_domain_migrate_finish_ret *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->ddom)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_list_defined_domains_args(xdrs, objp) + XDR *xdrs; + remote_list_defined_domains_args *objp; +{ + if (!xdr_int(xdrs, &objp->maxnames)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_list_defined_domains_ret(xdrs, objp) + XDR *xdrs; + remote_list_defined_domains_ret *objp; +{ + if (!xdr_array(xdrs, (char **)&objp->names.names_val, (u_int *)&objp->names.names_len, REMOTE_DOMAIN_NAME_LIST_MAX, sizeof(remote_nonnull_string), xdr_remote_nonnull_string)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_num_of_defined_domains_ret(xdrs, objp) + XDR *xdrs; + remote_num_of_defined_domains_ret *objp; +{ + if (!xdr_int(xdrs, &objp->num)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_create_args(xdrs, objp) + XDR *xdrs; + remote_domain_create_args *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_define_xml_args(xdrs, objp) + XDR *xdrs; + remote_domain_define_xml_args *objp; +{ + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_remote_domain_define_xml_ret(xdrs, objp) + XDR *xdrs; + remote_domain_define_xml_ret *objp; +{ + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); +} + + - if (!xdr_quad_t (xdrs, &objp->rx_bytes)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->rx_packets)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->rx_errs)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->rx_drop)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->tx_bytes)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->tx_packets)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->tx_errs)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->tx_drop)) - return FALSE; - return TRUE; -} bool_t -xdr_remote_list_domains_args (XDR *xdrs, remote_list_domains_args *objp) +xdr_remote_domain_undefine_args(xdrs, objp) + XDR *xdrs; + remote_domain_undefine_args *objp; { - - if (!xdr_int (xdrs, &objp->maxids)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_list_domains_ret (XDR *xdrs, remote_list_domains_ret *objp) -{ - char **objp_cpp0 = (char **) (void *) &objp->ids.ids_val; - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->ids.ids_len, REMOTE_DOMAIN_ID_LIST_MAX, - sizeof (int), (xdrproc_t) xdr_int)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_num_of_domains_ret (XDR *xdrs, remote_num_of_domains_ret *objp) +xdr_remote_domain_set_vcpus_args(xdrs, objp) + XDR *xdrs; + remote_domain_set_vcpus_args *objp; { - - if (!xdr_int (xdrs, &objp->num)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->nvcpus)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_create_linux_args (XDR *xdrs, remote_domain_create_linux_args *objp) -{ - if (!xdr_remote_nonnull_string (xdrs, &objp->xml_desc)) - return FALSE; - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_create_linux_ret (XDR *xdrs, remote_domain_create_linux_ret *objp) +xdr_remote_domain_pin_vcpu_args(xdrs, objp) + XDR *xdrs; + remote_domain_pin_vcpu_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->vcpu)) { + return (FALSE); + } + if (!xdr_bytes(xdrs, (char **)&objp->cpumap.cpumap_val, (u_int *)&objp->cpumap.cpumap_len, REMOTE_CPUMAP_MAX)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_lookup_by_id_args (XDR *xdrs, remote_domain_lookup_by_id_args *objp) -{ - if (!xdr_int (xdrs, &objp->id)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_lookup_by_id_ret (XDR *xdrs, remote_domain_lookup_by_id_ret *objp) +xdr_remote_domain_get_vcpus_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_vcpus_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->maxinfo)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->maplen)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_lookup_by_uuid_args (XDR *xdrs, remote_domain_lookup_by_uuid_args *objp) -{ - if (!xdr_remote_uuid (xdrs, objp->uuid)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_lookup_by_uuid_ret (XDR *xdrs, remote_domain_lookup_by_uuid_ret *objp) +xdr_remote_domain_get_vcpus_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_vcpus_ret *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_array(xdrs, (char **)&objp->info.info_val, (u_int *)&objp->info.info_len, REMOTE_VCPUINFO_MAX, sizeof(remote_vcpu_info), xdr_remote_vcpu_info)) { + return (FALSE); + } + if (!xdr_bytes(xdrs, (char **)&objp->cpumaps.cpumaps_val, (u_int *)&objp->cpumaps.cpumaps_len, REMOTE_CPUMAPS_MAX)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_lookup_by_name_args (XDR *xdrs, remote_domain_lookup_by_name_args *objp) -{ - if (!xdr_remote_nonnull_string (xdrs, &objp->name)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_lookup_by_name_ret (XDR *xdrs, remote_domain_lookup_by_name_ret *objp) +xdr_remote_domain_get_max_vcpus_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_max_vcpus_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_suspend_args (XDR *xdrs, remote_domain_suspend_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_resume_args (XDR *xdrs, remote_domain_resume_args *objp) +xdr_remote_domain_get_max_vcpus_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_max_vcpus_ret *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->num)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_shutdown_args (XDR *xdrs, remote_domain_shutdown_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_reboot_args (XDR *xdrs, remote_domain_reboot_args *objp) +xdr_remote_domain_attach_device_args(xdrs, objp) + XDR *xdrs; + remote_domain_attach_device_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_destroy_args (XDR *xdrs, remote_domain_destroy_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_get_os_type_args (XDR *xdrs, remote_domain_get_os_type_args *objp) +xdr_remote_domain_detach_device_args(xdrs, objp) + XDR *xdrs; + remote_domain_detach_device_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_get_os_type_ret (XDR *xdrs, remote_domain_get_os_type_ret *objp) -{ - if (!xdr_remote_nonnull_string (xdrs, &objp->type)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_get_max_memory_args (XDR *xdrs, remote_domain_get_max_memory_args *objp) +xdr_remote_domain_get_autostart_args(xdrs, objp) + XDR *xdrs; + remote_domain_get_autostart_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_get_max_memory_ret (XDR *xdrs, remote_domain_get_max_memory_ret *objp) -{ - if (!xdr_u_quad_t (xdrs, &objp->memory)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_set_max_memory_args (XDR *xdrs, remote_domain_set_max_memory_args *objp) +xdr_remote_domain_get_autostart_ret(xdrs, objp) + XDR *xdrs; + remote_domain_get_autostart_ret *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->memory)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->autostart)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_set_memory_args (XDR *xdrs, remote_domain_set_memory_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->memory)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_get_info_args (XDR *xdrs, remote_domain_get_info_args *objp) +xdr_remote_domain_set_autostart_args(xdrs, objp) + XDR *xdrs; + remote_domain_set_autostart_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_domain(xdrs, &objp->dom)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->autostart)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_get_info_ret (XDR *xdrs, remote_domain_get_info_ret *objp) -{ - if (!xdr_u_char (xdrs, &objp->state)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->max_mem)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->memory)) - return FALSE; - if (!xdr_u_short (xdrs, &objp->nr_virt_cpu)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->cpu_time)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_save_args (XDR *xdrs, remote_domain_save_args *objp) +xdr_remote_num_of_networks_ret(xdrs, objp) + XDR *xdrs; + remote_num_of_networks_ret *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->to)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->num)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_restore_args (XDR *xdrs, remote_domain_restore_args *objp) -{ - if (!xdr_remote_nonnull_string (xdrs, &objp->from)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_core_dump_args (XDR *xdrs, remote_domain_core_dump_args *objp) +xdr_remote_list_networks_args(xdrs, objp) + XDR *xdrs; + remote_list_networks_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->to)) - return FALSE; - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->maxnames)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_dump_xml_args (XDR *xdrs, remote_domain_dump_xml_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_dump_xml_ret (XDR *xdrs, remote_domain_dump_xml_ret *objp) +xdr_remote_list_networks_ret(xdrs, objp) + XDR *xdrs; + remote_list_networks_ret *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; + if (!xdr_array(xdrs, (char **)&objp->names.names_val, (u_int *)&objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX, sizeof(remote_nonnull_string), xdr_remote_nonnull_string)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_migrate_prepare_args (XDR *xdrs, remote_domain_migrate_prepare_args *objp) -{ - if (!xdr_remote_string (xdrs, &objp->uri_in)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->flags)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->dname)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->resource)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_migrate_prepare_ret (XDR *xdrs, remote_domain_migrate_prepare_ret *objp) +xdr_remote_num_of_defined_networks_ret(xdrs, objp) + XDR *xdrs; + remote_num_of_defined_networks_ret *objp; { - char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val; - - if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->uri_out)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->num)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_migrate_perform_args (XDR *xdrs, remote_domain_migrate_perform_args *objp) -{ - char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val; - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->uri)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->flags)) - return FALSE; - if (!xdr_remote_string (xdrs, &objp->dname)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->resource)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_migrate_finish_args (XDR *xdrs, remote_domain_migrate_finish_args *objp) +xdr_remote_list_defined_networks_args(xdrs, objp) + XDR *xdrs; + remote_list_defined_networks_args *objp; { - char **objp_cpp0 = (char **) (void *) &objp->cookie.cookie_val; - - if (!xdr_remote_nonnull_string (xdrs, &objp->dname)) - return FALSE; - if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cookie.cookie_len, REMOTE_MIGRATE_COOKIE_MAX)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->uri)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->flags)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->maxnames)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_migrate_finish_ret (XDR *xdrs, remote_domain_migrate_finish_ret *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->ddom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_list_defined_domains_args (XDR *xdrs, remote_list_defined_domains_args *objp) +xdr_remote_list_defined_networks_ret(xdrs, objp) + XDR *xdrs; + remote_list_defined_networks_ret *objp; { - - if (!xdr_int (xdrs, &objp->maxnames)) - return FALSE; - return TRUE; + if (!xdr_array(xdrs, (char **)&objp->names.names_val, (u_int *)&objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX, sizeof(remote_nonnull_string), xdr_remote_nonnull_string)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_list_defined_domains_ret (XDR *xdrs, remote_list_defined_domains_ret *objp) -{ - char **objp_cpp0 = (char **) (void *) &objp->names.names_val; - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_DOMAIN_NAME_LIST_MAX, - sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_num_of_defined_domains_ret (XDR *xdrs, remote_num_of_defined_domains_ret *objp) +xdr_remote_network_lookup_by_uuid_args(xdrs, objp) + XDR *xdrs; + remote_network_lookup_by_uuid_args *objp; { - - if (!xdr_int (xdrs, &objp->num)) - return FALSE; - return TRUE; + if (!xdr_remote_uuid(xdrs, objp->uuid)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_create_args (XDR *xdrs, remote_domain_create_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_define_xml_args (XDR *xdrs, remote_domain_define_xml_args *objp) +xdr_remote_network_lookup_by_uuid_ret(xdrs, objp) + XDR *xdrs; + remote_network_lookup_by_uuid_ret *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_define_xml_ret (XDR *xdrs, remote_domain_define_xml_ret *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_undefine_args (XDR *xdrs, remote_domain_undefine_args *objp) +xdr_remote_network_lookup_by_name_args(xdrs, objp) + XDR *xdrs; + remote_network_lookup_by_name_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->name)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_set_vcpus_args (XDR *xdrs, remote_domain_set_vcpus_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->nvcpus)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_pin_vcpu_args (XDR *xdrs, remote_domain_pin_vcpu_args *objp) +xdr_remote_network_lookup_by_name_ret(xdrs, objp) + XDR *xdrs; + remote_network_lookup_by_name_ret *objp; { - char **objp_cpp0 = (char **) (void *) &objp->cpumap.cpumap_val; - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->vcpu)) - return FALSE; - if (!xdr_bytes (xdrs, objp_cpp0, (u_int *) &objp->cpumap.cpumap_len, REMOTE_CPUMAP_MAX)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_get_vcpus_args (XDR *xdrs, remote_domain_get_vcpus_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->maxinfo)) - return FALSE; - if (!xdr_int (xdrs, &objp->maplen)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_get_vcpus_ret (XDR *xdrs, remote_domain_get_vcpus_ret *objp) +xdr_remote_network_create_xml_args(xdrs, objp) + XDR *xdrs; + remote_network_create_xml_args *objp; { - char **objp_cpp0 = (char **) (void *) &objp->info.info_val; - char **objp_cpp1 = (char **) (void *) &objp->cpumaps.cpumaps_val; - - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->info.info_len, REMOTE_VCPUINFO_MAX, - sizeof (remote_vcpu_info), (xdrproc_t) xdr_remote_vcpu_info)) - return FALSE; - if (!xdr_bytes (xdrs, objp_cpp1, (u_int *) &objp->cpumaps.cpumaps_len, REMOTE_CPUMAPS_MAX)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_get_max_vcpus_args (XDR *xdrs, remote_domain_get_max_vcpus_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_get_max_vcpus_ret (XDR *xdrs, remote_domain_get_max_vcpus_ret *objp) +xdr_remote_network_create_xml_ret(xdrs, objp) + XDR *xdrs; + remote_network_create_xml_ret *objp; { - - if (!xdr_int (xdrs, &objp->num)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_attach_device_args (XDR *xdrs, remote_domain_attach_device_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_detach_device_args (XDR *xdrs, remote_domain_detach_device_args *objp) +xdr_remote_network_define_xml_args(xdrs, objp) + XDR *xdrs; + remote_network_define_xml_args *objp; { - - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_get_autostart_args (XDR *xdrs, remote_domain_get_autostart_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_domain_get_autostart_ret (XDR *xdrs, remote_domain_get_autostart_ret *objp) +xdr_remote_network_define_xml_ret(xdrs, objp) + XDR *xdrs; + remote_network_define_xml_ret *objp; { - - if (!xdr_int (xdrs, &objp->autostart)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_domain_set_autostart_args (XDR *xdrs, remote_domain_set_autostart_args *objp) -{ - if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) - return FALSE; - if (!xdr_int (xdrs, &objp->autostart)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_num_of_networks_ret (XDR *xdrs, remote_num_of_networks_ret *objp) +xdr_remote_network_undefine_args(xdrs, objp) + XDR *xdrs; + remote_network_undefine_args *objp; { - - if (!xdr_int (xdrs, &objp->num)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_list_networks_args (XDR *xdrs, remote_list_networks_args *objp) -{ - if (!xdr_int (xdrs, &objp->maxnames)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_list_networks_ret (XDR *xdrs, remote_list_networks_ret *objp) +xdr_remote_network_create_args(xdrs, objp) + XDR *xdrs; + remote_network_create_args *objp; { - char **objp_cpp0 = (char **) (void *) &objp->names.names_val; - - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX, - sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_num_of_defined_networks_ret (XDR *xdrs, remote_num_of_defined_networks_ret *objp) -{ - if (!xdr_int (xdrs, &objp->num)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_list_defined_networks_args (XDR *xdrs, remote_list_defined_networks_args *objp) +xdr_remote_network_destroy_args(xdrs, objp) + XDR *xdrs; + remote_network_destroy_args *objp; { - - if (!xdr_int (xdrs, &objp->maxnames)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_list_defined_networks_ret (XDR *xdrs, remote_list_defined_networks_ret *objp) -{ - char **objp_cpp0 = (char **) (void *) &objp->names.names_val; - if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_NETWORK_NAME_LIST_MAX, - sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_lookup_by_uuid_args (XDR *xdrs, remote_network_lookup_by_uuid_args *objp) +xdr_remote_network_dump_xml_args(xdrs, objp) + XDR *xdrs; + remote_network_dump_xml_args *objp; { - - if (!xdr_remote_uuid (xdrs, objp->uuid)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->flags)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_lookup_by_uuid_ret (XDR *xdrs, remote_network_lookup_by_uuid_ret *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_lookup_by_name_args (XDR *xdrs, remote_network_lookup_by_name_args *objp) +xdr_remote_network_dump_xml_ret(xdrs, objp) + XDR *xdrs; + remote_network_dump_xml_ret *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->name)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->xml)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_lookup_by_name_ret (XDR *xdrs, remote_network_lookup_by_name_ret *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_create_xml_args (XDR *xdrs, remote_network_create_xml_args *objp) +xdr_remote_network_get_bridge_name_args(xdrs, objp) + XDR *xdrs; + remote_network_get_bridge_name_args *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_create_xml_ret (XDR *xdrs, remote_network_create_xml_ret *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_define_xml_args (XDR *xdrs, remote_network_define_xml_args *objp) +xdr_remote_network_get_bridge_name_ret(xdrs, objp) + XDR *xdrs; + remote_network_get_bridge_name_ret *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_string(xdrs, &objp->name)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_define_xml_ret (XDR *xdrs, remote_network_define_xml_ret *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_undefine_args (XDR *xdrs, remote_network_undefine_args *objp) +xdr_remote_network_get_autostart_args(xdrs, objp) + XDR *xdrs; + remote_network_get_autostart_args *objp; { - - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_create_args (XDR *xdrs, remote_network_create_args *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_destroy_args (XDR *xdrs, remote_network_destroy_args *objp) +xdr_remote_network_get_autostart_ret(xdrs, objp) + XDR *xdrs; + remote_network_get_autostart_ret *objp; { - - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; + if (!xdr_int(xdrs, &objp->autostart)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_dump_xml_args (XDR *xdrs, remote_network_dump_xml_args *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_dump_xml_ret (XDR *xdrs, remote_network_dump_xml_ret *objp) +xdr_remote_network_set_autostart_args(xdrs, objp) + XDR *xdrs; + remote_network_set_autostart_args *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->xml)) - return FALSE; - return TRUE; + if (!xdr_remote_nonnull_network(xdrs, &objp->net)) { + return (FALSE); + } + if (!xdr_int(xdrs, &objp->autostart)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_get_bridge_name_args (XDR *xdrs, remote_network_get_bridge_name_args *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_get_bridge_name_ret (XDR *xdrs, remote_network_get_bridge_name_ret *objp) +xdr_remote_procedure(xdrs, objp) + XDR *xdrs; + remote_procedure *objp; { - - if (!xdr_remote_nonnull_string (xdrs, &objp->name)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_get_autostart_args (XDR *xdrs, remote_network_get_autostart_args *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_network_get_autostart_ret (XDR *xdrs, remote_network_get_autostart_ret *objp) +xdr_remote_message_direction(xdrs, objp) + XDR *xdrs; + remote_message_direction *objp; { - - if (!xdr_int (xdrs, &objp->autostart)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_network_set_autostart_args (XDR *xdrs, remote_network_set_autostart_args *objp) -{ - if (!xdr_remote_nonnull_network (xdrs, &objp->net)) - return FALSE; - if (!xdr_int (xdrs, &objp->autostart)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_procedure (XDR *xdrs, remote_procedure *objp) +xdr_remote_message_status(xdrs, objp) + XDR *xdrs; + remote_message_status *objp; { - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_message_direction (XDR *xdrs, remote_message_direction *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} + bool_t -xdr_remote_message_status (XDR *xdrs, remote_message_status *objp) +xdr_remote_message_header(xdrs, objp) + XDR *xdrs; + remote_message_header *objp; { - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_u_int(xdrs, &objp->prog)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->vers)) { + return (FALSE); + } + if (!xdr_remote_procedure(xdrs, &objp->proc)) { + return (FALSE); + } + if (!xdr_remote_message_direction(xdrs, &objp->direction)) { + return (FALSE); + } + if (!xdr_u_int(xdrs, &objp->serial)) { + return (FALSE); + } + if (!xdr_remote_message_status(xdrs, &objp->status)) { + return (FALSE); + } + return (TRUE); } -bool_t -xdr_remote_message_header (XDR *xdrs, remote_message_header *objp) -{ - if (!xdr_u_int (xdrs, &objp->prog)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->vers)) - return FALSE; - if (!xdr_remote_procedure (xdrs, &objp->proc)) - return FALSE; - if (!xdr_remote_message_direction (xdrs, &objp->direction)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->serial)) - return FALSE; - if (!xdr_remote_message_status (xdrs, &objp->status)) - return FALSE; - return TRUE; -} Index: qemud/remote_protocol.h =================================================================== RCS file: /data/cvs/libvirt/qemud/remote_protocol.h,v retrieving revision 1.7 diff -u -r1.7 remote_protocol.h --- qemud/remote_protocol.h 17 Nov 2007 11:17:48 -0000 1.7 +++ qemud/remote_protocol.h 29 Nov 2007 16:04:06 -0000 @@ -1,25 +1,14 @@ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _REMOTE_PROTOCOL_H_RPCGEN -#define _REMOTE_PROTOCOL_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - #include "libvirt/libvirt.h" #define REMOTE_MESSAGE_MAX 262144 #define REMOTE_STRING_MAX 65536 typedef char *remote_nonnull_string; +bool_t xdr_remote_nonnull_string(); + typedef remote_nonnull_string *remote_string; +bool_t xdr_remote_string(); + #define REMOTE_DOMAIN_ID_LIST_MAX 16384 #define REMOTE_DOMAIN_NAME_LIST_MAX 1024 #define REMOTE_CPUMAP_MAX 256 @@ -30,6 +19,8 @@ #define REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX 16 typedef char remote_uuid[VIR_UUID_BUFLEN]; +bool_t xdr_remote_uuid(); + struct remote_nonnull_domain { remote_nonnull_string name; @@ -37,16 +28,24 @@ int id; }; typedef struct remote_nonnull_domain remote_nonnull_domain; +bool_t xdr_remote_nonnull_domain(); + struct remote_nonnull_network { remote_nonnull_string name; remote_uuid uuid; }; typedef struct remote_nonnull_network remote_nonnull_network; +bool_t xdr_remote_nonnull_network(); + typedef remote_nonnull_domain *remote_domain; +bool_t xdr_remote_domain(); + typedef remote_nonnull_network *remote_network; +bool_t xdr_remote_network(); + struct remote_error { int code; @@ -62,78 +61,102 @@ remote_network net; }; typedef struct remote_error remote_error; +bool_t xdr_remote_error(); + struct remote_vcpu_info { u_int number; int state; - u_quad_t cpu_time; + u_int64_t cpu_time; int cpu; }; typedef struct remote_vcpu_info remote_vcpu_info; +bool_t xdr_remote_vcpu_info(); + struct remote_sched_param_value { int type; union { int i; u_int ui; - quad_t l; - u_quad_t ul; + int64_t l; + u_int64_t ul; double d; int b; } remote_sched_param_value_u; }; typedef struct remote_sched_param_value remote_sched_param_value; +bool_t xdr_remote_sched_param_value(); + struct remote_sched_param { remote_nonnull_string field; remote_sched_param_value value; }; typedef struct remote_sched_param remote_sched_param; +bool_t xdr_remote_sched_param(); + struct remote_open_args { remote_string name; int flags; }; typedef struct remote_open_args remote_open_args; +bool_t xdr_remote_open_args(); + struct remote_supports_feature_args { int feature; }; typedef struct remote_supports_feature_args remote_supports_feature_args; +bool_t xdr_remote_supports_feature_args(); + struct remote_supports_feature_ret { int supported; }; typedef struct remote_supports_feature_ret remote_supports_feature_ret; +bool_t xdr_remote_supports_feature_ret(); + struct remote_get_type_ret { remote_nonnull_string type; }; typedef struct remote_get_type_ret remote_get_type_ret; +bool_t xdr_remote_get_type_ret(); + struct remote_get_version_ret { - quad_t hv_ver; + int64_t hv_ver; }; typedef struct remote_get_version_ret remote_get_version_ret; +bool_t xdr_remote_get_version_ret(); + struct remote_get_hostname_ret { remote_nonnull_string hostname; }; typedef struct remote_get_hostname_ret remote_get_hostname_ret; +bool_t xdr_remote_get_hostname_ret(); + struct remote_get_max_vcpus_args { remote_string type; }; typedef struct remote_get_max_vcpus_args remote_get_max_vcpus_args; +bool_t xdr_remote_get_max_vcpus_args(); + struct remote_get_max_vcpus_ret { int max_vcpus; }; typedef struct remote_get_max_vcpus_ret remote_get_max_vcpus_ret; +bool_t xdr_remote_get_max_vcpus_ret(); + struct remote_node_get_info_ret { char model[32]; - quad_t memory; + int64_t memory; int cpus; int mhz; int nodes; @@ -142,28 +165,38 @@ int threads; }; typedef struct remote_node_get_info_ret remote_node_get_info_ret; +bool_t xdr_remote_node_get_info_ret(); + struct remote_get_capabilities_ret { remote_nonnull_string capabilities; }; typedef struct remote_get_capabilities_ret remote_get_capabilities_ret; +bool_t xdr_remote_get_capabilities_ret(); + struct remote_domain_get_scheduler_type_args { remote_nonnull_domain dom; }; typedef struct remote_domain_get_scheduler_type_args remote_domain_get_scheduler_type_args; +bool_t xdr_remote_domain_get_scheduler_type_args(); + struct remote_domain_get_scheduler_type_ret { remote_nonnull_string type; int nparams; }; typedef struct remote_domain_get_scheduler_type_ret remote_domain_get_scheduler_type_ret; +bool_t xdr_remote_domain_get_scheduler_type_ret(); + struct remote_domain_get_scheduler_parameters_args { remote_nonnull_domain dom; int nparams; }; typedef struct remote_domain_get_scheduler_parameters_args remote_domain_get_scheduler_parameters_args; +bool_t xdr_remote_domain_get_scheduler_parameters_args(); + struct remote_domain_get_scheduler_parameters_ret { struct { @@ -172,6 +205,8 @@ } params; }; typedef struct remote_domain_get_scheduler_parameters_ret remote_domain_get_scheduler_parameters_ret; +bool_t xdr_remote_domain_get_scheduler_parameters_ret(); + struct remote_domain_set_scheduler_parameters_args { remote_nonnull_domain dom; @@ -181,44 +216,56 @@ } params; }; typedef struct remote_domain_set_scheduler_parameters_args remote_domain_set_scheduler_parameters_args; +bool_t xdr_remote_domain_set_scheduler_parameters_args(); + struct remote_domain_block_stats_args { remote_nonnull_domain dom; remote_nonnull_string path; }; typedef struct remote_domain_block_stats_args remote_domain_block_stats_args; +bool_t xdr_remote_domain_block_stats_args(); + struct remote_domain_block_stats_ret { - quad_t rd_req; - quad_t rd_bytes; - quad_t wr_req; - quad_t wr_bytes; - quad_t errs; + int64_t rd_req; + int64_t rd_bytes; + int64_t wr_req; + int64_t wr_bytes; + int64_t errs; }; typedef struct remote_domain_block_stats_ret remote_domain_block_stats_ret; +bool_t xdr_remote_domain_block_stats_ret(); + struct remote_domain_interface_stats_args { remote_nonnull_domain dom; remote_nonnull_string path; }; typedef struct remote_domain_interface_stats_args remote_domain_interface_stats_args; +bool_t xdr_remote_domain_interface_stats_args(); + struct remote_domain_interface_stats_ret { - quad_t rx_bytes; - quad_t rx_packets; - quad_t rx_errs; - quad_t rx_drop; - quad_t tx_bytes; - quad_t tx_packets; - quad_t tx_errs; - quad_t tx_drop; + int64_t rx_bytes; + int64_t rx_packets; + int64_t rx_errs; + int64_t rx_drop; + int64_t tx_bytes; + int64_t tx_packets; + int64_t tx_errs; + int64_t tx_drop; }; typedef struct remote_domain_interface_stats_ret remote_domain_interface_stats_ret; +bool_t xdr_remote_domain_interface_stats_ret(); + struct remote_list_domains_args { int maxids; }; typedef struct remote_list_domains_args remote_list_domains_args; +bool_t xdr_remote_list_domains_args(); + struct remote_list_domains_ret { struct { @@ -227,135 +274,185 @@ } ids; }; typedef struct remote_list_domains_ret remote_list_domains_ret; +bool_t xdr_remote_list_domains_ret(); + struct remote_num_of_domains_ret { int num; }; typedef struct remote_num_of_domains_ret remote_num_of_domains_ret; +bool_t xdr_remote_num_of_domains_ret(); + struct remote_domain_create_linux_args { remote_nonnull_string xml_desc; int flags; }; typedef struct remote_domain_create_linux_args remote_domain_create_linux_args; +bool_t xdr_remote_domain_create_linux_args(); + struct remote_domain_create_linux_ret { remote_nonnull_domain dom; }; typedef struct remote_domain_create_linux_ret remote_domain_create_linux_ret; +bool_t xdr_remote_domain_create_linux_ret(); + struct remote_domain_lookup_by_id_args { int id; }; typedef struct remote_domain_lookup_by_id_args remote_domain_lookup_by_id_args; +bool_t xdr_remote_domain_lookup_by_id_args(); + struct remote_domain_lookup_by_id_ret { remote_nonnull_domain dom; }; typedef struct remote_domain_lookup_by_id_ret remote_domain_lookup_by_id_ret; +bool_t xdr_remote_domain_lookup_by_id_ret(); + struct remote_domain_lookup_by_uuid_args { remote_uuid uuid; }; typedef struct remote_domain_lookup_by_uuid_args remote_domain_lookup_by_uuid_args; +bool_t xdr_remote_domain_lookup_by_uuid_args(); + struct remote_domain_lookup_by_uuid_ret { remote_nonnull_domain dom; }; typedef struct remote_domain_lookup_by_uuid_ret remote_domain_lookup_by_uuid_ret; +bool_t xdr_remote_domain_lookup_by_uuid_ret(); + struct remote_domain_lookup_by_name_args { remote_nonnull_string name; }; typedef struct remote_domain_lookup_by_name_args remote_domain_lookup_by_name_args; +bool_t xdr_remote_domain_lookup_by_name_args(); + struct remote_domain_lookup_by_name_ret { remote_nonnull_domain dom; }; typedef struct remote_domain_lookup_by_name_ret remote_domain_lookup_by_name_ret; +bool_t xdr_remote_domain_lookup_by_name_ret(); + struct remote_domain_suspend_args { remote_nonnull_domain dom; }; typedef struct remote_domain_suspend_args remote_domain_suspend_args; +bool_t xdr_remote_domain_suspend_args(); + struct remote_domain_resume_args { remote_nonnull_domain dom; }; typedef struct remote_domain_resume_args remote_domain_resume_args; +bool_t xdr_remote_domain_resume_args(); + struct remote_domain_shutdown_args { remote_nonnull_domain dom; }; typedef struct remote_domain_shutdown_args remote_domain_shutdown_args; +bool_t xdr_remote_domain_shutdown_args(); + struct remote_domain_reboot_args { remote_nonnull_domain dom; int flags; }; typedef struct remote_domain_reboot_args remote_domain_reboot_args; +bool_t xdr_remote_domain_reboot_args(); + struct remote_domain_destroy_args { remote_nonnull_domain dom; }; typedef struct remote_domain_destroy_args remote_domain_destroy_args; +bool_t xdr_remote_domain_destroy_args(); + struct remote_domain_get_os_type_args { remote_nonnull_domain dom; }; typedef struct remote_domain_get_os_type_args remote_domain_get_os_type_args; +bool_t xdr_remote_domain_get_os_type_args(); + struct remote_domain_get_os_type_ret { remote_nonnull_string type; }; typedef struct remote_domain_get_os_type_ret remote_domain_get_os_type_ret; +bool_t xdr_remote_domain_get_os_type_ret(); + struct remote_domain_get_max_memory_args { remote_nonnull_domain dom; }; typedef struct remote_domain_get_max_memory_args remote_domain_get_max_memory_args; +bool_t xdr_remote_domain_get_max_memory_args(); + struct remote_domain_get_max_memory_ret { - u_quad_t memory; + u_int64_t memory; }; typedef struct remote_domain_get_max_memory_ret remote_domain_get_max_memory_ret; +bool_t xdr_remote_domain_get_max_memory_ret(); + struct remote_domain_set_max_memory_args { remote_nonnull_domain dom; - u_quad_t memory; + u_int64_t memory; }; typedef struct remote_domain_set_max_memory_args remote_domain_set_max_memory_args; +bool_t xdr_remote_domain_set_max_memory_args(); + struct remote_domain_set_memory_args { remote_nonnull_domain dom; - u_quad_t memory; + u_int64_t memory; }; typedef struct remote_domain_set_memory_args remote_domain_set_memory_args; +bool_t xdr_remote_domain_set_memory_args(); + struct remote_domain_get_info_args { remote_nonnull_domain dom; }; typedef struct remote_domain_get_info_args remote_domain_get_info_args; +bool_t xdr_remote_domain_get_info_args(); + struct remote_domain_get_info_ret { u_char state; - u_quad_t max_mem; - u_quad_t memory; + u_int64_t max_mem; + u_int64_t memory; u_short nr_virt_cpu; - u_quad_t cpu_time; + u_int64_t cpu_time; }; typedef struct remote_domain_get_info_ret remote_domain_get_info_ret; +bool_t xdr_remote_domain_get_info_ret(); + struct remote_domain_save_args { remote_nonnull_domain dom; remote_nonnull_string to; }; typedef struct remote_domain_save_args remote_domain_save_args; +bool_t xdr_remote_domain_save_args(); + struct remote_domain_restore_args { remote_nonnull_string from; }; typedef struct remote_domain_restore_args remote_domain_restore_args; +bool_t xdr_remote_domain_restore_args(); + struct remote_domain_core_dump_args { remote_nonnull_domain dom; @@ -363,25 +460,33 @@ int flags; }; typedef struct remote_domain_core_dump_args remote_domain_core_dump_args; +bool_t xdr_remote_domain_core_dump_args(); + struct remote_domain_dump_xml_args { remote_nonnull_domain dom; int flags; }; typedef struct remote_domain_dump_xml_args remote_domain_dump_xml_args; +bool_t xdr_remote_domain_dump_xml_args(); + struct remote_domain_dump_xml_ret { remote_nonnull_string xml; }; typedef struct remote_domain_dump_xml_ret remote_domain_dump_xml_ret; +bool_t xdr_remote_domain_dump_xml_ret(); + struct remote_domain_migrate_prepare_args { remote_string uri_in; - u_quad_t flags; + u_int64_t flags; remote_string dname; - u_quad_t resource; + u_int64_t resource; }; typedef struct remote_domain_migrate_prepare_args remote_domain_migrate_prepare_args; +bool_t xdr_remote_domain_migrate_prepare_args(); + struct remote_domain_migrate_prepare_ret { struct { @@ -391,6 +496,8 @@ remote_string uri_out; }; typedef struct remote_domain_migrate_prepare_ret remote_domain_migrate_prepare_ret; +bool_t xdr_remote_domain_migrate_prepare_ret(); + struct remote_domain_migrate_perform_args { remote_nonnull_domain dom; @@ -399,11 +506,13 @@ char *cookie_val; } cookie; remote_nonnull_string uri; - u_quad_t flags; + u_int64_t flags; remote_string dname; - u_quad_t resource; + u_int64_t resource; }; typedef struct remote_domain_migrate_perform_args remote_domain_migrate_perform_args; +bool_t xdr_remote_domain_migrate_perform_args(); + struct remote_domain_migrate_finish_args { remote_nonnull_string dname; @@ -412,19 +521,25 @@ char *cookie_val; } cookie; remote_nonnull_string uri; - u_quad_t flags; + u_int64_t flags; }; typedef struct remote_domain_migrate_finish_args remote_domain_migrate_finish_args; +bool_t xdr_remote_domain_migrate_finish_args(); + struct remote_domain_migrate_finish_ret { remote_nonnull_domain ddom; }; typedef struct remote_domain_migrate_finish_ret remote_domain_migrate_finish_ret; +bool_t xdr_remote_domain_migrate_finish_ret(); + struct remote_list_defined_domains_args { int maxnames; }; typedef struct remote_list_defined_domains_args remote_list_defined_domains_args; +bool_t xdr_remote_list_defined_domains_args(); + struct remote_list_defined_domains_ret { struct { @@ -433,37 +548,51 @@ } names; }; typedef struct remote_list_defined_domains_ret remote_list_defined_domains_ret; +bool_t xdr_remote_list_defined_domains_ret(); + struct remote_num_of_defined_domains_ret { int num; }; typedef struct remote_num_of_defined_domains_ret remote_num_of_defined_domains_ret; +bool_t xdr_remote_num_of_defined_domains_ret(); + struct remote_domain_create_args { remote_nonnull_domain dom; }; typedef struct remote_domain_create_args remote_domain_create_args; +bool_t xdr_remote_domain_create_args(); + struct remote_domain_define_xml_args { remote_nonnull_string xml; }; typedef struct remote_domain_define_xml_args remote_domain_define_xml_args; +bool_t xdr_remote_domain_define_xml_args(); + struct remote_domain_define_xml_ret { remote_nonnull_domain dom; }; typedef struct remote_domain_define_xml_ret remote_domain_define_xml_ret; +bool_t xdr_remote_domain_define_xml_ret(); + struct remote_domain_undefine_args { remote_nonnull_domain dom; }; typedef struct remote_domain_undefine_args remote_domain_undefine_args; +bool_t xdr_remote_domain_undefine_args(); + struct remote_domain_set_vcpus_args { remote_nonnull_domain dom; int nvcpus; }; typedef struct remote_domain_set_vcpus_args remote_domain_set_vcpus_args; +bool_t xdr_remote_domain_set_vcpus_args(); + struct remote_domain_pin_vcpu_args { remote_nonnull_domain dom; @@ -474,6 +603,8 @@ } cpumap; }; typedef struct remote_domain_pin_vcpu_args remote_domain_pin_vcpu_args; +bool_t xdr_remote_domain_pin_vcpu_args(); + struct remote_domain_get_vcpus_args { remote_nonnull_domain dom; @@ -481,6 +612,8 @@ int maplen; }; typedef struct remote_domain_get_vcpus_args remote_domain_get_vcpus_args; +bool_t xdr_remote_domain_get_vcpus_args(); + struct remote_domain_get_vcpus_ret { struct { @@ -493,54 +626,74 @@ } cpumaps; }; typedef struct remote_domain_get_vcpus_ret remote_domain_get_vcpus_ret; +bool_t xdr_remote_domain_get_vcpus_ret(); + struct remote_domain_get_max_vcpus_args { remote_nonnull_domain dom; }; typedef struct remote_domain_get_max_vcpus_args remote_domain_get_max_vcpus_args; +bool_t xdr_remote_domain_get_max_vcpus_args(); + struct remote_domain_get_max_vcpus_ret { int num; }; typedef struct remote_domain_get_max_vcpus_ret remote_domain_get_max_vcpus_ret; +bool_t xdr_remote_domain_get_max_vcpus_ret(); + struct remote_domain_attach_device_args { remote_nonnull_domain dom; remote_nonnull_string xml; }; typedef struct remote_domain_attach_device_args remote_domain_attach_device_args; +bool_t xdr_remote_domain_attach_device_args(); + struct remote_domain_detach_device_args { remote_nonnull_domain dom; remote_nonnull_string xml; }; typedef struct remote_domain_detach_device_args remote_domain_detach_device_args; +bool_t xdr_remote_domain_detach_device_args(); + struct remote_domain_get_autostart_args { remote_nonnull_domain dom; }; typedef struct remote_domain_get_autostart_args remote_domain_get_autostart_args; +bool_t xdr_remote_domain_get_autostart_args(); + struct remote_domain_get_autostart_ret { int autostart; }; typedef struct remote_domain_get_autostart_ret remote_domain_get_autostart_ret; +bool_t xdr_remote_domain_get_autostart_ret(); + struct remote_domain_set_autostart_args { remote_nonnull_domain dom; int autostart; }; typedef struct remote_domain_set_autostart_args remote_domain_set_autostart_args; +bool_t xdr_remote_domain_set_autostart_args(); + struct remote_num_of_networks_ret { int num; }; typedef struct remote_num_of_networks_ret remote_num_of_networks_ret; +bool_t xdr_remote_num_of_networks_ret(); + struct remote_list_networks_args { int maxnames; }; typedef struct remote_list_networks_args remote_list_networks_args; +bool_t xdr_remote_list_networks_args(); + struct remote_list_networks_ret { struct { @@ -549,16 +702,22 @@ } names; }; typedef struct remote_list_networks_ret remote_list_networks_ret; +bool_t xdr_remote_list_networks_ret(); + struct remote_num_of_defined_networks_ret { int num; }; typedef struct remote_num_of_defined_networks_ret remote_num_of_defined_networks_ret; +bool_t xdr_remote_num_of_defined_networks_ret(); + struct remote_list_defined_networks_args { int maxnames; }; typedef struct remote_list_defined_networks_args remote_list_defined_networks_args; +bool_t xdr_remote_list_defined_networks_args(); + struct remote_list_defined_networks_ret { struct { @@ -567,98 +726,136 @@ } names; }; typedef struct remote_list_defined_networks_ret remote_list_defined_networks_ret; +bool_t xdr_remote_list_defined_networks_ret(); + struct remote_network_lookup_by_uuid_args { remote_uuid uuid; }; typedef struct remote_network_lookup_by_uuid_args remote_network_lookup_by_uuid_args; +bool_t xdr_remote_network_lookup_by_uuid_args(); + struct remote_network_lookup_by_uuid_ret { remote_nonnull_network net; }; typedef struct remote_network_lookup_by_uuid_ret remote_network_lookup_by_uuid_ret; +bool_t xdr_remote_network_lookup_by_uuid_ret(); + struct remote_network_lookup_by_name_args { remote_nonnull_string name; }; typedef struct remote_network_lookup_by_name_args remote_network_lookup_by_name_args; +bool_t xdr_remote_network_lookup_by_name_args(); + struct remote_network_lookup_by_name_ret { remote_nonnull_network net; }; typedef struct remote_network_lookup_by_name_ret remote_network_lookup_by_name_ret; +bool_t xdr_remote_network_lookup_by_name_ret(); + struct remote_network_create_xml_args { remote_nonnull_string xml; }; typedef struct remote_network_create_xml_args remote_network_create_xml_args; +bool_t xdr_remote_network_create_xml_args(); + struct remote_network_create_xml_ret { remote_nonnull_network net; }; typedef struct remote_network_create_xml_ret remote_network_create_xml_ret; +bool_t xdr_remote_network_create_xml_ret(); + struct remote_network_define_xml_args { remote_nonnull_string xml; }; typedef struct remote_network_define_xml_args remote_network_define_xml_args; +bool_t xdr_remote_network_define_xml_args(); + struct remote_network_define_xml_ret { remote_nonnull_network net; }; typedef struct remote_network_define_xml_ret remote_network_define_xml_ret; +bool_t xdr_remote_network_define_xml_ret(); + struct remote_network_undefine_args { remote_nonnull_network net; }; typedef struct remote_network_undefine_args remote_network_undefine_args; +bool_t xdr_remote_network_undefine_args(); + struct remote_network_create_args { remote_nonnull_network net; }; typedef struct remote_network_create_args remote_network_create_args; +bool_t xdr_remote_network_create_args(); + struct remote_network_destroy_args { remote_nonnull_network net; }; typedef struct remote_network_destroy_args remote_network_destroy_args; +bool_t xdr_remote_network_destroy_args(); + struct remote_network_dump_xml_args { remote_nonnull_network net; int flags; }; typedef struct remote_network_dump_xml_args remote_network_dump_xml_args; +bool_t xdr_remote_network_dump_xml_args(); + struct remote_network_dump_xml_ret { remote_nonnull_string xml; }; typedef struct remote_network_dump_xml_ret remote_network_dump_xml_ret; +bool_t xdr_remote_network_dump_xml_ret(); + struct remote_network_get_bridge_name_args { remote_nonnull_network net; }; typedef struct remote_network_get_bridge_name_args remote_network_get_bridge_name_args; +bool_t xdr_remote_network_get_bridge_name_args(); + struct remote_network_get_bridge_name_ret { remote_nonnull_string name; }; typedef struct remote_network_get_bridge_name_ret remote_network_get_bridge_name_ret; +bool_t xdr_remote_network_get_bridge_name_ret(); + struct remote_network_get_autostart_args { remote_nonnull_network net; }; typedef struct remote_network_get_autostart_args remote_network_get_autostart_args; +bool_t xdr_remote_network_get_autostart_args(); + struct remote_network_get_autostart_ret { int autostart; }; typedef struct remote_network_get_autostart_ret remote_network_get_autostart_ret; +bool_t xdr_remote_network_get_autostart_ret(); + struct remote_network_set_autostart_args { remote_nonnull_network net; int autostart; }; typedef struct remote_network_set_autostart_args remote_network_set_autostart_args; +bool_t xdr_remote_network_set_autostart_args(); + #define REMOTE_PROGRAM 0x20008086 #define REMOTE_PROTOCOL_VERSION 1 @@ -730,6 +927,8 @@ REMOTE_PROC_DOMAIN_INTERFACE_STATS = 65, }; typedef enum remote_procedure remote_procedure; +bool_t xdr_remote_procedure(); + enum remote_message_direction { REMOTE_CALL = 0, @@ -737,12 +936,16 @@ REMOTE_MESSAGE = 2, }; typedef enum remote_message_direction remote_message_direction; +bool_t xdr_remote_message_direction(); + enum remote_message_status { REMOTE_OK = 0, REMOTE_ERROR = 1, }; typedef enum remote_message_status remote_message_status; +bool_t xdr_remote_message_status(); + #define REMOTE_MESSAGE_HEADER_XDR_LEN 4 struct remote_message_header { @@ -754,237 +957,5 @@ remote_message_status status; }; typedef struct remote_message_header remote_message_header; +bool_t xdr_remote_message_header(); -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_remote_nonnull_string (XDR *, remote_nonnull_string*); -extern bool_t xdr_remote_string (XDR *, remote_string*); -extern bool_t xdr_remote_uuid (XDR *, remote_uuid); -extern bool_t xdr_remote_nonnull_domain (XDR *, remote_nonnull_domain*); -extern bool_t xdr_remote_nonnull_network (XDR *, remote_nonnull_network*); -extern bool_t xdr_remote_domain (XDR *, remote_domain*); -extern bool_t xdr_remote_network (XDR *, remote_network*); -extern bool_t xdr_remote_error (XDR *, remote_error*); -extern bool_t xdr_remote_vcpu_info (XDR *, remote_vcpu_info*); -extern bool_t xdr_remote_sched_param_value (XDR *, remote_sched_param_value*); -extern bool_t xdr_remote_sched_param (XDR *, remote_sched_param*); -extern bool_t xdr_remote_open_args (XDR *, remote_open_args*); -extern bool_t xdr_remote_supports_feature_args (XDR *, remote_supports_feature_args*); -extern bool_t xdr_remote_supports_feature_ret (XDR *, remote_supports_feature_ret*); -extern bool_t xdr_remote_get_type_ret (XDR *, remote_get_type_ret*); -extern bool_t xdr_remote_get_version_ret (XDR *, remote_get_version_ret*); -extern bool_t xdr_remote_get_hostname_ret (XDR *, remote_get_hostname_ret*); -extern bool_t xdr_remote_get_max_vcpus_args (XDR *, remote_get_max_vcpus_args*); -extern bool_t xdr_remote_get_max_vcpus_ret (XDR *, remote_get_max_vcpus_ret*); -extern bool_t xdr_remote_node_get_info_ret (XDR *, remote_node_get_info_ret*); -extern bool_t xdr_remote_get_capabilities_ret (XDR *, remote_get_capabilities_ret*); -extern bool_t xdr_remote_domain_get_scheduler_type_args (XDR *, remote_domain_get_scheduler_type_args*); -extern bool_t xdr_remote_domain_get_scheduler_type_ret (XDR *, remote_domain_get_scheduler_type_ret*); -extern bool_t xdr_remote_domain_get_scheduler_parameters_args (XDR *, remote_domain_get_scheduler_parameters_args*); -extern bool_t xdr_remote_domain_get_scheduler_parameters_ret (XDR *, remote_domain_get_scheduler_parameters_ret*); -extern bool_t xdr_remote_domain_set_scheduler_parameters_args (XDR *, remote_domain_set_scheduler_parameters_args*); -extern bool_t xdr_remote_domain_block_stats_args (XDR *, remote_domain_block_stats_args*); -extern bool_t xdr_remote_domain_block_stats_ret (XDR *, remote_domain_block_stats_ret*); -extern bool_t xdr_remote_domain_interface_stats_args (XDR *, remote_domain_interface_stats_args*); -extern bool_t xdr_remote_domain_interface_stats_ret (XDR *, remote_domain_interface_stats_ret*); -extern bool_t xdr_remote_list_domains_args (XDR *, remote_list_domains_args*); -extern bool_t xdr_remote_list_domains_ret (XDR *, remote_list_domains_ret*); -extern bool_t xdr_remote_num_of_domains_ret (XDR *, remote_num_of_domains_ret*); -extern bool_t xdr_remote_domain_create_linux_args (XDR *, remote_domain_create_linux_args*); -extern bool_t xdr_remote_domain_create_linux_ret (XDR *, remote_domain_create_linux_ret*); -extern bool_t xdr_remote_domain_lookup_by_id_args (XDR *, remote_domain_lookup_by_id_args*); -extern bool_t xdr_remote_domain_lookup_by_id_ret (XDR *, remote_domain_lookup_by_id_ret*); -extern bool_t xdr_remote_domain_lookup_by_uuid_args (XDR *, remote_domain_lookup_by_uuid_args*); -extern bool_t xdr_remote_domain_lookup_by_uuid_ret (XDR *, remote_domain_lookup_by_uuid_ret*); -extern bool_t xdr_remote_domain_lookup_by_name_args (XDR *, remote_domain_lookup_by_name_args*); -extern bool_t xdr_remote_domain_lookup_by_name_ret (XDR *, remote_domain_lookup_by_name_ret*); -extern bool_t xdr_remote_domain_suspend_args (XDR *, remote_domain_suspend_args*); -extern bool_t xdr_remote_domain_resume_args (XDR *, remote_domain_resume_args*); -extern bool_t xdr_remote_domain_shutdown_args (XDR *, remote_domain_shutdown_args*); -extern bool_t xdr_remote_domain_reboot_args (XDR *, remote_domain_reboot_args*); -extern bool_t xdr_remote_domain_destroy_args (XDR *, remote_domain_destroy_args*); -extern bool_t xdr_remote_domain_get_os_type_args (XDR *, remote_domain_get_os_type_args*); -extern bool_t xdr_remote_domain_get_os_type_ret (XDR *, remote_domain_get_os_type_ret*); -extern bool_t xdr_remote_domain_get_max_memory_args (XDR *, remote_domain_get_max_memory_args*); -extern bool_t xdr_remote_domain_get_max_memory_ret (XDR *, remote_domain_get_max_memory_ret*); -extern bool_t xdr_remote_domain_set_max_memory_args (XDR *, remote_domain_set_max_memory_args*); -extern bool_t xdr_remote_domain_set_memory_args (XDR *, remote_domain_set_memory_args*); -extern bool_t xdr_remote_domain_get_info_args (XDR *, remote_domain_get_info_args*); -extern bool_t xdr_remote_domain_get_info_ret (XDR *, remote_domain_get_info_ret*); -extern bool_t xdr_remote_domain_save_args (XDR *, remote_domain_save_args*); -extern bool_t xdr_remote_domain_restore_args (XDR *, remote_domain_restore_args*); -extern bool_t xdr_remote_domain_core_dump_args (XDR *, remote_domain_core_dump_args*); -extern bool_t xdr_remote_domain_dump_xml_args (XDR *, remote_domain_dump_xml_args*); -extern bool_t xdr_remote_domain_dump_xml_ret (XDR *, remote_domain_dump_xml_ret*); -extern bool_t xdr_remote_domain_migrate_prepare_args (XDR *, remote_domain_migrate_prepare_args*); -extern bool_t xdr_remote_domain_migrate_prepare_ret (XDR *, remote_domain_migrate_prepare_ret*); -extern bool_t xdr_remote_domain_migrate_perform_args (XDR *, remote_domain_migrate_perform_args*); -extern bool_t xdr_remote_domain_migrate_finish_args (XDR *, remote_domain_migrate_finish_args*); -extern bool_t xdr_remote_domain_migrate_finish_ret (XDR *, remote_domain_migrate_finish_ret*); -extern bool_t xdr_remote_list_defined_domains_args (XDR *, remote_list_defined_domains_args*); -extern bool_t xdr_remote_list_defined_domains_ret (XDR *, remote_list_defined_domains_ret*); -extern bool_t xdr_remote_num_of_defined_domains_ret (XDR *, remote_num_of_defined_domains_ret*); -extern bool_t xdr_remote_domain_create_args (XDR *, remote_domain_create_args*); -extern bool_t xdr_remote_domain_define_xml_args (XDR *, remote_domain_define_xml_args*); -extern bool_t xdr_remote_domain_define_xml_ret (XDR *, remote_domain_define_xml_ret*); -extern bool_t xdr_remote_domain_undefine_args (XDR *, remote_domain_undefine_args*); -extern bool_t xdr_remote_domain_set_vcpus_args (XDR *, remote_domain_set_vcpus_args*); -extern bool_t xdr_remote_domain_pin_vcpu_args (XDR *, remote_domain_pin_vcpu_args*); -extern bool_t xdr_remote_domain_get_vcpus_args (XDR *, remote_domain_get_vcpus_args*); -extern bool_t xdr_remote_domain_get_vcpus_ret (XDR *, remote_domain_get_vcpus_ret*); -extern bool_t xdr_remote_domain_get_max_vcpus_args (XDR *, remote_domain_get_max_vcpus_args*); -extern bool_t xdr_remote_domain_get_max_vcpus_ret (XDR *, remote_domain_get_max_vcpus_ret*); -extern bool_t xdr_remote_domain_attach_device_args (XDR *, remote_domain_attach_device_args*); -extern bool_t xdr_remote_domain_detach_device_args (XDR *, remote_domain_detach_device_args*); -extern bool_t xdr_remote_domain_get_autostart_args (XDR *, remote_domain_get_autostart_args*); -extern bool_t xdr_remote_domain_get_autostart_ret (XDR *, remote_domain_get_autostart_ret*); -extern bool_t xdr_remote_domain_set_autostart_args (XDR *, remote_domain_set_autostart_args*); -extern bool_t xdr_remote_num_of_networks_ret (XDR *, remote_num_of_networks_ret*); -extern bool_t xdr_remote_list_networks_args (XDR *, remote_list_networks_args*); -extern bool_t xdr_remote_list_networks_ret (XDR *, remote_list_networks_ret*); -extern bool_t xdr_remote_num_of_defined_networks_ret (XDR *, remote_num_of_defined_networks_ret*); -extern bool_t xdr_remote_list_defined_networks_args (XDR *, remote_list_defined_networks_args*); -extern bool_t xdr_remote_list_defined_networks_ret (XDR *, remote_list_defined_networks_ret*); -extern bool_t xdr_remote_network_lookup_by_uuid_args (XDR *, remote_network_lookup_by_uuid_args*); -extern bool_t xdr_remote_network_lookup_by_uuid_ret (XDR *, remote_network_lookup_by_uuid_ret*); -extern bool_t xdr_remote_network_lookup_by_name_args (XDR *, remote_network_lookup_by_name_args*); -extern bool_t xdr_remote_network_lookup_by_name_ret (XDR *, remote_network_lookup_by_name_ret*); -extern bool_t xdr_remote_network_create_xml_args (XDR *, remote_network_create_xml_args*); -extern bool_t xdr_remote_network_create_xml_ret (XDR *, remote_network_create_xml_ret*); -extern bool_t xdr_remote_network_define_xml_args (XDR *, remote_network_define_xml_args*); -extern bool_t xdr_remote_network_define_xml_ret (XDR *, remote_network_define_xml_ret*); -extern bool_t xdr_remote_network_undefine_args (XDR *, remote_network_undefine_args*); -extern bool_t xdr_remote_network_create_args (XDR *, remote_network_create_args*); -extern bool_t xdr_remote_network_destroy_args (XDR *, remote_network_destroy_args*); -extern bool_t xdr_remote_network_dump_xml_args (XDR *, remote_network_dump_xml_args*); -extern bool_t xdr_remote_network_dump_xml_ret (XDR *, remote_network_dump_xml_ret*); -extern bool_t xdr_remote_network_get_bridge_name_args (XDR *, remote_network_get_bridge_name_args*); -extern bool_t xdr_remote_network_get_bridge_name_ret (XDR *, remote_network_get_bridge_name_ret*); -extern bool_t xdr_remote_network_get_autostart_args (XDR *, remote_network_get_autostart_args*); -extern bool_t xdr_remote_network_get_autostart_ret (XDR *, remote_network_get_autostart_ret*); -extern bool_t xdr_remote_network_set_autostart_args (XDR *, remote_network_set_autostart_args*); -extern bool_t xdr_remote_procedure (XDR *, remote_procedure*); -extern bool_t xdr_remote_message_direction (XDR *, remote_message_direction*); -extern bool_t xdr_remote_message_status (XDR *, remote_message_status*); -extern bool_t xdr_remote_message_header (XDR *, remote_message_header*); - -#else /* K&R C */ -extern bool_t xdr_remote_nonnull_string (); -extern bool_t xdr_remote_string (); -extern bool_t xdr_remote_uuid (); -extern bool_t xdr_remote_nonnull_domain (); -extern bool_t xdr_remote_nonnull_network (); -extern bool_t xdr_remote_domain (); -extern bool_t xdr_remote_network (); -extern bool_t xdr_remote_error (); -extern bool_t xdr_remote_vcpu_info (); -extern bool_t xdr_remote_sched_param_value (); -extern bool_t xdr_remote_sched_param (); -extern bool_t xdr_remote_open_args (); -extern bool_t xdr_remote_supports_feature_args (); -extern bool_t xdr_remote_supports_feature_ret (); -extern bool_t xdr_remote_get_type_ret (); -extern bool_t xdr_remote_get_version_ret (); -extern bool_t xdr_remote_get_hostname_ret (); -extern bool_t xdr_remote_get_max_vcpus_args (); -extern bool_t xdr_remote_get_max_vcpus_ret (); -extern bool_t xdr_remote_node_get_info_ret (); -extern bool_t xdr_remote_get_capabilities_ret (); -extern bool_t xdr_remote_domain_get_scheduler_type_args (); -extern bool_t xdr_remote_domain_get_scheduler_type_ret (); -extern bool_t xdr_remote_domain_get_scheduler_parameters_args (); -extern bool_t xdr_remote_domain_get_scheduler_parameters_ret (); -extern bool_t xdr_remote_domain_set_scheduler_parameters_args (); -extern bool_t xdr_remote_domain_block_stats_args (); -extern bool_t xdr_remote_domain_block_stats_ret (); -extern bool_t xdr_remote_domain_interface_stats_args (); -extern bool_t xdr_remote_domain_interface_stats_ret (); -extern bool_t xdr_remote_list_domains_args (); -extern bool_t xdr_remote_list_domains_ret (); -extern bool_t xdr_remote_num_of_domains_ret (); -extern bool_t xdr_remote_domain_create_linux_args (); -extern bool_t xdr_remote_domain_create_linux_ret (); -extern bool_t xdr_remote_domain_lookup_by_id_args (); -extern bool_t xdr_remote_domain_lookup_by_id_ret (); -extern bool_t xdr_remote_domain_lookup_by_uuid_args (); -extern bool_t xdr_remote_domain_lookup_by_uuid_ret (); -extern bool_t xdr_remote_domain_lookup_by_name_args (); -extern bool_t xdr_remote_domain_lookup_by_name_ret (); -extern bool_t xdr_remote_domain_suspend_args (); -extern bool_t xdr_remote_domain_resume_args (); -extern bool_t xdr_remote_domain_shutdown_args (); -extern bool_t xdr_remote_domain_reboot_args (); -extern bool_t xdr_remote_domain_destroy_args (); -extern bool_t xdr_remote_domain_get_os_type_args (); -extern bool_t xdr_remote_domain_get_os_type_ret (); -extern bool_t xdr_remote_domain_get_max_memory_args (); -extern bool_t xdr_remote_domain_get_max_memory_ret (); -extern bool_t xdr_remote_domain_set_max_memory_args (); -extern bool_t xdr_remote_domain_set_memory_args (); -extern bool_t xdr_remote_domain_get_info_args (); -extern bool_t xdr_remote_domain_get_info_ret (); -extern bool_t xdr_remote_domain_save_args (); -extern bool_t xdr_remote_domain_restore_args (); -extern bool_t xdr_remote_domain_core_dump_args (); -extern bool_t xdr_remote_domain_dump_xml_args (); -extern bool_t xdr_remote_domain_dump_xml_ret (); -extern bool_t xdr_remote_domain_migrate_prepare_args (); -extern bool_t xdr_remote_domain_migrate_prepare_ret (); -extern bool_t xdr_remote_domain_migrate_perform_args (); -extern bool_t xdr_remote_domain_migrate_finish_args (); -extern bool_t xdr_remote_domain_migrate_finish_ret (); -extern bool_t xdr_remote_list_defined_domains_args (); -extern bool_t xdr_remote_list_defined_domains_ret (); -extern bool_t xdr_remote_num_of_defined_domains_ret (); -extern bool_t xdr_remote_domain_create_args (); -extern bool_t xdr_remote_domain_define_xml_args (); -extern bool_t xdr_remote_domain_define_xml_ret (); -extern bool_t xdr_remote_domain_undefine_args (); -extern bool_t xdr_remote_domain_set_vcpus_args (); -extern bool_t xdr_remote_domain_pin_vcpu_args (); -extern bool_t xdr_remote_domain_get_vcpus_args (); -extern bool_t xdr_remote_domain_get_vcpus_ret (); -extern bool_t xdr_remote_domain_get_max_vcpus_args (); -extern bool_t xdr_remote_domain_get_max_vcpus_ret (); -extern bool_t xdr_remote_domain_attach_device_args (); -extern bool_t xdr_remote_domain_detach_device_args (); -extern bool_t xdr_remote_domain_get_autostart_args (); -extern bool_t xdr_remote_domain_get_autostart_ret (); -extern bool_t xdr_remote_domain_set_autostart_args (); -extern bool_t xdr_remote_num_of_networks_ret (); -extern bool_t xdr_remote_list_networks_args (); -extern bool_t xdr_remote_list_networks_ret (); -extern bool_t xdr_remote_num_of_defined_networks_ret (); -extern bool_t xdr_remote_list_defined_networks_args (); -extern bool_t xdr_remote_list_defined_networks_ret (); -extern bool_t xdr_remote_network_lookup_by_uuid_args (); -extern bool_t xdr_remote_network_lookup_by_uuid_ret (); -extern bool_t xdr_remote_network_lookup_by_name_args (); -extern bool_t xdr_remote_network_lookup_by_name_ret (); -extern bool_t xdr_remote_network_create_xml_args (); -extern bool_t xdr_remote_network_create_xml_ret (); -extern bool_t xdr_remote_network_define_xml_args (); -extern bool_t xdr_remote_network_define_xml_ret (); -extern bool_t xdr_remote_network_undefine_args (); -extern bool_t xdr_remote_network_create_args (); -extern bool_t xdr_remote_network_destroy_args (); -extern bool_t xdr_remote_network_dump_xml_args (); -extern bool_t xdr_remote_network_dump_xml_ret (); -extern bool_t xdr_remote_network_get_bridge_name_args (); -extern bool_t xdr_remote_network_get_bridge_name_ret (); -extern bool_t xdr_remote_network_get_autostart_args (); -extern bool_t xdr_remote_network_get_autostart_ret (); -extern bool_t xdr_remote_network_set_autostart_args (); -extern bool_t xdr_remote_procedure (); -extern bool_t xdr_remote_message_direction (); -extern bool_t xdr_remote_message_status (); -extern bool_t xdr_remote_message_header (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_REMOTE_PROTOCOL_H_RPCGEN */ Index: src/Makefile.am =================================================================== RCS file: /data/cvs/libvirt/src/Makefile.am,v retrieving revision 1.55 diff -u -r1.55 Makefile.am --- src/Makefile.am 17 Nov 2007 11:17:48 -0000 1.55 +++ src/Makefile.am 29 Nov 2007 16:04:06 -0000 @@ -24,11 +24,6 @@ EXTRA_DIST = libvirt_sym.version $(conf_DATA) lib_LTLIBRARIES = libvirt.la -libvirt_la_LIBADD = $(LIBXML_LIBS) $(GNUTLS_LIBS) -libvirt_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libvirt_sym.version \ - -version-info @LIBVIRT_VERSION_INFO@ \ - $(COVERAGE_CFLAGS:-f%=-Wc,-f%) -libvirt_la_CFLAGS = $(COVERAGE_CFLAGS) CLIENT_SOURCES = \ libvirt.c internal.h \ @@ -64,6 +59,13 @@ ../qemud/remote_protocol.c ../qemud/remote_protocol.h libvirt_la_SOURCES = $(CLIENT_SOURCES) $(SERVER_SOURCES) +libvirt_la_LIBADD = $(LIBXML_LIBS) $(GNUTLS_LIBS) $(LTLIBOBJS) \ + @CYGWIN_EXTRA_LIBADD@ +libvirt_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libvirt_sym.version \ + -version-info @LIBVIRT_VERSION_INFO@ \ + $(COVERAGE_CFLAGS:-f%=-Wc,-f%) \ + @CYGWIN_EXTRA_LDFLAGS@ +libvirt_la_CFLAGS = $(COVERAGE_CFLAGS) bin_PROGRAMS = virsh Index: src/getaddrinfo.c =================================================================== RCS file: src/getaddrinfo.c diff -N src/getaddrinfo.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/getaddrinfo.c 29 Nov 2007 16:04:07 -0000 @@ -0,0 +1,593 @@ +/* + * Copyright (c) 2001, 02 Motoyuki Kasahara + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * This program provides getaddrinfo() and getnameinfo() described in + * RFC2133, 2553 and 3493. These functions are mainly used for IPv6 + * application to resolve hostname or address. + * + * This program is designed to be working on traditional IPv4 systems + * which don't have those functions. Therefore, this implementation + * supports IPv4 only. + * + * This program is useful for application which should support both IPv6 + * and traditional IPv4 systems. Use genuine getaddrinfo() and getnameinfo() + * provided by system if the system supports IPv6. Otherwise, use this + * implementation. + * + * This program is intended to be used in combination with GNU Autoconf. + * + * This program also provides freeaddrinfo() and gai_strerror(). + * + * To use this program in your application, insert the following lines to + * C source files after including `sys/types.h', `sys/socket.h' and + * `netdb.h'. `getaddrinfo.h' defines `struct addrinfo' and AI_, NI_, + * EAI_ macros. + * + * #ifndef HAVE_GETADDRINFO + * #include "getaddrinfo.h" + * #endif + * + * Restriction: + * getaddrinfo() and getnameinfo() of this program are NOT thread + * safe, unless the cpp macro ENABLE_PTHREAD is defined. + */ + +/* + * Add the following code to your configure.ac (or configure.in). + * AC_C_CONST + * AC_HEADER_STDC + * AC_CHECK_HEADERS(string.h memory.h stdlib.h) + * AC_CHECK_FUNCS(memcpy) + * AC_REPLACE_FUNCS(memset) + * AC_TYPE_SOCKLEN_T + * AC_TYPE_IN_PORT_T + * AC_DECL_H_ERRNO + * + * AC_CHECK_FUNCS(getaddrinfo getnameinfo) + * if test "$ac_cv_func_getaddrinfo$ac_cv_func_getnameinfo" != yesyes ; then + * LIBOBJS="$LIBOBJS getaddrinfo.$ac_objext" + * fi + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include +#include +#include +#include + +#if defined(STDC_HEADERS) || defined(HAVE_STRING_H) +#include +#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H) +#include +#endif /* not STDC_HEADERS and HAVE_MEMORY_H */ +#else /* not STDC_HEADERS and not HAVE_STRING_H */ +#include +#endif /* not STDC_HEADERS and not HAVE_STRING_H */ + +#ifdef HAVE_STDLIB_H +#include +#endif + +#ifdef ENABLE_PTHREAD +#include +#endif + +#ifdef ENABLE_NLS +#include +#endif + +#ifndef HAVE_MEMCPY +#define memcpy(d, s, n) bcopy((s), (d), (n)) +#ifdef __STDC__ +void *memchr(const void *, int, size_t); +int memcmp(const void *, const void *, size_t); +void *memmove(void *, const void *, size_t); +void *memset(void *, int, size_t); +#else /* not __STDC__ */ +char *memchr(); +int memcmp(); +char *memmove(); +char *memset(); +#endif /* not __STDC__ */ +#endif /* not HAVE_MEMCPY */ + +#ifndef H_ERRNO_DECLARED +extern int h_errno; +#endif + +#include "getaddrinfo.h" + +#ifdef ENABLE_NLS +#define _(string) gettext(string) +#ifdef gettext_noop +#define N_(string) gettext_noop(string) +#else +#define N_(string) (string) +#endif +#else +#define gettext(string) (string) +#define _(string) (string) +#define N_(string) (string) +#endif + +/* + * Error messages for gai_strerror(). + */ +static char *eai_errlist[] = { + N_("Success"), + + /* EAI_ADDRFAMILY */ + N_("Address family for hostname not supported"), + + /* EAI_AGAIN */ + N_("Temporary failure in name resolution"), + + /* EAI_BADFLAGS */ + N_("Invalid value for ai_flags"), + + /* EAI_FAIL */ + N_("Non-recoverable failure in name resolution"), + + /* EAI_FAMILY */ + N_("ai_family not supported"), + + /* EAI_MEMORY */ + N_("Memory allocation failure"), + + /* EAI_NONAME */ + N_("hostname nor servname provided, or not known"), + + /* EAI_OVERFLOW */ + N_("An argument buffer overflowed"), + + /* EAI_SERVICE */ + N_("servname not supported for ai_socktype"), + + /* EAI_SOCKTYPE */ + N_("ai_socktype not supported"), + + /* EAI_SYSTEM */ + N_("System error returned in errno") +}; + +/* + * Default hints for getaddrinfo(). + */ +static struct addrinfo default_hints = { + 0, PF_UNSPEC, 0, 0, 0, NULL, NULL, NULL +}; + +/* + * Mutex. + */ +#ifdef ENABLE_PTHREAD +static pthread_mutex_t gai_mutex = PTHREAD_MUTEX_INITIALIZER; +#endif + +/* + * Declaration of static functions. + */ +#ifdef __STDC__ +static int is_integer(const char *); +static int is_address(const char *); +static int itoa_length(int); +#else +static int is_integer(); +static int is_address(); +static int itoa_length(); +#endif + +/* + * gai_strerror(). + */ +const char * +gai_strerror(ecode) + int ecode; +{ + if (ecode < 0 || ecode > EAI_SYSTEM) + return _("Unknown error"); + + return gettext(eai_errlist[ecode]); +} + +/* + * freeaddrinfo(). + */ +void +freeaddrinfo(ai) + struct addrinfo *ai; +{ + struct addrinfo *next_ai; + + while (ai != NULL) { + if (ai->ai_canonname != NULL) + free(ai->ai_canonname); + if (ai->ai_addr != NULL) + free(ai->ai_addr); + next_ai = ai->ai_next; + free(ai); + ai = next_ai; + } +} + +/* + * Return 1 if the string `s' represents an integer. + */ +static int +is_integer(s) + const char *s; +{ + if (*s == '-' || *s == '+') + s++; + if (*s < '0' || '9' < *s) + return 0; + + s++; + while ('0' <= *s && *s <= '9') + s++; + + return (*s == '\0'); +} + +/* + * Return 1 if the string `s' represents an IPv4 address. + * Unlike inet_addr(), it doesn't permit malformed nortation such + * as "192.168". + */ +static int +is_address(s) + const char *s; +{ + const static char delimiters[] = {'.', '.', '.', '\0'}; + int i, j; + int octet; + + for (i = 0; i < 4; i++) { + if (*s == '0' && *(s + 1) != delimiters[i]) + return 0; + for (j = 0, octet = 0; '0' <= *s && *s <= '9' && j < 3; s++, j++) + octet = octet * 10 + (*s - '0'); + if (j == 0 || octet > 255 || *s != delimiters[i]) + return 0; + s++; + } + + return 1; +} + +/* + * Calcurate length of the string `s', where `s' is set by + * sprintf(s, "%d", n). + */ +static int +itoa_length(n) + int n; +{ + int result = 1; + + if (n < 0) { + n = -n; + result++; + } + + while (n >= 10) { + result++; + n /= 10; + } + + return result; +} + +/* + * getaddrinfo(). + */ +int +getaddrinfo(nodename, servname, hints, res) + const char *nodename; + const char *servname; + const struct addrinfo *hints; + struct addrinfo **res; +{ + struct addrinfo *head_res = NULL; + struct addrinfo *tail_res = NULL; + struct addrinfo *new_res; + struct sockaddr_in *sa_in; + struct in_addr **addr_list; + struct in_addr *addr_list_buf[2]; + struct in_addr addr_buf; + struct in_addr **ap; + struct servent *servent; + struct hostent *hostent; + const char *canonname = NULL; + in_port_t port; + int saved_h_errno; + int result = 0; + +#ifdef ENABLE_PTHREAD + pthread_mutex_lock(&gai_mutex); +#endif + + saved_h_errno = h_errno; + + if (nodename == NULL && servname == NULL) { + result = EAI_NONAME; + goto end; + } + + if (hints != NULL) { + if (hints->ai_family != PF_INET && hints->ai_family != PF_UNSPEC) { + result = EAI_FAMILY; + goto end; + } + if (hints->ai_socktype != SOCK_DGRAM + && hints->ai_socktype != SOCK_STREAM + && hints->ai_socktype != 0) { + result = EAI_SOCKTYPE; + goto end; + } + } else { + hints = &default_hints; + } + + if (servname != NULL) { + if (is_integer(servname)) + port = htons(atoi(servname)); + else { + if (hints->ai_flags & AI_NUMERICSERV) { + result = EAI_NONAME; + goto end; + } + + if (hints->ai_socktype == SOCK_DGRAM) + servent = getservbyname(servname, "udp"); + else if (hints->ai_socktype == SOCK_STREAM) + servent = getservbyname(servname, "tcp"); + else if (hints->ai_socktype == 0) + servent = getservbyname(servname, "tcp"); + else { + result = EAI_SOCKTYPE; + goto end; + } + + if (servent == NULL) { + result = EAI_SERVICE; + goto end; + } + port = servent->s_port; + } + } else { + port = htons(0); + } + + if (nodename != NULL) { + if (is_address(nodename)) { + addr_buf.s_addr = inet_addr(nodename); + addr_list_buf[0] = &addr_buf; + addr_list_buf[1] = NULL; + addr_list = addr_list_buf; + + if (hints->ai_flags & AI_CANONNAME + && !(hints->ai_flags & AI_NUMERICHOST)) { + hostent = gethostbyaddr((char *)&addr_buf, + sizeof(struct in_addr), AF_INET); + if (hostent != NULL) + canonname = hostent->h_name; + else + canonname = nodename; + } + } else { + if (hints->ai_flags & AI_NUMERICHOST) { + result = EAI_NONAME; + goto end; + } + + hostent = gethostbyname(nodename); + if (hostent == NULL) { + switch (h_errno) { + case HOST_NOT_FOUND: + case NO_DATA: + result = EAI_NONAME; + goto end; + case TRY_AGAIN: + result = EAI_AGAIN; + goto end; + default: + result = EAI_FAIL; + goto end; + } + } + addr_list = (struct in_addr **)hostent->h_addr_list; + + if (hints->ai_flags & AI_CANONNAME) + canonname = hostent->h_name; + } + } else { + if (hints->ai_flags & AI_PASSIVE) + addr_buf.s_addr = htonl(INADDR_ANY); + else + addr_buf.s_addr = htonl(0x7F000001); + addr_list_buf[0] = &addr_buf; + addr_list_buf[1] = NULL; + addr_list = addr_list_buf; + } + + for (ap = addr_list; *ap != NULL; ap++) { + new_res = (struct addrinfo *)malloc(sizeof(struct addrinfo)); + if (new_res == NULL) { + if (head_res != NULL) + freeaddrinfo(head_res); + result = EAI_MEMORY; + goto end; + } + + new_res->ai_family = PF_INET; + new_res->ai_socktype = hints->ai_socktype; + new_res->ai_protocol = hints->ai_protocol; + new_res->ai_addr = NULL; + new_res->ai_addrlen = sizeof(struct sockaddr_in); + new_res->ai_canonname = NULL; + new_res->ai_next = NULL; + + new_res->ai_addr = (struct sockaddr *) + malloc(sizeof(struct sockaddr_in)); + if (new_res->ai_addr == NULL) { + free(new_res); + if (head_res != NULL) + freeaddrinfo(head_res); + result = EAI_MEMORY; + goto end; + } + + sa_in = (struct sockaddr_in *)new_res->ai_addr; + memset(sa_in, 0, sizeof(struct sockaddr_in)); + sa_in->sin_family = PF_INET; + sa_in->sin_port = port; + memcpy(&sa_in->sin_addr, *ap, sizeof(struct in_addr)); + + if (head_res == NULL) + head_res = new_res; + else + tail_res->ai_next = new_res; + tail_res = new_res; + } + + if (canonname != NULL && head_res != NULL) { + head_res->ai_canonname = (char *)malloc(strlen(canonname) + 1); + if (head_res->ai_canonname != NULL) + strcpy(head_res->ai_canonname, canonname); + } + + *res = head_res; + + end: + h_errno = saved_h_errno; +#ifdef ENABLE_PTHREAD + pthread_mutex_unlock(&gai_mutex); +#endif + return result; +} + +/* + * getnameinfo(). + */ +int +getnameinfo(sa, salen, node, nodelen, serv, servlen, flags) + const struct sockaddr *sa; + socklen_t salen; + char *node; + socklen_t nodelen; + char *serv; + socklen_t servlen; + int flags; +{ + const struct sockaddr_in *sa_in = (const struct sockaddr_in *)sa; + struct hostent *hostent; + struct servent *servent; + char *ntoa_address; + int saved_h_errno; + int result = 0; + +#ifdef ENABLE_PTHREAD + pthread_mutex_lock(&gai_mutex); +#endif + + saved_h_errno = h_errno; + + if (sa_in->sin_family != PF_INET) { + result = EAI_FAMILY; + goto end; + } else if (node == NULL && serv == NULL) { + result = EAI_NONAME; + goto end; + } + + if (serv != NULL && servlen > 0) { + if (flags & NI_NUMERICSERV) + servent = NULL; + else if (flags & NI_DGRAM) + servent = getservbyport(sa_in->sin_port, "udp"); + else + servent = getservbyport(sa_in->sin_port, "tcp"); + + if (servent != NULL) { + if (servlen <= strlen(servent->s_name)) { + result = EAI_OVERFLOW; + goto end; + } + strcpy(serv, servent->s_name); + } else { + if (servlen <= itoa_length(ntohs(sa_in->sin_port))) { + result = EAI_OVERFLOW; + goto end; + } + sprintf(serv, "%d", ntohs(sa_in->sin_port)); + } + } + + if (node != NULL && nodelen > 0) { + if (flags & NI_NUMERICHOST) + hostent = NULL; + else { + hostent = gethostbyaddr((char *)&sa_in->sin_addr, + sizeof(struct in_addr), AF_INET); + } + if (hostent != NULL) { + if (nodelen <= strlen(hostent->h_name)) { + result = EAI_OVERFLOW; + goto end; + } + strcpy(node, hostent->h_name); + } else { + if (flags & NI_NAMEREQD) { + result = EAI_NONAME; + goto end; + } + ntoa_address = inet_ntoa(sa_in->sin_addr); + if (nodelen <= strlen(ntoa_address)) { + result = EAI_OVERFLOW; + goto end; + } + strcpy(node, ntoa_address); + } + + } + + end: + h_errno = saved_h_errno; +#ifdef ENABLE_PTHREAD + pthread_mutex_unlock(&gai_mutex); +#endif + return result; +} + Index: src/getaddrinfo.h =================================================================== RCS file: src/getaddrinfo.h diff -N src/getaddrinfo.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/getaddrinfo.h 29 Nov 2007 16:04:07 -0000 @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2001, 02 Motoyuki Kasahara + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef GETADDRINFO_H +#define GETADDRINFO_H + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include + +/********************************************************************/ +/* + * Undefine all the macros. + * might defines some of them. + */ +#ifdef EAI_ADDRFAMILY +#undef EAI_ADDRFAMILY +#endif +#ifdef EAI_AGAIN +#undef EAI_AGAIN +#endif +#ifdef EAI_BADFLAGS +#undef EAI_BADFLAGS +#endif +#ifdef EAI_FAIL +#undef EAI_FAIL +#endif +#ifdef EAI_FAMILY +#undef EAI_FAMILY +#endif +#ifdef EAI_MEMORY +#undef EAI_MEMORY +#endif +#ifdef EAI_NONAME +#undef EAI_NONAME +#endif +#ifdef EAI_OVERFLOW +#undef EAI_OVERFLOW +#endif +#ifdef EAI_SERVICE +#undef EAI_SERVICE +#endif +#ifdef EAI_SOCKTYPE +#undef EAI_SOCKTYPE +#endif +#ifdef EAI_SYSTEM +#undef EAI_SYSTEM +#endif + +#ifdef AI_PASSIVE +#undef AI_PASSIVE +#endif +#ifdef AI_CANONNAME +#undef AI_CANONNAME +#endif +#ifdef AI_NUMERICHOST +#undef AI_NUMERICHOST +#endif +#ifdef AI_NUMERICSERV +#undef AI_NUMERICSERV +#endif +#ifdef AI_V4MAPPED +#undef AI_V4MAPPED +#endif +#ifdef AI_ALL +#undef AI_ALL +#endif +#ifdef AI_ADDRCONFIG +#undef AI_ADDRCONFIG +#endif +#ifdef AI_DEFAULT +#undef AI_DEFAULT +#endif + +#ifdef NI_NOFQDN +#undef NI_NOFQDN +#endif +#ifdef NI_NUMERICHOST +#undef NI_NUMERICHOST +#endif +#ifdef NI_NAMEREQD +#undef NI_NAMEREQD +#endif +#ifdef NI_NUMERICSERV +#undef NI_NUMERICSERV +#endif +#ifdef NI_NUMERICSCOPE +#undef NI_NUMERICSCOPE +#endif + +#ifdef NI_DGRAM +#undef NI_DGRAM +#endif +#ifdef NI_MAXHOST +#undef NI_MAXHOST +#endif +#ifdef NI_MAXSERV +#undef NI_MAXSERV +#endif + +/* + * Fake struct and function names. + * might declares all or some of them. + */ +#if defined(HAVE_GETADDRINFO) || defined(HAVE_GETNAMEINFO) +#define addrinfo my_addrinfo +#define gai_strerror my_gai_strerror +#define freeaddrinfo my_freeaddrinfo +#define getaddrinfo my_getaddrinfo +#define getnameinfo my_getnameinfo +#endif + +/********************************************************************/ +/* + * Error codes. + */ +#define EAI_ADDRFAMILY 1 +#define EAI_AGAIN 2 +#define EAI_BADFLAGS 3 +#define EAI_FAIL 4 +#define EAI_FAMILY 5 +#define EAI_MEMORY 6 +#define EAI_NONAME 7 +#define EAI_OVERFLOW 8 +#define EAI_SERVICE 9 +#define EAI_SOCKTYPE 10 +#define EAI_SYSTEM 11 + +/* + * Flags for getaddrinfo(). + */ +#define AI_ADDRCONFIG 0x0001 +#define AI_ALL 0x0002 +#define AI_CANONNAME 0x0004 +#define AI_NUMERICHOST 0x0008 +#define AI_NUMERICSERV 0x0010 +#define AI_PASSIVE 0x0020 +#define AI_V4MAPPED 0x0040 +#define AI_DEFAULT (AI_V4MAPPED | AI_ADDRCONFIG) + +/* + * Flags for getnameinfo(). + */ +#define NI_DGRAM 0x0001 +#define NI_NAMEREQD 0x0002 +#define NI_NOFQDN 0x0004 +#define NI_NUMERICHOST 0x0008 +#define NI_NUMERICSCOPE 0x0010 +#define NI_NUMERICSERV 0x0020 + +/* + * Maximum length of FQDN and servie name for getnameinfo(). + */ +#define NI_MAXHOST 1025 +#define NI_MAXSERV 32 + +/* + * Address families and Protocol families. + */ +#ifndef AF_UNSPEC +#define AF_UNSPEC AF_INET +#endif +#ifndef PF_UNSPEC +#define PF_UNSPEC PF_INET +#endif + +/* + * struct addrinfo. + */ +struct addrinfo { + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + socklen_t ai_addrlen; + char *ai_canonname; + struct sockaddr *ai_addr; + struct addrinfo *ai_next; +}; + +/* + * Functions. + */ +#ifdef __STDC__ +const char *gai_strerror(int); +void freeaddrinfo(struct addrinfo *); +int getaddrinfo(const char *, const char *, const struct addrinfo *, + struct addrinfo **); +int getnameinfo(const struct sockaddr *, socklen_t, char *, + socklen_t, char *, socklen_t, int); +#else +const char *gai_strerror(); +void freeaddrinfo(); +int getaddrinfo(); +int getnameinfo(); +#endif + +#endif /* not GETADDRINFO_H */ Index: src/remote_internal.c =================================================================== RCS file: /data/cvs/libvirt/src/remote_internal.c,v retrieving revision 1.35 diff -u -r1.35 remote_internal.c --- src/remote_internal.c 27 Nov 2007 18:18:23 -0000 1.35 +++ src/remote_internal.c 29 Nov 2007 16:04:09 -0000 @@ -55,6 +55,10 @@ #include "remote_internal.h" #include "remote_protocol.h" +#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO) +#include "getaddrinfo.h" +#endif + #define DEBUG 0 /* Enable verbose messages on stderr. */ /* Per-connection private data. */