[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [libvirt] [PATCH 1/4] Convert the remote driver to new RPC client APIs



On 06/27/2011 08:24 AM, Daniel P. Berrange wrote:
> This guts the current remote driver, removing all its networking
> handling code. Instead it calls out to the new virClientPtr and
> virClientProgramPtr APIs for all RPC & networking work.
> ---
>  src/Makefile.am            |    5 +-
>  src/remote/remote_driver.c | 3452 ++++++++------------------------------------
>  src/rpc/gendispatch.pl     |   14 +-
>  3 files changed, 586 insertions(+), 2885 deletions(-)
> @@ -1222,6 +1222,7 @@ endif
>  libvirt_net_rpc_la_CFLAGS = \
>  			$(GNUTLS_CFLAGS) \
>  			$(SASL_CFLAGS) \
> +			$(XDR_CFLAGS) \

Should this hunk be done as a separate patch?

> +++ b/src/remote/remote_driver.c
> @@ -23,51 +23,14 @@

> +#include "virnetclient.h"
> +#include "virnetclientprogram.h"
> +#include "virnetclientstream.h"
>  #include "virterror_internal.h"
>  #include "logging.h"
>  #include "datatypes.h"

'make syntax-check' is calling you for not removing the now-unused
#include "ignore-value.h".

Aargh.  This needs yet another rebase to pick up the revert of BlockPull
patches:

remote/remote_driver.c:263:7: error:
'REMOTE_PROC_DOMAIN_EVENT_BLOCK_PULL' undeclared here (not in a function)
remote/remote_driver.c:265:14: error:
'remote_domain_event_block_pull_msg' undeclared here (not in a function)
remote/remote_driver.c:266:18: error:
'xdr_remote_domain_event_block_pull_msg' undeclared here (not in a function)
cc1: warnings being treated as errors
remote/remote_driver.c:222:1: error: 'remoteDomainBuildEventBlockPull'
used but never defined

> @@ -107,119 +70,27 @@
>  
>  static int inside_daemon = 0;
>  
> -struct remote_thread_call;
> -
> -
> -enum {
> -    REMOTE_MODE_WAIT_TX,
> -    REMOTE_MODE_WAIT_RX,
> -    REMOTE_MODE_COMPLETE,
> -    REMOTE_MODE_ERROR,
> -};

Replaced by virnetclient.c, but that enum only has MODE_WAIT_TX,
MODE_WAIT_RX, and MODE_COMPLETE - I'm hoping that dropping the
MODE_ERROR works out.

> +static void
> +remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                                virNetClientPtr client ATTRIBUTE_UNUSED,
> +                                void *evdata, void *opaque);

Is it worth rearranging this file to be in topological order, to avoid
having to use quite as many forward declarations?  But that should be a
separate followup patch.

> @@ -524,12 +431,6 @@ doRemoteOpen (virConnectPtr conn,
>              } else if (STRCASEEQ (var->name, "no_tty")) {
>                  no_tty = atoi (var->value);
>                  var->ignore = 1;
> -            } else if (STRCASEEQ (var->name, "debug")) {
> -                if (var->value &&
> -                    STRCASEEQ (var->value, "stdout"))
> -                    priv->debugLog = stdout;
> -                else
> -                    priv->debugLog = stderr;
>              } else if (STRCASEEQ(var->name, "pkipath")) {

I'm not sure why this hunk is here.

>  
>          /*FALLTHROUGH*/
> -    case trans_tcp: {
> -        /* http://people.redhat.com/drepper/userapi-ipv6.html */
> -        struct addrinfo *res, *r;
> -        struct addrinfo hints;
> -        int saved_errno = EINVAL;
> -        memset (&hints, 0, sizeof hints);
> -        hints.ai_socktype = SOCK_STREAM;
> -        hints.ai_flags = AI_ADDRCONFIG;
> -        int e = getaddrinfo (priv->hostname, port, &hints, &res);
> -        if (e != 0) {
> -            remoteError(VIR_ERR_SYSTEM_ERROR,
> -                        _("unable to resolve hostname '%s': %s"),
> -                        priv->hostname, gai_strerror (e));
> +    case trans_tcp:
> +        priv->client = virNetClientNewTCP(priv->hostname, port);
> +        if (!priv->client)
>              goto failed;
> -        }
>  
> -        /* Try to connect to each returned address in turn. */
> -        /* XXX This loop contains a subtle problem.  In the case
> -         * where a host is accessible over IPv4 and IPv6, it will
> -         * try the IPv4 and IPv6 addresses in turn.  However it
> -         * should be able to present different client certificates
> -         * (because the commonName field in a client cert contains
> -         * the client IP address, which is different for IPv4 and
> -         * IPv6).  At the moment we only have a single client
> -         * certificate, and no way to specify what address family
> -         * that certificate belongs to.
> -         */
> -        for (r = res; r; r = r->ai_next) {
> -            int no_slow_start = 1;
> -
> -            priv->sock = socket (r->ai_family, SOCK_STREAM, 0);
> -            if (priv->sock == -1) {
> -                saved_errno = errno;
> -                continue;
> -            }
> -
> -            /* Disable Nagle - Dan Berrange. */
> -            setsockopt (priv->sock,
> -                        IPPROTO_TCP, TCP_NODELAY, (void *)&no_slow_start,
> -                        sizeof no_slow_start);
> -
> -            if (connect (priv->sock, r->ai_addr, r->ai_addrlen) == -1) {
> -                saved_errno = errno;
> -                VIR_FORCE_CLOSE(priv->sock);
> -                continue;
> -            }
> -
> -            if (priv->uses_tls) {
> -                priv->session =
> -                    negotiate_gnutls_on_connection
> -                      (conn, priv, no_verify);
> -                if (!priv->session) {
> -                    VIR_FORCE_CLOSE(priv->sock);
> -                    goto failed;
> -                }
> -            }
> -            goto tcp_connected;
> +        if (priv->tls) {
> +            VIR_DEBUG("Starting TLS session");
> +            if (virNetClientSetTLSSession(priv->client, priv->tls) < 0)
> +                goto failed;
>          }
>  
> -        freeaddrinfo (res);
> -        virReportSystemError(saved_errno,
> -                             _("unable to connect to libvirtd at '%s'"),
> -                             priv->hostname);
> -        goto failed;
> -
> -       tcp_connected:
> -        freeaddrinfo (res);
> -
> -        /* NB. All versioning is done by the RPC headers, so we don't
> -         * need to worry (at this point anyway) about versioning. */
>          break;
> -    }
>  
>  #ifndef WIN32
> -    case trans_unix: {
> +    case trans_unix:
>          if (!sockname) {
>              if (flags & VIR_DRV_OPEN_REMOTE_USER) {
>                  char *userdir = virGetUserDirectory(getuid());
> @@ -698,131 +544,59 @@ doRemoteOpen (virConnectPtr conn,
>                  VIR_FREE(userdir);
>              } else {
>                  if (flags & VIR_DRV_OPEN_REMOTE_RO)
> -                    sockname = strdup (LIBVIRTD_PRIV_UNIX_SOCKET_RO);
> +                    sockname = strdup(LIBVIRTD_PRIV_UNIX_SOCKET_RO);
>                  else
> -                    sockname = strdup (LIBVIRTD_PRIV_UNIX_SOCKET);
> +                    sockname = strdup(LIBVIRTD_PRIV_UNIX_SOCKET);
>                  if (sockname == NULL)
>                      goto out_of_memory;
>              }
> +            VIR_DEBUG("Proceeding with sockname %s", sockname);
>          }
>  
> -# ifndef UNIX_PATH_MAX
> -#  define UNIX_PATH_MAX(addr) (sizeof (addr).sun_path)
> -# endif
> -        struct sockaddr_un addr;
> -        int trials = 0;
> -
> -        memset (&addr, 0, sizeof addr);
> -        addr.sun_family = AF_UNIX;
> -        if (virStrcpyStatic(addr.sun_path, sockname) == NULL) {
> -            remoteError(VIR_ERR_INTERNAL_ERROR,
> -                        _("Socket %s too big for destination"), sockname);
> +        if (!(priv->client = virNetClientNewUNIX(sockname,
> +                                                 flags & VIR_DRV_OPEN_REMOTE_AUTOSTART,
> +                                                 remoteFindDaemonPath())))
>              goto failed;
> -        }
> -        if (addr.sun_path[0] == '@')
> -            addr.sun_path[0] = '\0';
>  
> -      autostart_retry:
>          priv->is_secure = 1;
> -        priv->sock = socket (AF_UNIX, SOCK_STREAM, 0);
> -        if (priv->sock == -1) {
> -            virReportSystemError(errno, "%s",
> -                                 _("unable to create socket"));
> -            goto failed;
> -        }
> -        if (connect (priv->sock, (struct sockaddr *) &addr, sizeof addr) == -1) {
> -            /* We might have to autostart the daemon in some cases....
> -             * It takes a short while for the daemon to startup, hence we
> -             * have a number of retries, with a small sleep. This will
> -             * sometimes cause multiple daemons to be started - this is
> -             * ok because the duplicates will fail to bind to the socket
> -             * and immediately exit, leaving just one daemon.
> -             */
> -            if (errno == ECONNREFUSED &&
> -                flags & VIR_DRV_OPEN_REMOTE_AUTOSTART &&
> -                trials < 20) {
> -                VIR_FORCE_CLOSE(priv->sock);
> -                if (trials > 0 ||
> -                    remoteForkDaemon() == 0) {
> -                    trials++;
> -                    usleep(1000 * 100 * trials);
> -                    goto autostart_retry;
> -                }
> -            }
> -            virReportSystemError(errno,
> -              _("unable to connect to '%s', libvirtd may need to be started"),
> -              sockname);
> -            goto failed;
> -        }
> -
>          break;
> -    }
>  
> -    case trans_ssh: {
> -        cmd = virCommandNew(command ? command : "ssh");
> -
> -        /* Generate the final command argv[] array.
> -         *   ssh [-p $port] [-l $username] $hostname $netcat -U $sockname */
> +    case trans_ssh:
> +        command = command ? command : strdup ("ssh");
> +        if (command == NULL)
> +            goto out_of_memory;
>  
> -        if (port) {
> -            virCommandAddArgList(cmd, "-p", port, NULL);
> -        }
> -        if (username) {
> -            virCommandAddArgList(cmd, "-l", username, NULL);
> -        }
> -        if (no_tty) {
> -            virCommandAddArgList(cmd, "-T", "-o", "BatchMode=yes", "-e",
> -                                 "none", NULL);
> +        if (!sockname) {
> +            if (flags & VIR_DRV_OPEN_REMOTE_RO)
> +                sockname = strdup(LIBVIRTD_PRIV_UNIX_SOCKET_RO);
> +            else
> +                sockname = strdup(LIBVIRTD_PRIV_UNIX_SOCKET);
> +            if (sockname == NULL)
> +                goto out_of_memory;
>          }
> -        virCommandAddArgList(cmd, priv->hostname, netcat ? netcat : "nc",
> -                             "-U", (sockname ? sockname :
> -                                    (flags & VIR_CONNECT_RO
> -                                     ? LIBVIRTD_PRIV_UNIX_SOCKET_RO
> -                                     : LIBVIRTD_PRIV_UNIX_SOCKET)), NULL);
> -
> -        priv->is_secure = 1;
> -    }
>  
> -        /*FALLTHROUGH*/
> -    case trans_ext: {
> -        pid_t pid;
> -        int sv[2];
> -        int errfd[2];
> -
> -        /* Fork off the external process.  Use socketpair to create a private
> -         * (unnamed) Unix domain socket to the child process so we don't have
> -         * to faff around with two file descriptors (a la 'pipe(2)').
> -         */
> -        if (socketpair (PF_UNIX, SOCK_STREAM, 0, sv) == -1) {
> -            virReportSystemError(errno, "%s",
> -                                 _("unable to create socket pair"));
> +        if (!(priv->client = virNetClientNewSSH(priv->hostname,
> +                                                port,
> +                                                command,
> +                                                username,
> +                                                no_tty,
> +                                                netcat ? netcat : "nc",
> +                                                sockname)))
>              goto failed;
> -        }
>  
> -        if (pipe(errfd) == -1) {
> -            virReportSystemError(errno, "%s",
> -                                 _("unable to create socket pair"));
> -            goto failed;
> -        }
> +        priv->is_secure = 1;
> +        break;
>  
> -        virCommandSetInputFD(cmd, sv[1]);
> -        virCommandSetOutputFD(cmd, &(sv[1]));
> -        virCommandSetErrorFD(cmd, &(errfd[1]));
> -        virCommandClearCaps(cmd);
> -        if (virCommandRunAsync(cmd, &pid) < 0)
> +    case trans_ext: {
> +        char const *cmd_argv[] = { command, NULL };
> +        if (!(priv->client = virNetClientNewExternal(cmd_argv)))
>              goto failed;
>  
> -        /* Parent continues here. */
> -        VIR_FORCE_CLOSE(sv[1]);
> -        VIR_FORCE_CLOSE(errfd[1]);
> -        priv->sock = sv[0];
> -        priv->errfd = errfd[0];
> -        priv->pid = pid;
> -
>          /* Do not set 'is_secure' flag since we can't guarentee
>           * an external program is secure, and this flag must be
>           * pessimistic */
> -    }
> +    }   break;
> +
>  #else /* WIN32 */
>  
>      case trans_unix:
> @@ -834,38 +608,36 @@ doRemoteOpen (virConnectPtr conn,
>          goto failed;
>  
>  #endif /* WIN32 */
> -
>      } /* switch (transport) */
>  
> -    if (virSetNonBlock(priv->sock) < 0) {
> -        virReportSystemError(errno, "%s",
> -                             _("unable to make socket non-blocking"));
> +    if (!(priv->remoteProgram = virNetClientProgramNew(REMOTE_PROGRAM,
> +                                                       REMOTE_PROTOCOL_VERSION,
> +                                                       remoteDomainEvents,
> +                                                       ARRAY_CARDINALITY(remoteDomainEvents),
> +                                                       conn)))
>          goto failed;
> -    }
> -
> -    if ((priv->errfd != -1) && virSetNonBlock(priv->errfd) < 0) {
> -        virReportSystemError(errno, "%s",
> -                             _("unable to make socket non-blocking"));
> +    if (!(priv->qemuProgram = virNetClientProgramNew(QEMU_PROGRAM,
> +                                                     QEMU_PROTOCOL_VERSION,
> +                                                     NULL,
> +                                                     0,
> +                                                     NULL)))
>          goto failed;
> -    }
>  
> -    if (pipe(wakeupFD) < 0) {
> -        virReportSystemError(errno, "%s",
> -                             _("unable to make pipe"));
> +    if (virNetClientAddProgram(priv->client, priv->remoteProgram) < 0 ||
> +        virNetClientAddProgram(priv->client, priv->qemuProgram) < 0)
>          goto failed;
> -    }
> -    priv->wakeupReadFD = wakeupFD[0];
> -    priv->wakeupSendFD = wakeupFD[1];
>  
>      /* Try and authenticate with server */
> -    if (remoteAuthenticate(conn, priv, 1, auth, authtype) == -1)
> +    VIR_DEBUG("Trying authentication");
> +    if (remoteAuthenticate(conn, priv, auth, authtype) == -1)
>          goto failed;
>  
>      /* Finally we can call the remote side's open function. */
>      {
>          remote_open_args args = { &name, flags };
>  
> -        if (call (conn, priv, REMOTE_CALL_IN_OPEN, REMOTE_PROC_OPEN,
> +        VIR_DEBUG("Trying to open URI %s", name);
> +        if (call (conn, priv, 0, REMOTE_PROC_OPEN,
>                    (xdrproc_t) xdr_remote_open_args, (char *) &args,
>                    (xdrproc_t) xdr_void, (char *) NULL) == -1)
>              goto failed;
> @@ -874,26 +646,14 @@ doRemoteOpen (virConnectPtr conn,
>      /* Now try and find out what URI the daemon used */
>      if (conn->uri == NULL) {
>          remote_get_uri_ret uriret;
> -        int urierr;
>  
> +        VIR_DEBUG("Trying to query remote URI");
>          memset (&uriret, 0, sizeof uriret);
> -        urierr = call (conn, priv,
> -                       REMOTE_CALL_IN_OPEN | REMOTE_CALL_QUIET_MISSING_RPC,
> -                       REMOTE_PROC_GET_URI,
> -                       (xdrproc_t) xdr_void, (char *) NULL,
> -                       (xdrproc_t) xdr_remote_get_uri_ret, (char *) &uriret);
> -        if (urierr == -2) {
> -            /* Should not really happen, since we only probe local libvirtd's,
> -               & the library should always match the daemon. Only case is post
> -               RPM upgrade where an old daemon instance is still running with
> -               new client. Too bad. It is not worth the hassle to fix this */
> -            remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                        _("unable to auto-detect URI"));
> -            goto failed;
> -        }
> -        if (urierr == -1) {
> +        if (call (conn, priv, 0,
> +                  REMOTE_PROC_GET_URI,
> +                  (xdrproc_t) xdr_void, (char *) NULL,
> +                  (xdrproc_t) xdr_remote_get_uri_ret, (char *) &uriret) < 0)
>              goto failed;
> -        }
>  
>          VIR_DEBUG("Auto-probed URI is %s", uriret.uri);
>          conn->uri = xmlParseURI(uriret.uri);
> @@ -904,27 +664,11 @@ doRemoteOpen (virConnectPtr conn,
>          }
>      }
>  
> -    /* Set up a callback to listen on the socket data */
> -    if ((priv->watch = virEventAddHandle(priv->sock,
> -                                         VIR_EVENT_HANDLE_READABLE,
> -                                         remoteDomainEventFired,
> -                                         conn, NULL)) < 0) {
> -        VIR_DEBUG("virEventAddHandle failed: No addHandleImpl defined."
> -               " continuing without events.");
> -        priv->watch = -1;
> -    }
> -
> -    priv->domainEventState = virDomainEventStateNew(remoteDomainEventQueueFlush,
> -                                                    conn,
> -                                                    NULL,
> -                                                    false);
> -    if (!priv->domainEventState) {
> +    if (!(priv->domainEventState = virDomainEventStateNew(remoteDomainEventQueueFlush,
> +                                                          conn,
> +                                                          NULL,
> +                                                          false)))
>          goto failed;
> -    }
> -    if (priv->domainEventState->timer < 0 && priv->watch != -1) {
> -        virEventRemoveHandle(priv->watch);
> -        priv->watch = -1;
> -    }
>  
>      /* Successful. */
>      retcode = VIR_DRV_OPEN_SUCCESS;
> @@ -938,7 +682,6 @@ doRemoteOpen (virConnectPtr conn,
>      VIR_FREE(netcat);
>      VIR_FREE(username);
>      VIR_FREE(port);
> -    virCommandFree(cmd);
>      VIR_FREE(pkipath);
>  
>      return retcode;
> @@ -949,30 +692,8 @@ doRemoteOpen (virConnectPtr conn,
>          free_qparam_set (vars);
>  
>   failed:
> -    /* Close the socket if we failed. */
> -    VIR_FORCE_CLOSE(priv->errfd);
> -
> -    if (priv->sock >= 0) {
> -        if (priv->uses_tls && priv->session) {
> -            gnutls_bye (priv->session, GNUTLS_SHUT_RDWR);
> -            gnutls_deinit (priv->session);
> -        }
> -        VIR_FORCE_CLOSE(priv->sock);
> -#ifndef WIN32
> -        if (priv->pid > 0) {
> -            pid_t reap;
> -            do {
> -retry:
> -                reap = waitpid(priv->pid, NULL, 0);
> -                if (reap == -1 && errno == EINTR)
> -                    goto retry;
> -            } while (reap != -1 && reap != priv->pid);
> -        }
> -#endif
> -    }
> -
> -    VIR_FORCE_CLOSE(wakeupFD[0]);
> -    VIR_FORCE_CLOSE(wakeupFD[1]);
> +    virNetClientFree(priv->client);
> +    priv->client = NULL;
>  
>      VIR_FREE(priv->hostname);
>      goto cleanup;
> @@ -995,9 +716,6 @@ remoteAllocPrivateData(void)
>      }
>      remoteDriverLock(priv);
>      priv->localUses = 1;
> -    priv->watch = -1;
> -    priv->sock = -1;
> -    priv->errfd = -1;
>  
>      return priv;
>  }
> @@ -1109,577 +827,139 @@ get_transport_from_scheme (char *scheme)
>      return p ? p+1 : 0;
>  }
>  
> -/* GnuTLS functions used by remoteOpen. */
> -static gnutls_certificate_credentials_t x509_cred;
> +/*----------------------------------------------------------------------*/
>  
>  
>  static int
> -check_cert_file(const char *type, const char *file)
> +doRemoteClose (virConnectPtr conn, struct private_data *priv)
>  {
> -    if (access(file, R_OK)) {
> -        virReportSystemError(errno,
> -                             _("Cannot access %s '%s'"),
> -                             type, file);
> +    if (call (conn, priv, 0, REMOTE_PROC_CLOSE,
> +              (xdrproc_t) xdr_void, (char *) NULL,
> +              (xdrproc_t) xdr_void, (char *) NULL) == -1)
>          return -1;
> -    }
> -    return 0;
> -}
>  
> +    virNetTLSContextFree(priv->tls);
> +    priv->tls = NULL;
> +    virNetClientFree(priv->client);
> +    priv->client = NULL;
> +    virNetClientProgramFree(priv->remoteProgram);
> +    virNetClientProgramFree(priv->qemuProgram);
> +    priv->remoteProgram = priv->qemuProgram = NULL;
> +
> +    /* Free hostname copy */
> +    VIR_FREE(priv->hostname);
> +
> +    /* See comment for remoteType. */
> +    VIR_FREE(priv->type);
> +
> +    virDomainEventStateFree(priv->domainEventState);
>  
> -static void remote_debug_gnutls_log(int level, const char* str) {
> -    VIR_DEBUG("%d %s", level, str);
> +    return 0;
>  }
>  
>  static int
> -initialize_gnutls(char *pkipath, int flags)
> +remoteClose (virConnectPtr conn)
>  {
> -    static int initialized = 0;
> -    int err;
> -    char *gnutlsdebug;
> -    char *libvirt_cacert = NULL;
> -    char *libvirt_clientkey = NULL;
> -    char *libvirt_clientcert = NULL;
> -    int ret = -1;
> -    char *userdir = NULL;
> -    char *user_pki_path = NULL;
> -
> -    if (initialized) return 0;
> -
> -    gnutls_global_init ();
> +    int ret = 0;
> +    struct private_data *priv = conn->privateData;
>  
> -    if ((gnutlsdebug = getenv("LIBVIRT_GNUTLS_DEBUG")) != NULL) {
> -        int val;
> -        if (virStrToLong_i(gnutlsdebug, NULL, 10, &val) < 0)
> -            val = 10;
> -        gnutls_global_set_log_level(val);
> -        gnutls_global_set_log_function(remote_debug_gnutls_log);
> +    remoteDriverLock(priv);
> +    priv->localUses--;
> +    if (!priv->localUses) {
> +        ret = doRemoteClose(conn, priv);
> +        conn->privateData = NULL;
> +        remoteDriverUnlock(priv);
> +        virMutexDestroy(&priv->lock);
> +        VIR_FREE (priv);
>      }
> +    if (priv)
> +        remoteDriverUnlock(priv);
>  
> -    /* X509 stuff */
> -    err = gnutls_certificate_allocate_credentials (&x509_cred);
> -    if (err) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to allocate TLS credentials: %s"),
> -                    gnutls_strerror (err));
> -        return -1;
> -    }
> +    return ret;
> +}
>  
> -    if (pkipath) {
> -        if ((virAsprintf(&libvirt_cacert, "%s/%s", pkipath,
> -                        "cacert.pem")) < 0)
> -            goto out_of_memory;
>  
> -        if ((virAsprintf(&libvirt_clientkey, "%s/%s", pkipath,
> -                        "clientkey.pem")) < 0)
> -            goto out_of_memory;
> +/* Unfortunately this function is defined to return a static string.
> + * Since the remote end always answers with the same type (for a
> + * single connection anyway) we cache the type in the connection's
> + * private data, and free it when we close the connection.
> + *
> + * See also:
> + * http://www.redhat.com/archives/libvir-list/2007-February/msg00096.html
> + */
> +static const char *
> +remoteType (virConnectPtr conn)
> +{
> +    char *rv = NULL;
> +    remote_get_type_ret ret;
> +    struct private_data *priv = conn->privateData;
>  
> -        if ((virAsprintf(&libvirt_clientcert, "%s/%s", pkipath,
> -                        "clientcert.pem")) < 0)
> -             goto out_of_memory;
> -    } else if (flags & VIR_DRV_OPEN_REMOTE_USER || getuid() > 0) {
> -        userdir = virGetUserDirectory(getuid());
> +    remoteDriverLock(priv);
>  
> -        if (!userdir)
> -            goto out_of_memory;
> +    /* Cached? */
> +    if (priv->type) {
> +        rv = priv->type;
> +        goto done;
> +    }
>  
> -        if (virAsprintf(&user_pki_path, "%s/.pki/libvirt", userdir) < 0)
> -            goto out_of_memory;
> +    memset (&ret, 0, sizeof ret);
> +    if (call (conn, priv, 0, REMOTE_PROC_GET_TYPE,
> +              (xdrproc_t) xdr_void, (char *) NULL,
> +              (xdrproc_t) xdr_remote_get_type_ret, (char *) &ret) == -1)
> +        goto done;
>  
> -        if ((virAsprintf(&libvirt_cacert, "%s/%s", user_pki_path,
> -                        "cacert.pem")) < 0)
> -            goto out_of_memory;
> +    /* Stash. */
> +    rv = priv->type = ret.type;
>  
> -        if ((virAsprintf(&libvirt_clientkey, "%s/%s", user_pki_path,
> -                        "clientkey.pem")) < 0)
> -            goto out_of_memory;
> +done:
> +    remoteDriverUnlock(priv);
> +    return rv;
> +}
>  
> -        if ((virAsprintf(&libvirt_clientcert, "%s/%s", user_pki_path,
> -                        "clientcert.pem")) < 0)
> -            goto out_of_memory;
> +static int remoteIsSecure(virConnectPtr conn)
> +{
> +    int rv = -1;
> +    struct private_data *priv = conn->privateData;
> +    remote_is_secure_ret ret;
> +    remoteDriverLock(priv);
>  
> -        /* Use the default location of the CA certificate if it
> -         * cannot be found in $HOME/.pki/libvirt
> -         */
> -        if (!virFileExists(libvirt_cacert)) {
> -            VIR_FREE(libvirt_cacert);
> +    memset (&ret, 0, sizeof ret);
> +    if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
> +              (xdrproc_t) xdr_void, (char *) NULL,
> +              (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
> +        goto done;
>  
> -            libvirt_cacert = strdup(LIBVIRT_CACERT);
> -            if (!libvirt_cacert) goto out_of_memory;
> -        }
> +    /* We claim to be secure, if the remote driver
> +     * transport itself is secure, and the remote
> +     * HV connection is secure
> +     *
> +     * ie, we don't want to claim to be secure if the
> +     * remote driver is used to connect to a XenD
> +     * driver using unencrypted HTTP:/// access
> +     */
> +    rv = priv->is_secure && ret.secure ? 1 : 0;
>  
> -        /* Use default location as long as one of
> -         * client key, and client certificate cannot be found in
> -         * $HOME/.pki/libvirt, we don't want to make user confused
> -         * with one file is here, the other is there.
> -         */
> -        if (!virFileExists(libvirt_clientkey) ||
> -            !virFileExists(libvirt_clientcert)) {
> -            VIR_FREE(libvirt_clientkey);
> -            VIR_FREE(libvirt_clientcert);
> -
> -            libvirt_clientkey = strdup(LIBVIRT_CLIENTKEY);
> -            if (!libvirt_clientkey) goto out_of_memory;
> -
> -            libvirt_clientcert = strdup(LIBVIRT_CLIENTCERT);
> -            if (!libvirt_clientcert) goto out_of_memory;
> -        }
> -    } else {
> -        libvirt_cacert = strdup(LIBVIRT_CACERT);
> -        if (!libvirt_cacert) goto out_of_memory;
> +done:
> +    remoteDriverUnlock(priv);
> +    return rv;
> +}
>  
> -        libvirt_clientkey = strdup(LIBVIRT_CLIENTKEY);
> -        if (!libvirt_clientkey) goto out_of_memory;
> +static int remoteIsEncrypted(virConnectPtr conn)
> +{
> +    int rv = -1;
> +    int encrypted = 0;
> +    struct private_data *priv = conn->privateData;
> +    remote_is_secure_ret ret;
> +    remoteDriverLock(priv);
>  
> -        libvirt_clientcert = strdup(LIBVIRT_CLIENTCERT);
> -        if (!libvirt_clientcert) goto out_of_memory;
> -    }
> -
> -    if (check_cert_file("CA certificate", libvirt_cacert) < 0)
> -        goto error;
> -    if (check_cert_file("client key", libvirt_clientkey) < 0)
> -        goto error;
> -    if (check_cert_file("client certificate", libvirt_clientcert) < 0)
> -        goto error;
> -
> -    /* Set the trusted CA cert. */
> -    VIR_DEBUG("loading CA file %s", libvirt_cacert);
> -    err =
> -        gnutls_certificate_set_x509_trust_file (x509_cred, libvirt_cacert,
> -                                                GNUTLS_X509_FMT_PEM);
> -    if (err < 0) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to load CA certificate '%s': %s"),
> -                    libvirt_cacert, gnutls_strerror (err));
> -        goto error;
> -    }
> -
> -    /* Set the client certificate and private key. */
> -    VIR_DEBUG("loading client cert and key from files %s and %s",
> -          libvirt_clientcert, libvirt_clientkey);
> -    err =
> -        gnutls_certificate_set_x509_key_file (x509_cred,
> -                                              libvirt_clientcert,
> -                                              libvirt_clientkey,
> -                                              GNUTLS_X509_FMT_PEM);
> -    if (err < 0) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to load private key '%s' and/or "
> -                    "certificate '%s': %s"), libvirt_clientkey,
> -                    libvirt_clientcert, gnutls_strerror (err));
> -        goto error;
> -    }
> -
> -    initialized = 1;
> -    ret = 0;
> -
> -cleanup:
> -    VIR_FREE(libvirt_cacert);
> -    VIR_FREE(libvirt_clientkey);
> -    VIR_FREE(libvirt_clientcert);
> -    VIR_FREE(userdir);
> -    VIR_FREE(user_pki_path);
> -    return ret;
> -
> -error:
> -    ret = -1;
> -    goto cleanup;
> -
> -out_of_memory:
> -    ret = -1;
> -    virReportOOMError();
> -    goto cleanup;
> -}
> -
> -static int verify_certificate (virConnectPtr conn, struct private_data *priv, gnutls_session_t session);
> -
> -#if HAVE_WINSOCK2_H
> -static ssize_t
> -custom_gnutls_push(void *s, const void *buf, size_t len)
> -{
> -    return send((size_t)s, buf, len, 0);
> -}
> -
> -static ssize_t
> -custom_gnutls_pull(void *s, void *buf, size_t len)
> -{
> -    return recv((size_t)s, buf, len, 0);
> -}
> -#endif
> -
> -static gnutls_session_t
> -negotiate_gnutls_on_connection (virConnectPtr conn,
> -                                struct private_data *priv,
> -                                int no_verify)
> -{
> -    bool success = false;
> -    int err;
> -    gnutls_session_t session;
> -
> -    /* Initialize TLS session
> -     */
> -    err = gnutls_init (&session, GNUTLS_CLIENT);
> -    if (err) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to initialize TLS client: %s"),
> -                    gnutls_strerror (err));
> -        return NULL;
> -    }
> -
> -    /* Use default priorities */
> -    err = gnutls_set_default_priority (session);
> -    if (err) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to set TLS algorithm priority: %s"),
> -                    gnutls_strerror (err));
> -        goto cleanup;
> -    }
> -
> -    /* put the x509 credentials to the current session
> -     */
> -    err = gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509_cred);
> -    if (err) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to set session credentials: %s"),
> -                    gnutls_strerror (err));
> -        goto cleanup;
> -    }
> -
> -    gnutls_transport_set_ptr (session,
> -                              (gnutls_transport_ptr_t) (long) priv->sock);
> -
> -#if HAVE_WINSOCK2_H
> -    /* Make sure GnuTLS uses gnulib's replacment functions for send() and
> -     * recv() on Windows */
> -    gnutls_transport_set_push_function(session, custom_gnutls_push);
> -    gnutls_transport_set_pull_function(session, custom_gnutls_pull);
> -#endif
> -
> -    /* Perform the TLS handshake. */
> - again:
> -    err = gnutls_handshake (session);
> -    if (err < 0) {
> -        if (err == GNUTLS_E_AGAIN || err == GNUTLS_E_INTERRUPTED)
> -            goto again;
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to complete TLS handshake: %s"),
> -                    gnutls_strerror (err));
> -        goto cleanup;
> -    }
> -
> -    /* Verify certificate. */
> -    if (verify_certificate (conn, priv, session) == -1) {
> -        VIR_DEBUG("failed to verify peer's certificate");
> -        if (!no_verify)
> -            goto cleanup;
> -    }
> -
> -    /* At this point, the server is verifying _our_ certificate, IP address,
> -     * etc.  If we make the grade, it will send us a '\1' byte.
> -     */
> -    char buf[1];
> -    int len;
> - again_2:
> -    len = gnutls_record_recv (session, buf, 1);
> -    if (len < 0 && len != GNUTLS_E_UNEXPECTED_PACKET_LENGTH) {
> -        if (len == GNUTLS_E_AGAIN || len == GNUTLS_E_INTERRUPTED)
> -            goto again_2;
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to complete TLS initialization: %s"),
> -                    gnutls_strerror (len));
> -        goto cleanup;
> -    }
> -    if (len != 1 || buf[0] != '\1') {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("server verification (of our certificate or IP "
> -                      "address) failed"));
> -        goto cleanup;
> -    }
> -
> -#if 0
> -    /* Print session info. */
> -    print_info (session);
> -#endif
> -
> -    success = true;
> -
> -cleanup:
> -    if (!success) {
> -        gnutls_deinit(session);
> -        session = NULL;
> -    }
> -
> -    return session;
> -}
> -
> -static int
> -verify_certificate (virConnectPtr conn ATTRIBUTE_UNUSED,
> -                    struct private_data *priv,
> -                    gnutls_session_t session)
> -{
> -    int ret;
> -    unsigned int status;
> -    const gnutls_datum_t *certs;
> -    unsigned int nCerts, i;
> -    time_t now;
> -
> -    if ((ret = gnutls_certificate_verify_peers2 (session, &status)) < 0) {
> -        remoteError(VIR_ERR_GNUTLS_ERROR,
> -                    _("unable to verify server certificate: %s"),
> -                    gnutls_strerror (ret));
> -        return -1;
> -    }
> -
> -    if ((now = time(NULL)) == ((time_t)-1)) {
> -        virReportSystemError(errno, "%s",
> -                             _("cannot get current time"));
> -        return -1;
> -    }
> -
> -    if (status != 0) {
> -        const char *reason = _("Invalid certificate");
> -
> -        if (status & GNUTLS_CERT_INVALID)
> -            reason = _("The certificate is not trusted.");
> -
> -        if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
> -            reason = _("The certificate hasn't got a known issuer.");
> -
> -        if (status & GNUTLS_CERT_REVOKED)
> -            reason = _("The certificate has been revoked.");
> -
> -#ifndef GNUTLS_1_0_COMPAT
> -        if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
> -            reason = _("The certificate uses an insecure algorithm");
> -#endif
> -
> -        remoteError(VIR_ERR_RPC,
> -                    _("server certificate failed validation: %s"),
> -                    reason);
> -        return -1;
> -    }
> -
> -    if (gnutls_certificate_type_get(session) != GNUTLS_CRT_X509) {
> -        remoteError(VIR_ERR_RPC,  "%s",_("Certificate type is not X.509"));
> -        return -1;
> -    }
> -
> -    if (!(certs = gnutls_certificate_get_peers(session, &nCerts))) {
> -        remoteError(VIR_ERR_RPC,  "%s",_("gnutls_certificate_get_peers failed"));
> -        return -1;
> -    }
> -
> -    for (i = 0 ; i < nCerts ; i++) {
> -        gnutls_x509_crt_t cert;
> -
> -        ret = gnutls_x509_crt_init (&cert);
> -        if (ret < 0) {
> -            remoteError(VIR_ERR_GNUTLS_ERROR,
> -                        _("unable to initialize certificate: %s"),
> -                        gnutls_strerror (ret));
> -            return -1;
> -        }
> -
> -        ret = gnutls_x509_crt_import (cert, &certs[i], GNUTLS_X509_FMT_DER);
> -        if (ret < 0) {
> -            remoteError(VIR_ERR_GNUTLS_ERROR,
> -                        _("unable to import certificate: %s"),
> -                        gnutls_strerror (ret));
> -            gnutls_x509_crt_deinit (cert);
> -            return -1;
> -        }
> -
> -        if (gnutls_x509_crt_get_expiration_time (cert) < now) {
> -            remoteError(VIR_ERR_RPC, "%s", _("The certificate has expired"));
> -            gnutls_x509_crt_deinit (cert);
> -            return -1;
> -        }
> -
> -        if (gnutls_x509_crt_get_activation_time (cert) > now) {
> -            remoteError(VIR_ERR_RPC, "%s",
> -                        _("The certificate is not yet activated"));
> -            gnutls_x509_crt_deinit (cert);
> -            return -1;
> -        }
> -
> -        if (i == 0) {
> -            if (!gnutls_x509_crt_check_hostname (cert, priv->hostname)) {
> -                remoteError(VIR_ERR_RPC,
> -                            _("Certificate's owner does not match the hostname (%s)"),
> -                            priv->hostname);
> -                gnutls_x509_crt_deinit (cert);
> -                return -1;
> -            }
> -        }
> -    }
> -
> -    return 0;
> -}
> -
> -/*----------------------------------------------------------------------*/
> -
> -
> -static int
> -doRemoteClose (virConnectPtr conn, struct private_data *priv)
> -{
> -    /* Remove timer before closing the connection, to avoid possible
> -     * remoteDomainEventFired with a free'd connection */
> -    if (priv->domainEventState->timer >= 0) {
> -        virEventRemoveTimeout(priv->domainEventState->timer);
> -        virEventRemoveHandle(priv->watch);
> -        priv->watch = -1;
> -        priv->domainEventState->timer = -1;
> -    }
> -
> -    if (call (conn, priv, 0, REMOTE_PROC_CLOSE,
> -              (xdrproc_t) xdr_void, (char *) NULL,
> -              (xdrproc_t) xdr_void, (char *) NULL) == -1)
> -        return -1;
> -
> -    /* Close socket. */
> -    if (priv->uses_tls && priv->session) {
> -        gnutls_bye (priv->session, GNUTLS_SHUT_RDWR);
> -        gnutls_deinit (priv->session);
> -    }
> -#if HAVE_SASL
> -    if (priv->saslconn)
> -        sasl_dispose (&priv->saslconn);
> -#endif
> -    VIR_FORCE_CLOSE(priv->sock);
> -    VIR_FORCE_CLOSE(priv->errfd);
> -
> -#ifndef WIN32
> -    if (priv->pid > 0) {
> -        pid_t reap;
> -        do {
> -retry:
> -            reap = waitpid(priv->pid, NULL, 0);
> -            if (reap == -1 && errno == EINTR)
> -                goto retry;
> -        } while (reap != -1 && reap != priv->pid);
> -    }
> -#endif
> -    VIR_FORCE_CLOSE(priv->wakeupReadFD);
> -    VIR_FORCE_CLOSE(priv->wakeupSendFD);
> -
> -
> -    /* Free hostname copy */
> -    VIR_FREE(priv->hostname);
> -
> -    /* See comment for remoteType. */
> -    VIR_FREE(priv->type);
> -
> -    virDomainEventStateFree(priv->domainEventState);
> -
> -    return 0;
> -}
> -
> -static int
> -remoteClose (virConnectPtr conn)
> -{
> -    int ret = 0;
> -    struct private_data *priv = conn->privateData;
> -
> -    remoteDriverLock(priv);
> -    priv->localUses--;
> -    if (!priv->localUses) {
> -        ret = doRemoteClose(conn, priv);
> -        conn->privateData = NULL;
> -        remoteDriverUnlock(priv);
> -        virMutexDestroy(&priv->lock);
> -        VIR_FREE (priv);
> -    }
> -    if (priv)
> -        remoteDriverUnlock(priv);
> -
> -    return ret;
> -}
> -
> -/* Unfortunately this function is defined to return a static string.
> - * Since the remote end always answers with the same type (for a
> - * single connection anyway) we cache the type in the connection's
> - * private data, and free it when we close the connection.
> - *
> - * See also:
> - * http://www.redhat.com/archives/libvir-list/2007-February/msg00096.html
> - */
> -static const char *
> -remoteType (virConnectPtr conn)
> -{
> -    char *rv = NULL;
> -    remote_get_type_ret ret;
> -    struct private_data *priv = conn->privateData;
> -
> -    remoteDriverLock(priv);
> -
> -    /* Cached? */
> -    if (priv->type) {
> -        rv = priv->type;
> -        goto done;
> -    }
> -
> -    memset (&ret, 0, sizeof ret);
> -    if (call (conn, priv, 0, REMOTE_PROC_GET_TYPE,
> -              (xdrproc_t) xdr_void, (char *) NULL,
> -              (xdrproc_t) xdr_remote_get_type_ret, (char *) &ret) == -1)
> -        goto done;
> -
> -    /* Stash. */
> -    rv = priv->type = ret.type;
> -
> -done:
> -    remoteDriverUnlock(priv);
> -    return rv;
> -}
> -
> -static int remoteIsSecure(virConnectPtr conn)
> -{
> -    int rv = -1;
> -    struct private_data *priv = conn->privateData;
> -    remote_is_secure_ret ret;
> -    remoteDriverLock(priv);
> -
> -    memset (&ret, 0, sizeof ret);
> -    if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
> -              (xdrproc_t) xdr_void, (char *) NULL,
> -              (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
> -        goto done;
> -
> -    /* We claim to be secure, if the remote driver
> -     * transport itself is secure, and the remote
> -     * HV connection is secure
> -     *
> -     * ie, we don't want to claim to be secure if the
> -     * remote driver is used to connect to a XenD
> -     * driver using unencrypted HTTP:/// access
> -     */
> -    rv = priv->is_secure && ret.secure ? 1 : 0;
> -
> -done:
> -    remoteDriverUnlock(priv);
> -    return rv;
> -}
> -
> -static int remoteIsEncrypted(virConnectPtr conn)
> -{
> -    int rv = -1;
> -    int encrypted = 0;
> -    struct private_data *priv = conn->privateData;
> -    remote_is_secure_ret ret;
> -    remoteDriverLock(priv);
> -
> -    memset (&ret, 0, sizeof ret);
> -    if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
> -              (xdrproc_t) xdr_void, (char *) NULL,
> -              (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
> -        goto done;
> -
> -    if (priv->uses_tls)
> -        encrypted = 1;
> -#if HAVE_SASL
> -    else if (priv->saslconn)
> -        encrypted = 1;
> -#endif
> +    memset (&ret, 0, sizeof ret);
> +    if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
> +              (xdrproc_t) xdr_void, (char *) NULL,
> +              (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
> +        goto done;
>  
> +    if (virNetClientIsEncrypted(priv->client))
> +        encrypted = 1;
>  
>      /* We claim to be encrypted, if the remote driver
>       * transport itself is encrypted, and the remote
> @@ -2967,7 +2247,6 @@ remoteNWFilterClose(virConnectPtr conn)
>  
>  static int
>  remoteAuthenticate (virConnectPtr conn, struct private_data *priv,
> -                    int in_open ATTRIBUTE_UNUSED,
>                      virConnectAuthPtr auth ATTRIBUTE_UNUSED,
>                      const char *authtype)
>  {
> @@ -2975,16 +2254,19 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv,
>      int err, type = REMOTE_AUTH_NONE;
>  
>      memset(&ret, 0, sizeof ret);
> -    err = call (conn, priv,
> -                REMOTE_CALL_IN_OPEN | REMOTE_CALL_QUIET_MISSING_RPC,
> +    err = call (conn, priv, 0,
>                  REMOTE_PROC_AUTH_LIST,
>                  (xdrproc_t) xdr_void, (char *) NULL,
>                  (xdrproc_t) xdr_remote_auth_list_ret, (char *) &ret);
> -    if (err == -2) /* Missing RPC - old server - ignore */
> -        return 0;
> -
> -    if (err < 0)
> +    if (err < 0) {
> +        virErrorPtr verr = virGetLastError();
> +        if (verr && verr->code == VIR_ERR_NO_SUPPORT) {
> +            /* Missing RPC - old server - ignore */
> +            virResetLastError();
> +            return 0;
> +        }
>          return -1;
> +    }
>  
>      if (ret.types.types_len == 0)
>          return 0;
> @@ -3023,7 +2305,7 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv,
>              STRCASEEQLEN(authtype, "sasl.", 5))
>              mech = authtype + 5;
>  
> -        if (remoteAuthSASL(conn, priv, in_open, auth, mech) < 0) {
> +        if (remoteAuthSASL(conn, priv, auth, mech) < 0) {
>              VIR_FREE(ret.types.types_val);
>              return -1;
>          }
> @@ -3033,7 +2315,7 @@ remoteAuthenticate (virConnectPtr conn, struct private_data *priv,
>  
>  #if HAVE_POLKIT
>      case REMOTE_AUTH_POLKIT:
> -        if (remoteAuthPolkit(conn, priv, in_open, auth) < 0) {
> +        if (remoteAuthPolkit(conn, priv, auth) < 0) {
>              VIR_FREE(ret.types.types_val);
>              return -1;
>          }
> @@ -3225,11 +2507,9 @@ static void remoteAuthFillInteract(virConnectCredentialPtr cred,
>  /* Perform the SASL authentication process
>   */
>  static int
> -remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
> +remoteAuthSASL (virConnectPtr conn, struct private_data *priv,
>                  virConnectAuthPtr auth, const char *wantmech)
>  {
> -    sasl_conn_t *saslconn = NULL;
> -    sasl_security_properties_t secprops;
>      remote_auth_sasl_init_ret iret;
>      remote_auth_sasl_start_args sargs;
>      remote_auth_sasl_start_ret sret;
> @@ -3237,48 +2517,22 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>      remote_auth_sasl_step_ret pret;
>      const char *clientout;
>      char *serverin = NULL;
> -    unsigned int clientoutlen, serverinlen;
> +    size_t clientoutlen, serverinlen;
>      const char *mech;
>      int err, complete;
> -    virSocketAddr sa;
> -    char *localAddr = NULL, *remoteAddr = NULL;
> -    const void *val;
> -    sasl_ssf_t ssf;
> +    int ssf;
>      sasl_callback_t *saslcb = NULL;
>      sasl_interact_t *interact = NULL;
>      virConnectCredentialPtr cred = NULL;
>      int ncred = 0;
>      int ret = -1;
>      const char *mechlist;
> +    virNetSASLContextPtr saslCtxt;
> +    virNetSASLSessionPtr sasl;
>  
>      VIR_DEBUG("Client initialize SASL authentication");
> -    /* Sets up the SASL library as a whole */
> -    err = sasl_client_init(NULL);
> -    if (err != SASL_OK) {
> -        remoteError(VIR_ERR_AUTH_FAILED,
> -                    _("failed to initialize SASL library: %d (%s)"),
> -                    err, sasl_errstring(err, NULL, NULL));
> -        goto cleanup;
> -    }
>  
> -    /* Get local address in form  IPADDR:PORT */
> -    sa.len = sizeof(sa.data.stor);
> -    if (getsockname(priv->sock, &sa.data.sa, &sa.len) < 0) {
> -        virReportSystemError(errno, "%s",
> -                             _("failed to get sock address"));
> -        goto cleanup;
> -    }
> -    if ((localAddr = virSocketFormatAddrFull(&sa, true, ";")) == NULL)
> -        goto cleanup;
> -
> -    /* Get remote address in form  IPADDR:PORT */
> -    sa.len = sizeof(sa.data.stor);
> -    if (getpeername(priv->sock, &sa.data.sa, &sa.len) < 0) {
> -        virReportSystemError(errno, "%s",
> -                             _("failed to get peer address"));
> -        goto cleanup;
> -    }
> -    if ((remoteAddr = virSocketFormatAddrFull(&sa, true, ";")) == NULL)
> +    if (!(saslCtxt = virNetSASLContextNewClient()))
>          goto cleanup;
>  
>      if (auth) {
> @@ -3289,63 +2543,37 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>      }
>  
>      /* Setup a handle for being a client */
> -    err = sasl_client_new("libvirt",
> -                          priv->hostname,
> -                          localAddr,
> -                          remoteAddr,
> -                          saslcb,
> -                          SASL_SUCCESS_DATA,
> -                          &saslconn);
> -
> -    if (err != SASL_OK) {
> -        remoteError(VIR_ERR_AUTH_FAILED,
> -                    _("Failed to create SASL client context: %d (%s)"),
> -                    err, sasl_errstring(err, NULL, NULL));
> +    if (!(sasl = virNetSASLSessionNewClient(saslCtxt,
> +                                            "libvirt",
> +                                            priv->hostname,
> +                                            virNetClientLocalAddrString(priv->client),
> +                                            virNetClientRemoteAddrString(priv->client),
> +                                            saslcb)))
>          goto cleanup;
> -    }
>  
>      /* Initialize some connection props we care about */
> -    if (priv->uses_tls) {
> -        gnutls_cipher_algorithm_t cipher;
> -
> -        cipher = gnutls_cipher_get(priv->session);
> -        if (!(ssf = (sasl_ssf_t)gnutls_cipher_get_key_size(cipher))) {
> -            remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                        _("invalid cipher size for TLS session"));
> +    if (priv->tls) {
> +        if ((ssf = virNetClientGetTLSKeySize(priv->client)) < 0)
>              goto cleanup;
> -        }
> +
>          ssf *= 8; /* key size is bytes, sasl wants bits */
>  
>          VIR_DEBUG("Setting external SSF %d", ssf);
> -        err = sasl_setprop(saslconn, SASL_SSF_EXTERNAL, &ssf);
> -        if (err != SASL_OK) {
> -            remoteError(VIR_ERR_INTERNAL_ERROR,
> -                        _("cannot set external SSF %d (%s)"),
> -                        err, sasl_errstring(err, NULL, NULL));
> +        if (virNetSASLSessionExtKeySize(sasl, ssf) < 0)
>              goto cleanup;
> -        }
>      }
>  
> -    memset (&secprops, 0, sizeof secprops);
>      /* If we've got a secure channel (TLS or UNIX sock), we don't care about SSF */
> -    secprops.min_ssf = priv->is_secure ? 0 : 56; /* Equiv to DES supported by all Kerberos */
> -    secprops.max_ssf = priv->is_secure ? 0 : 100000; /* Very strong ! AES == 256 */
> -    secprops.maxbufsize = 100000;
>      /* If we're not secure, then forbid any anonymous or trivially crackable auth */
> -    secprops.security_flags = priv->is_secure ? 0 :
> -        SASL_SEC_NOANONYMOUS | SASL_SEC_NOPLAINTEXT;
> -
> -    err = sasl_setprop(saslconn, SASL_SEC_PROPS, &secprops);
> -    if (err != SASL_OK) {
> -        remoteError(VIR_ERR_INTERNAL_ERROR,
> -                    _("cannot set security props %d (%s)"),
> -                    err, sasl_errstring(err, NULL, NULL));
> +    if (virNetSASLSessionSecProps(sasl,
> +                                  priv->is_secure ? 0 : 56, /* Equiv to DES supported by all Kerberos */
> +                                  priv->is_secure ? 0 : 100000, /* Very strong ! AES == 256 */
> +                                  priv->is_secure ? true : false) < 0)
>          goto cleanup;
> -    }
>  
>      /* First call is to inquire about supported mechanisms in the server */
>      memset (&iret, 0, sizeof iret);
> -    if (call (conn, priv, in_open, REMOTE_PROC_AUTH_SASL_INIT,
> +    if (call (conn, priv, 0, REMOTE_PROC_AUTH_SASL_INIT,
>                (xdrproc_t) xdr_void, (char *)NULL,
>                (xdrproc_t) xdr_remote_auth_sasl_init_ret, (char *) &iret) != 0)
>          goto cleanup;
> @@ -3365,22 +2593,16 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>   restart:
>      /* Start the auth negotiation on the client end first */
>      VIR_DEBUG("Client start negotiation mechlist '%s'", mechlist);
> -    err = sasl_client_start(saslconn,
> -                            mechlist,
> -                            &interact,
> -                            &clientout,
> -                            &clientoutlen,
> -                            &mech);
> -    if (err != SASL_OK && err != SASL_CONTINUE && err != SASL_INTERACT) {
> -        remoteError(VIR_ERR_AUTH_FAILED,
> -                    _("Failed to start SASL negotiation: %d (%s)"),
> -                    err, sasl_errdetail(saslconn));
> -        VIR_FREE(iret.mechlist);
> +    if ((err = virNetSASLSessionClientStart(sasl,
> +                                            mechlist,
> +                                            &interact,
> +                                            &clientout,
> +                                            &clientoutlen,
> +                                            &mech)) < 0)
>          goto cleanup;
> -    }
>  
>      /* Need to gather some credentials from the client */
> -    if (err == SASL_INTERACT) {
> +    if (err == VIR_NET_SASL_INTERACT) {
>          const char *msg;
>          if (cred) {
>              remoteAuthFreeCredentials(cred, ncred);
> @@ -3410,7 +2632,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>      if (clientoutlen > REMOTE_AUTH_SASL_DATA_MAX) {
>          remoteError(VIR_ERR_AUTH_FAILED,
>                      _("SASL negotiation data too long: %d bytes"),
> -                    clientoutlen);
> +                    (int)clientoutlen);
>          goto cleanup;
>      }
>      /* NB, distinction of NULL vs "" is *critical* in SASL */
> @@ -3419,11 +2641,12 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>      sargs.data.data_val = (char*)clientout;
>      sargs.data.data_len = clientoutlen;
>      sargs.mech = (char*)mech;
> -    VIR_DEBUG("Server start negotiation with mech %s. Data %d bytes %p", mech, clientoutlen, clientout);
> +    VIR_DEBUG("Server start negotiation with mech %s. Data %d bytes %p",
> +              mech, (int)clientoutlen, clientout);
>  
>      /* Now send the initial auth data to the server */
>      memset (&sret, 0, sizeof sret);
> -    if (call (conn, priv, in_open, REMOTE_PROC_AUTH_SASL_START,
> +    if (call (conn, priv, 0, REMOTE_PROC_AUTH_SASL_START,
>                (xdrproc_t) xdr_remote_auth_sasl_start_args, (char *) &sargs,
>                (xdrproc_t) xdr_remote_auth_sasl_start_ret, (char *) &sret) != 0)
>          goto cleanup;
> @@ -3433,27 +2656,23 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>      serverin = sret.nil ? NULL : sret.data.data_val;
>      serverinlen = sret.data.data_len;
>      VIR_DEBUG("Client step result complete: %d. Data %d bytes %p",
> -          complete, serverinlen, serverin);
> +              complete, (int)serverinlen, serverin);
>  
>      /* Loop-the-loop...
>       * Even if the server has completed, the client must *always* do at least one step
>       * in this loop to verify the server isn't lying about something. Mutual auth */
>      for (;;) {
>      restep:
> -        err = sasl_client_step(saslconn,
> -                               serverin,
> -                               serverinlen,
> -                               &interact,
> -                               &clientout,
> -                               &clientoutlen);
> -        if (err != SASL_OK && err != SASL_CONTINUE && err != SASL_INTERACT) {
> -            remoteError(VIR_ERR_AUTH_FAILED,
> -                        _("Failed SASL step: %d (%s)"),
> -                        err, sasl_errdetail(saslconn));
> +        if ((err = virNetSASLSessionClientStep(sasl,
> +                                               serverin,
> +                                               serverinlen,
> +                                               &interact,
> +                                               &clientout,
> +                                               &clientoutlen)) < 0)
>              goto cleanup;
> -        }
> +
>          /* Need to gather some credentials from the client */
> -        if (err == SASL_INTERACT) {
> +        if (err == VIR_NET_SASL_INTERACT) {
>              const char *msg;
>              if (cred) {
>                  remoteAuthFreeCredentials(cred, ncred);
> @@ -3479,10 +2698,11 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>          }
>  
>          VIR_FREE(serverin);
> -        VIR_DEBUG("Client step result %d. Data %d bytes %p", err, clientoutlen, clientout);
> +        VIR_DEBUG("Client step result %d. Data %d bytes %p",
> +                  err, (int)clientoutlen, clientout);
>  
>          /* Previous server call showed completion & we're now locally complete too */
> -        if (complete && err == SASL_OK)
> +        if (complete && err == VIR_NET_SASL_COMPLETE)
>              break;
>  
>          /* Not done, prepare to talk with the server for another iteration */
> @@ -3491,10 +2711,11 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>          pargs.nil = clientout ? 0 : 1;
>          pargs.data.data_val = (char*)clientout;
>          pargs.data.data_len = clientoutlen;
> -        VIR_DEBUG("Server step with %d bytes %p", clientoutlen, clientout);
> +        VIR_DEBUG("Server step with %d bytes %p",
> +                  (int)clientoutlen, clientout);
>  
>          memset (&pret, 0, sizeof pret);
> -        if (call (conn, priv, in_open, REMOTE_PROC_AUTH_SASL_STEP,
> +        if (call (conn, priv, 0, REMOTE_PROC_AUTH_SASL_STEP,
>                    (xdrproc_t) xdr_remote_auth_sasl_step_args, (char *) &pargs,
>                    (xdrproc_t) xdr_remote_auth_sasl_step_ret, (char *) &pret) != 0)
>              goto cleanup;
> @@ -3505,10 +2726,10 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>          serverinlen = pret.data.data_len;
>  
>          VIR_DEBUG("Client step result complete: %d. Data %d bytes %p",
> -              complete, serverinlen, serverin);
> +                  complete, (int)serverinlen, serverin);
>  
>          /* This server call shows complete, and earlier client step was OK */
> -        if (complete && err == SASL_OK) {
> +        if (complete && err == VIR_NET_SASL_COMPLETE) {
>              VIR_FREE(serverin);
>              break;
>          }
> @@ -3516,14 +2737,9 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>  
>      /* Check for suitable SSF if not already secure (TLS or UNIX sock) */
>      if (!priv->is_secure) {
> -        err = sasl_getprop(saslconn, SASL_SSF, &val);
> -        if (err != SASL_OK) {
> -            remoteError(VIR_ERR_AUTH_FAILED,
> -                        _("cannot query SASL ssf on connection %d (%s)"),
> -                        err, sasl_errstring(err, NULL, NULL));
> +        if ((ssf = virNetSASLSessionGetKeySize(sasl)) < 0)
>              goto cleanup;
> -        }
> -        ssf = *(const int *)val;
> +
>          VIR_DEBUG("SASL SSF value %d", ssf);
>          if (ssf < 56) { /* 56 == DES level, good for Kerberos */
>              remoteError(VIR_ERR_AUTH_FAILED,
> @@ -3534,18 +2750,16 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>      }
>  
>      VIR_DEBUG("SASL authentication complete");
> -    priv->saslconn = saslconn;
> +    virNetClientSetSASLSession(priv->client, sasl);
>      ret = 0;
>  
>   cleanup:
> -    VIR_FREE(localAddr);
> -    VIR_FREE(remoteAddr);
>      VIR_FREE(serverin);
>  
>      VIR_FREE(saslcb);
>      remoteAuthFreeCredentials(cred, ncred);
> -    if (ret != 0 && saslconn)
> -        sasl_dispose(&saslconn);
> +    virNetSASLSessionFree(sasl);
> +    virNetSASLContextFree(saslCtxt);
>  
>      return ret;
>  }
> @@ -3555,14 +2769,14 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
>  #if HAVE_POLKIT
>  # if HAVE_POLKIT1
>  static int
> -remoteAuthPolkit (virConnectPtr conn, struct private_data *priv, int in_open,
> +remoteAuthPolkit (virConnectPtr conn, struct private_data *priv,
>                    virConnectAuthPtr auth ATTRIBUTE_UNUSED)
>  {
>      remote_auth_polkit_ret ret;
>      VIR_DEBUG("Client initialize PolicyKit-1 authentication");
>  
>      memset (&ret, 0, sizeof ret);
> -    if (call (conn, priv, in_open, REMOTE_PROC_AUTH_POLKIT,
> +    if (call (conn, priv, 0, REMOTE_PROC_AUTH_POLKIT,
>                (xdrproc_t) xdr_void, (char *)NULL,
>                (xdrproc_t) xdr_remote_auth_polkit_ret, (char *) &ret) != 0) {
>          return -1; /* virError already set by call */
> @@ -3575,7 +2789,7 @@ remoteAuthPolkit (virConnectPtr conn, struct private_data *priv, int in_open,
>  /* Perform the PolicyKit authentication process
>   */
>  static int
> -remoteAuthPolkit (virConnectPtr conn, struct private_data *priv, int in_open,
> +remoteAuthPolkit (virConnectPtr conn, struct private_data *priv,
>                    virConnectAuthPtr auth)
>  {
>      remote_auth_polkit_ret ret;
> @@ -3613,7 +2827,7 @@ remoteAuthPolkit (virConnectPtr conn, struct private_data *priv, int in_open,
>      }
>  
>      memset (&ret, 0, sizeof ret);
> -    if (call (conn, priv, in_open, REMOTE_PROC_AUTH_POLKIT,
> +    if (call (conn, priv, 0, REMOTE_PROC_AUTH_POLKIT,
>                (xdrproc_t) xdr_void, (char *)NULL,
>                (xdrproc_t) xdr_remote_auth_polkit_ret, (char *) &ret) != 0) {
>          return -1; /* virError already set by call */
> @@ -3694,184 +2908,155 @@ done:
>      return rv;
>  }
>  
> -/**
> - * remoteDomainReadEventLifecycle
> - *
> - * Read the domain lifecycle event data off the wire
> - */
> -static virDomainEventPtr
> -remoteDomainReadEventLifecycle(virConnectPtr conn, XDR *xdr)
> +
> +static void
> +remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                                virNetClientPtr client ATTRIBUTE_UNUSED,
> +                                void *evdata, void *opaque)
>  {
> -    remote_domain_event_lifecycle_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_lifecycle_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_lifecycle_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal lifecycle event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> -
> -    event = virDomainEventNewFromDom(dom, msg.event, msg.detail);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_lifecycle_msg, (char *) &msg);
> +        return;
>  
> +    event = virDomainEventNewFromDom(dom, msg->event, msg->detail);
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventReboot(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                             virNetClientPtr client ATTRIBUTE_UNUSED,
> +                             void *evdata, void *opaque)
>  {
> -    remote_domain_event_reboot_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_reboot_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_reboot_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal reboot event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> +        return;
>  
>      event = virDomainEventRebootNewFromDom(dom);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_reboot_msg, (char *) &msg);
> -
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventRTCChange(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                                virNetClientPtr client ATTRIBUTE_UNUSED,
> +                                void *evdata, void *opaque)
>  {
> -    remote_domain_event_rtc_change_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_rtc_change_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_rtc_change_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal RTC change event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> -
> -    event = virDomainEventRTCChangeNewFromDom(dom, msg.offset);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_rtc_change_msg, (char *) &msg);
> +        return;
>  
> +    event = virDomainEventRTCChangeNewFromDom(dom, msg->offset);
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventWatchdog(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                               virNetClientPtr client ATTRIBUTE_UNUSED,
> +                               void *evdata, void *opaque)
>  {
> -    remote_domain_event_watchdog_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_watchdog_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_watchdog_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal watchdog event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> -
> -    event = virDomainEventWatchdogNewFromDom(dom, msg.action);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_watchdog_msg, (char *) &msg);
> +        return;
>  
> +    event = virDomainEventWatchdogNewFromDom(dom, msg->action);
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventIOError(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                              virNetClientPtr client ATTRIBUTE_UNUSED,
> +                              void *evdata, void *opaque)
>  {
> -    remote_domain_event_io_error_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_io_error_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_io_error_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal IO error event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> +        return;
>  
>      event = virDomainEventIOErrorNewFromDom(dom,
> -                                            msg.srcPath,
> -                                            msg.devAlias,
> -                                            msg.action);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_io_error_msg, (char *) &msg);
> -
> +                                            msg->srcPath,
> +                                            msg->devAlias,
> +                                            msg->action);
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventIOErrorReason(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                                    virNetClientPtr client ATTRIBUTE_UNUSED,
> +                                    void *evdata, void *opaque)
>  {
> -    remote_domain_event_io_error_reason_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_io_error_reason_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_io_error_reason_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal IO error reason event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn,msg->dom);
>      if (!dom)
> -        return NULL;
> +        return;
>  
>      event = virDomainEventIOErrorReasonNewFromDom(dom,
> -                                                  msg.srcPath,
> -                                                  msg.devAlias,
> -                                                  msg.action,
> -                                                  msg.reason);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_io_error_reason_msg, (char *) &msg);
> +                                                  msg->srcPath,
> +                                                  msg->devAlias,
> +                                                  msg->action,
> +                                                  msg->reason);
>  
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventGraphics(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                               virNetClientPtr client ATTRIBUTE_UNUSED,
> +                               void *evdata, void *opaque)
>  {
> -    remote_domain_event_graphics_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_graphics_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
>      virDomainEventGraphicsAddressPtr localAddr = NULL;
> @@ -3879,58 +3064,48 @@ remoteDomainReadEventGraphics(virConnectPtr conn, XDR *xdr)
>      virDomainEventGraphicsSubjectPtr subject = NULL;
>      int i;
>  
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshal parameters, and process it*/
> -    if (! xdr_remote_domain_event_graphics_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("Unable to demarshal graphics event"));
> -        return NULL;
> -    }
> -
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> +        return;
>  
>      if (VIR_ALLOC(localAddr) < 0)
>          goto no_memory;
> -    localAddr->family = msg.local.family;
> -    if (!(localAddr->service = strdup(msg.local.service)) ||
> -        !(localAddr->node = strdup(msg.local.node)))
> +    localAddr->family = msg->local.family;
> +    if (!(localAddr->service = strdup(msg->local.service)) ||
> +        !(localAddr->node = strdup(msg->local.node)))
>          goto no_memory;
>  
>      if (VIR_ALLOC(remoteAddr) < 0)
>          goto no_memory;
> -    remoteAddr->family = msg.remote.family;
> -    if (!(remoteAddr->service = strdup(msg.remote.service)) ||
> -        !(remoteAddr->node = strdup(msg.remote.node)))
> +    remoteAddr->family = msg->remote.family;
> +    if (!(remoteAddr->service = strdup(msg->remote.service)) ||
> +        !(remoteAddr->node = strdup(msg->remote.node)))
>          goto no_memory;
>  
>      if (VIR_ALLOC(subject) < 0)
>          goto no_memory;
> -    if (VIR_ALLOC_N(subject->identities, msg.subject.subject_len) < 0)
> +    if (VIR_ALLOC_N(subject->identities, msg->subject.subject_len) < 0)
>          goto no_memory;
> -    subject->nidentity = msg.subject.subject_len;
> +    subject->nidentity = msg->subject.subject_len;
>      for (i = 0 ; i < subject->nidentity ; i++) {
> -        if (!(subject->identities[i].type = strdup(msg.subject.subject_val[i].type)) ||
> -            !(subject->identities[i].name = strdup(msg.subject.subject_val[i].name)))
> +        if (!(subject->identities[i].type = strdup(msg->subject.subject_val[i].type)) ||
> +            !(subject->identities[i].name = strdup(msg->subject.subject_val[i].name)))
>              goto no_memory;
>      }
>  
>      event = virDomainEventGraphicsNewFromDom(dom,
> -                                             msg.phase,
> +                                             msg->phase,
>                                               localAddr,
>                                               remoteAddr,
> -                                             msg.authScheme,
> +                                             msg->authScheme,
>                                               subject);
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_graphics_msg, (char *) &msg);
>  
>      virDomainFree(dom);
> -    return event;
>  
> -no_memory:
> -    xdr_free ((xdrproc_t) &xdr_remote_domain_event_graphics_msg, (char *) &msg);
> +    remoteDomainEventQueue(priv, event);
> +    return;
>  
> +no_memory:
>      if (localAddr) {
>          VIR_FREE(localAddr->service);
>          VIR_FREE(localAddr->node);
> @@ -3949,34 +3124,31 @@ no_memory:
>          VIR_FREE(subject->identities);
>          VIR_FREE(subject);
>      }
> -    return NULL;
> +    return;
>  }
>  
>  
> -static virDomainEventPtr
> -remoteDomainReadEventControlError(virConnectPtr conn, XDR *xdr)
> +static void
> +remoteDomainBuildEventControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                                   virNetClientPtr client ATTRIBUTE_UNUSED,
> +                                   void *evdata, void *opaque)
>  {
> -    remote_domain_event_control_error_msg msg;
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_control_error_msg *msg = evdata;
>      virDomainPtr dom;
>      virDomainEventPtr event = NULL;
> -    memset (&msg, 0, sizeof msg);
> -
> -    /* unmarshall parameters, and process it*/
> -    if (! xdr_remote_domain_event_control_error_msg(xdr, &msg) ) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("unable to demarshall reboot event"));
> -        return NULL;
> -    }
>  
> -    dom = get_nonnull_domain(conn,msg.dom);
> +    dom = get_nonnull_domain(conn, msg->dom);
>      if (!dom)
> -        return NULL;
> +        return;
>  
>      event = virDomainEventControlErrorNewFromDom(dom);
>      xdr_free ((xdrproc_t) &xdr_remote_domain_event_control_error_msg, (char *) &msg);
>  
>      virDomainFree(dom);
> -    return event;
> +
> +    remoteDomainEventQueue(priv, event);
>  }
>  
>  
> @@ -4020,195 +3192,6 @@ done:
>      return rv;
>  }
>  
> -static struct private_stream_data *
> -remoteStreamOpen(virStreamPtr st,
> -                 unsigned int proc_nr,
> -                 unsigned int serial)
> -{
> -    struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *stpriv;
> -
> -    if (VIR_ALLOC(stpriv) < 0) {
> -        virReportOOMError();
> -        return NULL;
> -    }
> -
> -    /* Initialize call object used to receive replies */
> -    stpriv->proc_nr = proc_nr;
> -    stpriv->serial = serial;
> -
> -    stpriv->next = priv->streams;
> -    priv->streams = stpriv;
> -
> -    return stpriv;
> -}
> -
> -
> -static void
> -remoteStreamEventTimerUpdate(struct private_stream_data *privst)
> -{
> -    if (!privst->cb)
> -        return;
> -
> -    VIR_DEBUG("Check timer offset=%d %d", privst->incomingOffset, privst->cbEvents);
> -    if ((privst->incomingOffset &&
> -         (privst->cbEvents & VIR_STREAM_EVENT_READABLE)) ||
> -        (privst->cbEvents & VIR_STREAM_EVENT_WRITABLE)) {
> -        VIR_DEBUG("Enabling event timer");
> -        virEventUpdateTimeout(privst->cbTimer, 0);
> -    } else {
> -        VIR_DEBUG("Disabling event timer");
> -        virEventUpdateTimeout(privst->cbTimer, -1);
> -    }
> -}
> -
> -
> -static int
> -remoteStreamPacket(virStreamPtr st,
> -                   int status,
> -                   const char *data,
> -                   size_t nbytes)
> -{
> -    VIR_DEBUG("st=%p status=%d data=%p nbytes=%zu", st, status, data, nbytes);
> -    struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> -    XDR xdr;
> -    struct remote_thread_call *thiscall;
> -    remote_message_header hdr;
> -    int ret;
> -
> -    memset(&hdr, 0, sizeof hdr);
> -
> -    if (VIR_ALLOC(thiscall) < 0) {
> -        virReportOOMError();
> -        return -1;
> -    }
> -
> -    thiscall->mode = REMOTE_MODE_WAIT_TX;
> -    thiscall->serial = privst->serial;
> -    thiscall->proc_nr = privst->proc_nr;
> -    if (status == REMOTE_OK ||
> -        status == REMOTE_ERROR)
> -        thiscall->want_reply = 1;
> -
> -    if (virCondInit(&thiscall->cond) < 0) {
> -        VIR_FREE(thiscall);
> -        remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                    _("cannot initialize mutex"));
> -        return -1;
> -    }
> -
> -    /* Don't fill in any other fields in 'thiscall' since
> -     * we're not expecting a reply for this */
> -
> -    hdr.prog = REMOTE_PROGRAM;
> -    hdr.vers = REMOTE_PROTOCOL_VERSION;
> -    hdr.proc = privst->proc_nr;
> -    hdr.type = REMOTE_STREAM;
> -    hdr.serial = privst->serial;
> -    hdr.status = status;
> -
> -
> -    /* Length must include the length word itself (always encoded in
> -     * 4 bytes as per RFC 4506), so offset start length. We write this
> -     * later.
> -     */
> -    thiscall->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
> -
> -    /* Serialise header followed by args. */
> -    xdrmem_create (&xdr, thiscall->buffer + thiscall->bufferLength,
> -                   REMOTE_MESSAGE_MAX, XDR_ENCODE);
> -    if (!xdr_remote_message_header (&xdr, &hdr)) {
> -        remoteError(VIR_ERR_RPC, "%s", _("xdr_remote_message_header failed"));
> -        goto error;
> -    }
> -
> -    thiscall->bufferLength += xdr_getpos (&xdr);
> -    xdr_destroy (&xdr);
> -
> -    if (status == REMOTE_CONTINUE) {
> -        if (((4 + REMOTE_MESSAGE_MAX) - thiscall->bufferLength) < nbytes) {
> -            remoteError(VIR_ERR_RPC, _("data size %zu too large for payload %d"),
> -                        nbytes, ((4 + REMOTE_MESSAGE_MAX) - thiscall->bufferLength));
> -            goto error;
> -        }
> -
> -        memcpy(thiscall->buffer + thiscall->bufferLength, data, nbytes);
> -        thiscall->bufferLength += nbytes;
> -    }
> -
> -    /* Go back to packet start and encode the length word. */
> -    xdrmem_create (&xdr, thiscall->buffer, REMOTE_MESSAGE_HEADER_XDR_LEN, XDR_ENCODE);
> -    if (!xdr_u_int (&xdr, &thiscall->bufferLength)) {
> -        remoteError(VIR_ERR_RPC, "%s", _("xdr_u_int (length word)"));
> -        goto error;
> -    }
> -    xdr_destroy (&xdr);
> -
> -    ret = remoteIO(st->conn, priv, 0, thiscall);
> -    ignore_value(virCondDestroy(&thiscall->cond));
> -    VIR_FREE(thiscall);
> -    if (ret < 0)
> -        return -1;
> -
> -    return nbytes;
> -
> -error:
> -    xdr_destroy (&xdr);
> -    ignore_value(virCondDestroy(&thiscall->cond));
> -    VIR_FREE(thiscall);
> -    return -1;
> -}
> -
> -static int
> -remoteStreamHasError(virStreamPtr st) {
> -    struct private_stream_data *privst = st->privateData;
> -    if (!privst->has_error) {
> -        return 0;
> -    }
> -
> -    VIR_DEBUG("Raising async error");
> -    virRaiseErrorFull(__FILE__, __FUNCTION__, __LINE__,
> -                      privst->err.domain,
> -                      privst->err.code,
> -                      privst->err.level,
> -                      privst->err.str1 ? *privst->err.str1 : NULL,
> -                      privst->err.str2 ? *privst->err.str2 : NULL,
> -                      privst->err.str3 ? *privst->err.str3 : NULL,
> -                      privst->err.int1,
> -                      privst->err.int2,
> -                      "%s", privst->err.message ? *privst->err.message : NULL);
> -
> -    return 1;
> -}
> -
> -static void
> -remoteStreamRelease(virStreamPtr st)
> -{
> -    struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> -
> -    if (priv->streams == privst)
> -        priv->streams = privst->next;
> -    else {
> -        struct private_stream_data *tmp = priv->streams;
> -        while (tmp && tmp->next) {
> -            if (tmp->next == privst) {
> -                tmp->next = privst->next;
> -                break;
> -            }
> -        }
> -    }
> -
> -    if (privst->has_error)
> -        xdr_free((xdrproc_t)xdr_remote_error,  (char *)&privst->err);
> -
> -    VIR_FREE(privst);
> -
> -    st->driver = NULL;
> -    st->privateData = NULL;
> -}
> -
>  
>  static int
>  remoteStreamSend(virStreamPtr st,
> @@ -4217,22 +3200,21 @@ remoteStreamSend(virStreamPtr st,
>  {
>      VIR_DEBUG("st=%p data=%p nbytes=%zu", st, data, nbytes);
>      struct private_data *priv = st->conn->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int rv = -1;
>  
>      remoteDriverLock(priv);
>  
> -    if (remoteStreamHasError(st))
> +    if (virNetClientStreamRaiseError(privst))
>          goto cleanup;
>  
> -    rv = remoteStreamPacket(st,
> -                            REMOTE_CONTINUE,
> -                            data,
> -                            nbytes);
> +    rv = virNetClientStreamSendPacket(privst,
> +                                      priv->client,
> +                                      VIR_NET_CONTINUE,
> +                                      data,
> +                                      nbytes);
>  
>  cleanup:
> -    if (rv == -1)
> -        remoteStreamRelease(st);
> -
>      remoteDriverUnlock(priv);
>  
>      return rv;
> @@ -4246,123 +3228,57 @@ remoteStreamRecv(virStreamPtr st,
>  {
>      VIR_DEBUG("st=%p data=%p nbytes=%zu", st, data, nbytes);
>      struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int rv = -1;
>  
>      remoteDriverLock(priv);
>  
> -    if (remoteStreamHasError(st))
> +    if (virNetClientStreamRaiseError(privst))
>          goto cleanup;
>  
> -    if (!privst->incomingOffset) {
> -        struct remote_thread_call *thiscall;
> -        int ret;
> -
> -        if (st->flags & VIR_STREAM_NONBLOCK) {
> -            VIR_DEBUG("Non-blocking mode and no data available");
> -            rv = -2;
> -            goto cleanup;
> -        }
> -
> -        if (VIR_ALLOC(thiscall) < 0) {
> -            virReportOOMError();
> -            goto cleanup;
> -        }
> -
> -        /* We're not really doing an RPC calls, so we're
> -         * skipping straight to RX part */
> -        thiscall->mode = REMOTE_MODE_WAIT_RX;
> -        thiscall->serial = privst->serial;
> -        thiscall->proc_nr = privst->proc_nr;
> -        thiscall->want_reply = 1;
> -
> -        if (virCondInit(&thiscall->cond) < 0) {
> -            VIR_FREE(thiscall);
> -            remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                        _("cannot initialize mutex"));
> -            goto cleanup;
> -        }
> -
> -        ret = remoteIO(st->conn, priv, 0, thiscall);
> -        ignore_value(virCondDestroy(&thiscall->cond));
> -        VIR_FREE(thiscall);
> -        if (ret < 0)
> -            goto cleanup;
> -    }
> -
> -    VIR_DEBUG("After IO %d", privst->incomingOffset);
> -    if (privst->incomingOffset) {
> -        int want = privst->incomingOffset;
> -        if (want > nbytes)
> -            want = nbytes;
> -        memcpy(data, privst->incoming, want);
> -        if (want < privst->incomingOffset) {
> -            memmove(privst->incoming, privst->incoming + want, privst->incomingOffset - want);
> -            privst->incomingOffset -= want;
> -        } else {
> -            VIR_FREE(privst->incoming);
> -            privst->incomingOffset = privst->incomingLength = 0;
> -        }
> -        rv = want;
> -    } else {
> -        rv = 0;
> -    }
> -
> -    remoteStreamEventTimerUpdate(privst);
> +    rv = virNetClientStreamRecvPacket(privst,
> +                                      priv->client,
> +                                      data,
> +                                      nbytes,
> +                                      (st->flags & VIR_STREAM_NONBLOCK));
>  
>      VIR_DEBUG("Done %d", rv);
>  
>  cleanup:
> -    if (rv == -1)
> -        remoteStreamRelease(st);
>      remoteDriverUnlock(priv);
>  
>      return rv;
>  }
>  
> +struct remoteStreamCallbackData {
> +    virStreamPtr st;
> +    virStreamEventCallback cb;
> +    void *opaque;
> +    virFreeCallback ff;
> +};
>  
> -static void
> -remoteStreamEventTimer(int timer ATTRIBUTE_UNUSED, void *opaque)
> +static void remoteStreamEventCallback(virNetClientStreamPtr stream ATTRIBUTE_UNUSED,
> +                                      int events,
> +                                      void *opaque)
>  {
> -    virStreamPtr st = opaque;
> -    struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> -    int events = 0;
> -
> -    remoteDriverLock(priv);
> -
> -    if (privst->cb &&
> -        (privst->cbEvents & VIR_STREAM_EVENT_READABLE) &&
> -        privst->incomingOffset)
> -        events |= VIR_STREAM_EVENT_READABLE;
> -    if (privst->cb &&
> -        (privst->cbEvents & VIR_STREAM_EVENT_WRITABLE))
> -        events |= VIR_STREAM_EVENT_WRITABLE;
> -    VIR_DEBUG("Got Timer dispatch %d %d offset=%d", events, privst->cbEvents, privst->incomingOffset);
> -    if (events) {
> -        virStreamEventCallback cb = privst->cb;
> -        void *cbOpaque = privst->cbOpaque;
> -        virFreeCallback cbFree = privst->cbFree;
> -
> -        privst->cbDispatch = 1;
> -        remoteDriverUnlock(priv);
> -        (cb)(st, events, cbOpaque);
> -        remoteDriverLock(priv);
> -        privst->cbDispatch = 0;
> -
> -        if (!privst->cb && cbFree)
> -            (cbFree)(cbOpaque);
> -    }
> +    struct remoteStreamCallbackData *cbdata = opaque;
> +    struct private_data *priv = cbdata->st->conn->privateData;
>  
>      remoteDriverUnlock(priv);
> +    (cbdata->cb)(cbdata->st, events, cbdata->opaque);
> +    remoteDriverLock(priv);
>  }
>  
>  
> -static void
> -remoteStreamEventTimerFree(void *opaque)
> +static void remoteStreamCallbackFree(void *opaque)
>  {
> -    virStreamPtr st = opaque;
> -    virUnrefStream(st);
> +    struct remoteStreamCallbackData *cbdata = opaque;
> +
> +    if (!cbdata->cb && cbdata->ff)
> +        (cbdata->ff)(cbdata->opaque);
> +
> +    virStreamFree(cbdata->st);
> +    VIR_FREE(opaque);
>  }
>  
>  
> @@ -4374,148 +3290,128 @@ remoteStreamEventAddCallback(virStreamPtr st,
>                               virFreeCallback ff)
>  {
>      struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int ret = -1;
> +    struct remoteStreamCallbackData *cbdata;
>  
> -    remoteDriverLock(priv);
> -
> -    if (privst->cb) {
> -        remoteError(VIR_ERR_INTERNAL_ERROR,
> -                    "%s", _("multiple stream callbacks not supported"));
> -        goto cleanup;
> +    if (VIR_ALLOC(cbdata) < 0) {
> +        virReportOOMError();
> +        return -1;
>      }
> -
> +    cbdata->cb = cb;
> +    cbdata->opaque = opaque;
> +    cbdata->ff = ff;
> +    cbdata->st = st;
>      virStreamRef(st);
> -    if ((privst->cbTimer =
> -         virEventAddTimeout(-1,
> -                            remoteStreamEventTimer,
> -                            st,
> -                            remoteStreamEventTimerFree)) < 0) {
> -        virUnrefStream(st);
> -        goto cleanup;
> -    }
>  
> -    privst->cb = cb;
> -    privst->cbOpaque = opaque;
> -    privst->cbFree = ff;
> -    privst->cbEvents = events;
> -
> -    remoteStreamEventTimerUpdate(privst);
> +    remoteDriverLock(priv);
>  
> -    ret = 0;
> +    if ((ret = virNetClientStreamEventAddCallback(privst,
> +                                                  events,
> +                                                  remoteStreamEventCallback,
> +                                                  cbdata,
> +                                                  remoteStreamCallbackFree)) < 0) {
> +        VIR_FREE(cbdata);
> +        goto cleanup;
> +    }
>  
>  cleanup:
>      remoteDriverUnlock(priv);
>      return ret;
>  }
>  
> +
>  static int
>  remoteStreamEventUpdateCallback(virStreamPtr st,
>                                  int events)
>  {
>      struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int ret = -1;
>  
>      remoteDriverLock(priv);
>  
> -    if (!privst->cb) {
> -        remoteError(VIR_ERR_INTERNAL_ERROR,
> -                    "%s", _("no stream callback registered"));
> -        goto cleanup;
> -    }
> +    ret = virNetClientStreamEventUpdateCallback(privst, events);
>  
> -    privst->cbEvents = events;
> -
> -    remoteStreamEventTimerUpdate(privst);
> -
> -    ret = 0;
> -
> -cleanup:
> -    remoteDriverUnlock(priv);
> -    return ret;
> -}
> +    remoteDriverUnlock(priv);
> +    return ret;
> +}
>  
>  
>  static int
>  remoteStreamEventRemoveCallback(virStreamPtr st)
>  {
>      struct private_data *priv = st->conn->privateData;
> -    struct private_stream_data *privst = st->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int ret = -1;
>  
>      remoteDriverLock(priv);
>  
> -    if (!privst->cb) {
> -        remoteError(VIR_ERR_INTERNAL_ERROR,
> -                    "%s", _("no stream callback registered"));
> -        goto cleanup;
> -    }
> -
> -    if (!privst->cbDispatch &&
> -        privst->cbFree)
> -        (privst->cbFree)(privst->cbOpaque);
> -    privst->cb = NULL;
> -    privst->cbOpaque = NULL;
> -    privst->cbFree = NULL;
> -    privst->cbEvents = 0;
> -    virEventRemoveTimeout(privst->cbTimer);
> -
> -    ret = 0;
> +    ret = virNetClientStreamEventRemoveCallback(privst);
>  
> -cleanup:
>      remoteDriverUnlock(priv);
>      return ret;
>  }
>  
> +
>  static int
>  remoteStreamFinish(virStreamPtr st)
>  {
>      struct private_data *priv = st->conn->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int ret = -1;
>  
>      remoteDriverLock(priv);
>  
> -    if (remoteStreamHasError(st))
> +    if (virNetClientStreamRaiseError(privst))
>          goto cleanup;
>  
> -    ret = remoteStreamPacket(st,
> -                             REMOTE_OK,
> -                             NULL,
> -                             0);
> +    ret = virNetClientStreamSendPacket(privst,
> +                                       priv->client,
> +                                       VIR_NET_OK,
> +                                       NULL,
> +                                       0);
>  
>  cleanup:
> -    remoteStreamRelease(st);
> +    virNetClientRemoveStream(priv->client, privst);
> +    virNetClientStreamFree(privst);
> +    st->privateData = NULL;
> +    st->driver = NULL;
>  
>      remoteDriverUnlock(priv);
>      return ret;
>  }
>  
> +
>  static int
>  remoteStreamAbort(virStreamPtr st)
>  {
>      struct private_data *priv = st->conn->privateData;
> +    virNetClientStreamPtr privst = st->privateData;
>      int ret = -1;
>  
>      remoteDriverLock(priv);
>  
> -    if (remoteStreamHasError(st))
> +    if (virNetClientStreamRaiseError(privst))
>          goto cleanup;
>  
> -    ret = remoteStreamPacket(st,
> -                             REMOTE_ERROR,
> -                             NULL,
> -                             0);
> +    ret = virNetClientStreamSendPacket(privst,
> +                                       priv->client,
> +                                       VIR_NET_ERROR,
> +                                       NULL,
> +                                       0);
>  
>  cleanup:
> -    remoteStreamRelease(st);
> +    virNetClientRemoveStream(priv->client, privst);
> +    virNetClientStreamFree(privst);
> +    st->privateData = NULL;
> +    st->driver = NULL;
>  
>      remoteDriverUnlock(priv);
>      return ret;
>  }
>  
>  
> -
>  static virStreamDriver remoteStreamDrv = {
>      .streamRecv = remoteStreamRecv,
>      .streamSend = remoteStreamSend,
> @@ -4526,6 +3422,7 @@ static virStreamDriver remoteStreamDrv = {
>      .streamRemoveCallback = remoteStreamEventRemoveCallback,
>  };
>  
> +
>  static int remoteDomainEventRegisterAny(virConnectPtr conn,
>                                          virDomainPtr dom,
>                                          int eventID,
> @@ -4620,6 +3517,7 @@ done:
>      return rv;
>  }
>  
> +
>  /*----------------------------------------------------------------------*/
>  
>  static int
> @@ -4793,23 +3691,28 @@ remoteDomainMigratePrepareTunnel3(virConnectPtr dconn,
>                                    const char *dom_xml)
>  {
>      struct private_data *priv = dconn->privateData;
> -    struct private_stream_data *privst = NULL;
>      int rv = -1;
>      remote_domain_migrate_prepare_tunnel3_args args;
>      remote_domain_migrate_prepare_tunnel3_ret ret;
> +    virNetClientStreamPtr netst;
>  
>      remoteDriverLock(priv);
>  
>      memset(&args, 0, sizeof(args));
>      memset(&ret, 0, sizeof(ret));
>  
> -    if (!(privst = remoteStreamOpen(st,
> -                                    REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3,
> -                                    priv->counter)))
> +    if (!(netst = virNetClientStreamNew(priv->remoteProgram,
> +                                        REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL,
> +                                        priv->counter)))
>          goto done;
>  
> +    if (virNetClientAddStream(priv->client, netst) < 0) {
> +        virNetClientStreamFree(netst);
> +        goto done;
> +    }
> +
>      st->driver = &remoteStreamDrv;
> -    st->privateData = privst;
> +    st->privateData = netst;
>  
>      args.cookie_in.cookie_in_val = (char *)cookiein;
>      args.cookie_in.cookie_in_len = cookieinlen;
> @@ -4821,7 +3724,8 @@ remoteDomainMigratePrepareTunnel3(virConnectPtr dconn,
>      if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3,
>               (xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_args, (char *) &args,
>               (xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_ret, (char *) &ret) == -1) {
> -        remoteStreamRelease(st);
> +        virNetClientRemoveStream(priv->client, netst);
> +        virNetClientStreamFree(netst);
>          goto done;
>      }
>  
> @@ -5006,1251 +3910,41 @@ done:
>  #include "remote_client_bodies.h"
>  #include "qemu_client_bodies.h"
>  
> -
> -/*----------------------------------------------------------------------*/
> -
> -static struct remote_thread_call *
> -prepareCall(struct private_data *priv,
> -            int flags,
> -            int proc_nr,
> -            xdrproc_t args_filter, char *args,
> -            xdrproc_t ret_filter, char *ret)
> -{
> -    XDR xdr;
> -    struct remote_message_header hdr;
> -    struct remote_thread_call *rv;
> -
> -    if (VIR_ALLOC(rv) < 0) {
> -        virReportOOMError();
> -        return NULL;
> -    }
> -
> -    if (virCondInit(&rv->cond) < 0) {
> -        VIR_FREE(rv);
> -        remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                    _("cannot initialize mutex"));
> -        return NULL;
> -    }
> -
> -    /* Get a unique serial number for this message. */
> -    rv->serial = priv->counter++;
> -    rv->proc_nr = proc_nr;
> -    rv->ret_filter = ret_filter;
> -    rv->ret = ret;
> -    rv->want_reply = 1;
> -
> -    if (flags & REMOTE_CALL_QEMU) {
> -        hdr.prog = QEMU_PROGRAM;
> -        hdr.vers = QEMU_PROTOCOL_VERSION;
> -    }
> -    else {
> -        hdr.prog = REMOTE_PROGRAM;
> -        hdr.vers = REMOTE_PROTOCOL_VERSION;
> -    }
> -    hdr.proc = proc_nr;
> -    hdr.type = REMOTE_CALL;
> -    hdr.serial = rv->serial;
> -    hdr.status = REMOTE_OK;
> -
> -    /* Serialise header followed by args. */
> -    xdrmem_create (&xdr, rv->buffer+4, REMOTE_MESSAGE_MAX, XDR_ENCODE);
> -    if (!xdr_remote_message_header (&xdr, &hdr)) {
> -        remoteError(VIR_ERR_RPC, "%s", _("xdr_remote_message_header failed"));
> -        goto error;
> -    }
> -
> -    if (!(*args_filter) (&xdr, args)) {
> -        remoteError(VIR_ERR_RPC,
> -                    _("Unable to marshal arguments for program %d version %d procedure %d type %d status %d"),
> -                    hdr.prog, hdr.vers, hdr.proc, hdr.type, hdr.status);
> -        goto error;
> -    }
> -
> -    /* Get the length stored in buffer. */
> -    rv->bufferLength = xdr_getpos (&xdr);
> -    xdr_destroy (&xdr);
> -
> -    /* Length must include the length word itself (always encoded in
> -     * 4 bytes as per RFC 4506).
> -     */
> -    rv->bufferLength += REMOTE_MESSAGE_HEADER_XDR_LEN;
> -
> -    /* Encode the length word. */
> -    xdrmem_create (&xdr, rv->buffer, REMOTE_MESSAGE_HEADER_XDR_LEN, XDR_ENCODE);
> -    if (!xdr_u_int (&xdr, &rv->bufferLength)) {
> -        remoteError(VIR_ERR_RPC, "%s", _("xdr_u_int (length word)"));
> -        goto error;
> -    }
> -    xdr_destroy (&xdr);
> -
> -    return rv;
> -
> -error:
> -    xdr_destroy (&xdr);
> -    ignore_value(virCondDestroy(&rv->cond));
> -    VIR_FREE(rv);
> -    return NULL;
> -}
> -
> -
> -
> -static int
> -remoteIOWriteBuffer(struct private_data *priv,
> -                    const char *bytes, int len)
> -{
> -    int ret;
> -
> -    if (priv->uses_tls) {
> -    tls_resend:
> -        ret = gnutls_record_send (priv->session, bytes, len);
> -        if (ret < 0) {
> -            if (ret == GNUTLS_E_INTERRUPTED)
> -                goto tls_resend;
> -            if (ret == GNUTLS_E_AGAIN)
> -                return 0;
> -
> -            remoteError(VIR_ERR_GNUTLS_ERROR, "%s", gnutls_strerror (ret));
> -            return -1;
> -        }
> -    } else {
> -    resend:
> -        ret = send (priv->sock, bytes, len, 0);
> -        if (ret == -1) {
> -            if (errno == EINTR)
> -                goto resend;
> -            if (errno == EWOULDBLOCK)
> -                return 0;
> -
> -            virReportSystemError(errno, "%s", _("cannot send data"));
> -            return -1;
> -
> -        }
> -    }
> -
> -    return ret;
> -}
> -
> -
> -static int
> -remoteIOReadBuffer(struct private_data *priv,
> -                   char *bytes, int len)
> -{
> -    int ret;
> -
> -    if (priv->uses_tls) {
> -    tls_resend:
> -        ret = gnutls_record_recv (priv->session, bytes, len);
> -        if (ret == GNUTLS_E_INTERRUPTED)
> -            goto tls_resend;
> -        if (ret == GNUTLS_E_AGAIN)
> -            return 0;
> -
> -        /* Treat 0 == EOF as an error */
> -        if (ret <= 0) {
> -            if (ret < 0)
> -                remoteError(VIR_ERR_GNUTLS_ERROR,
> -                            _("failed to read from TLS socket %s"),
> -                            gnutls_strerror (ret));
> -            else
> -                remoteError(VIR_ERR_SYSTEM_ERROR, "%s",
> -                            _("server closed connection"));
> -            return -1;
> -        }
> -    } else {
> -    resend:
> -        ret = recv (priv->sock, bytes, len, 0);
> -        if (ret <= 0) {
> -            if (ret == -1) {
> -                if (errno == EINTR)
> -                    goto resend;
> -                if (errno == EWOULDBLOCK)
> -                    return 0;
> -
> -                char errout[1024] = "\0";
> -                if (priv->errfd != -1) {
> -                    if (saferead(priv->errfd, errout, sizeof(errout)) < 0) {
> -                        virReportSystemError(errno, "%s",
> -                                             _("cannot recv data"));
> -                        return -1;
> -                    }
> -                }
> -
> -                virReportSystemError(errno,
> -                                     _("cannot recv data: %s"), errout);
> -
> -            } else {
> -                char errout[1024] = "\0";
> -                if (priv->errfd != -1) {
> -                    if (saferead(priv->errfd, errout, sizeof(errout)) < 0) {
> -                        remoteError(VIR_ERR_SYSTEM_ERROR,
> -                                    _("server closed connection: %s"),
> -                                    virStrerror(errno, errout, sizeof errout));
> -                        return -1;
> -                    }
> -                }
> -
> -                remoteError(VIR_ERR_SYSTEM_ERROR,
> -                            _("server closed connection: %s"), errout);
> -            }
> -            return -1;
> -        }
> -    }
> -
> -    return ret;
> -}
> -
> -
> -static int
> -remoteIOWriteMessage(struct private_data *priv,
> -                     struct remote_thread_call *thecall)
> -{
> -#if HAVE_SASL
> -    if (priv->saslconn) {
> -        const char *output;
> -        unsigned int outputlen;
> -        int err, ret;
> -
> -        if (!priv->saslEncoded) {
> -            err = sasl_encode(priv->saslconn,
> -                              thecall->buffer + thecall->bufferOffset,
> -                              thecall->bufferLength - thecall->bufferOffset,
> -                              &output, &outputlen);
> -            if (err != SASL_OK) {
> -                remoteError(VIR_ERR_INTERNAL_ERROR,
> -                            _("failed to encode SASL data: %s"),
> -                            sasl_errstring(err, NULL, NULL));
> -                return -1;
> -            }
> -            priv->saslEncoded = output;
> -            priv->saslEncodedLength = outputlen;
> -            priv->saslEncodedOffset = 0;
> -
> -            thecall->bufferOffset = thecall->bufferLength;
> -        }
> -
> -        ret = remoteIOWriteBuffer(priv,
> -                                  priv->saslEncoded + priv->saslEncodedOffset,
> -                                  priv->saslEncodedLength - priv->saslEncodedOffset);
> -        if (ret < 0)
> -            return ret;
> -        priv->saslEncodedOffset += ret;
> -
> -        if (priv->saslEncodedOffset == priv->saslEncodedLength) {
> -            priv->saslEncoded = NULL;
> -            priv->saslEncodedOffset = priv->saslEncodedLength = 0;
> -            if (thecall->want_reply)
> -                thecall->mode = REMOTE_MODE_WAIT_RX;
> -            else
> -                thecall->mode = REMOTE_MODE_COMPLETE;
> -        }
> -    } else {
> -#endif
> -        int ret;
> -        ret = remoteIOWriteBuffer(priv,
> -                                  thecall->buffer + thecall->bufferOffset,
> -                                  thecall->bufferLength - thecall->bufferOffset);
> -        if (ret < 0)
> -            return ret;
> -        thecall->bufferOffset += ret;
> -
> -        if (thecall->bufferOffset == thecall->bufferLength) {
> -            thecall->bufferOffset = thecall->bufferLength = 0;
> -            if (thecall->want_reply)
> -                thecall->mode = REMOTE_MODE_WAIT_RX;
> -            else
> -                thecall->mode = REMOTE_MODE_COMPLETE;
> -        }
> -#if HAVE_SASL
> -    }
> -#endif
> -    return 0;
> -}
> -
> -
> -static int
> -remoteIOHandleOutput(struct private_data *priv) {
> -    struct remote_thread_call *thecall = priv->waitDispatch;
> -
> -    while (thecall &&
> -           thecall->mode != REMOTE_MODE_WAIT_TX)
> -        thecall = thecall->next;
> -
> -    if (!thecall)
> -        return -1; /* Shouldn't happen, but you never know... */
> -
> -    while (thecall) {
> -        int ret = remoteIOWriteMessage(priv, thecall);
> -        if (ret < 0)
> -            return ret;
> -
> -        if (thecall->mode == REMOTE_MODE_WAIT_TX)
> -            return 0; /* Blocking write, to back to event loop */
> -
> -        thecall = thecall->next;
> -    }
> -
> -    return 0; /* No more calls to send, all done */
> -}
> -
> -static int
> -remoteIOReadMessage(struct private_data *priv) {
> -    unsigned int wantData;
> -
> -    /* Start by reading length word */
> -    if (priv->bufferLength == 0)
> -        priv->bufferLength = 4;
> -
> -    wantData = priv->bufferLength - priv->bufferOffset;
> -
> -#if HAVE_SASL
> -    if (priv->saslconn) {
> -        if (priv->saslDecoded == NULL) {
> -            int ret, err;
> -            ret = remoteIOReadBuffer(priv, priv->saslTemporary,
> -                                     sizeof(priv->saslTemporary));
> -            if (ret < 0)
> -                return -1;
> -            if (ret == 0)
> -                return 0;
> -
> -            err = sasl_decode(priv->saslconn, priv->saslTemporary, ret,
> -                              &priv->saslDecoded, &priv->saslDecodedLength);
> -            if (err != SASL_OK) {
> -                remoteError(VIR_ERR_INTERNAL_ERROR,
> -                            _("failed to decode SASL data: %s"),
> -                            sasl_errstring(err, NULL, NULL));
> -                return -1;
> -            }
> -            priv->saslDecodedOffset = 0;
> -        }
> -
> -        if ((priv->saslDecodedLength - priv->saslDecodedOffset) < wantData)
> -            wantData = (priv->saslDecodedLength - priv->saslDecodedOffset);
> -
> -        memcpy(priv->buffer + priv->bufferOffset,
> -               priv->saslDecoded + priv->saslDecodedOffset,
> -               wantData);
> -        priv->saslDecodedOffset += wantData;
> -        priv->bufferOffset += wantData;
> -        if (priv->saslDecodedOffset == priv->saslDecodedLength) {
> -            priv->saslDecodedOffset = priv->saslDecodedLength = 0;
> -            priv->saslDecoded = NULL;
> -        }
> -
> -        return wantData;
> -    } else {
> -#endif
> -        int ret;
> -
> -        ret = remoteIOReadBuffer(priv,
> -                                 priv->buffer + priv->bufferOffset,
> -                                 wantData);
> -        if (ret < 0)
> -            return -1;
> -        if (ret == 0)
> -            return 0;
> -
> -        priv->bufferOffset += ret;
> -
> -        return ret;
> -#if HAVE_SASL
> -    }
> -#endif
> -}
> -
> -
> -static int
> -remoteIODecodeMessageLength(struct private_data *priv) {
> -    XDR xdr;
> -    unsigned int len;
> -
> -    xdrmem_create (&xdr, priv->buffer, priv->bufferLength, XDR_DECODE);
> -    if (!xdr_u_int (&xdr, &len)) {
> -        remoteError(VIR_ERR_RPC, "%s", _("xdr_u_int (length word, reply)"));
> -        return -1;
> -    }
> -    xdr_destroy (&xdr);
> -
> -    if (len < REMOTE_MESSAGE_HEADER_XDR_LEN) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("packet received from server too small"));
> -        return -1;
> -    }
> -
> -    /* Length includes length word - adjust to real length to read. */
> -    len -= REMOTE_MESSAGE_HEADER_XDR_LEN;
> -
> -    if (len > REMOTE_MESSAGE_MAX) {
> -        remoteError(VIR_ERR_RPC, "%s",
> -                    _("packet received from server too large"));
> -        return -1;
> -    }
> -
> -    /* Extend our declared buffer length and carry
> -       on reading the header + payload */
> -    priv->bufferLength += len;
> -    VIR_DEBUG("Got length, now need %d total (%d more)", priv->bufferLength, len);
> -    return 0;
> -}
> -
> -
> -static int
> -processCallDispatchReply(virConnectPtr conn, struct private_data *priv,
> -                         remote_message_header *hdr,
> -                         XDR *xdr);
> -
> -static int
> -processCallDispatchMessage(virConnectPtr conn, struct private_data *priv,
> -                           int in_open,
> -                           remote_message_header *hdr,
> -                           XDR *xdr);
> -
> -static int
> -processCallDispatchStream(virConnectPtr conn, struct private_data *priv,
> -                          remote_message_header *hdr,
> -                          XDR *xdr);
> -
> -
> -static int
> -processCallDispatch(virConnectPtr conn, struct private_data *priv,
> -                    int flags) {
> -    XDR xdr;
> -    struct remote_message_header hdr;
> -    int len = priv->bufferLength - 4;
> -    int rv = -1;
> -    int expectedprog;
> -    int expectedvers;
> -
> -    /* Length word has already been read */
> -    priv->bufferOffset = 4;
> -
> -    /* Deserialise reply header. */
> -    xdrmem_create (&xdr, priv->buffer + priv->bufferOffset, len, XDR_DECODE);
> -    if (!xdr_remote_message_header (&xdr, &hdr)) {
> -        remoteError(VIR_ERR_RPC, "%s", _("invalid header in reply"));
> -        return -1;
> -    }
> -
> -    priv->bufferOffset += xdr_getpos(&xdr);
> -
> -    expectedprog = REMOTE_PROGRAM;
> -    expectedvers = REMOTE_PROTOCOL_VERSION;
> -    if (flags & REMOTE_CALL_QEMU) {
> -        expectedprog = QEMU_PROGRAM;
> -        expectedvers = QEMU_PROTOCOL_VERSION;
> -    }
> -
> -    /* Check program, version, etc. are what we expect. */
> -    if (hdr.prog != expectedprog) {
> -        remoteError(VIR_ERR_RPC,
> -                    _("unknown program (received %x, expected %x)"),
> -                    hdr.prog, expectedprog);
> -        return -1;
> -    }
> -    if (hdr.vers != expectedvers) {
> -        remoteError(VIR_ERR_RPC,
> -                    _("unknown protocol version (received %x, expected %x)"),
> -                    hdr.vers, expectedvers);
> -        return -1;
> -    }
> -
> -
> -    switch (hdr.type) {
> -    case REMOTE_REPLY: /* Normal RPC replies */
> -        rv = processCallDispatchReply(conn, priv, &hdr, &xdr);
> -        break;
> -
> -    case REMOTE_MESSAGE: /* Async notifications */
> -        VIR_DEBUG("Dispatch event %d %d", hdr.proc, priv->bufferLength);
> -        rv = processCallDispatchMessage(conn, priv, flags & REMOTE_CALL_IN_OPEN,
> -                                        &hdr, &xdr);
> -        break;
> -
> -    case REMOTE_STREAM: /* Stream protocol */
> -        rv = processCallDispatchStream(conn, priv, &hdr, &xdr);
> -        break;
> -
> -    default:
> -        remoteError(VIR_ERR_RPC,
> -                    _("got unexpected RPC call %d from server"),
> -                    hdr.proc);
> -        rv = -1;
> -        break;
> -    }
> -
> -    xdr_destroy(&xdr);
> -    return rv;
> -}
> -
> -
> -static int
> -processCallDispatchReply(virConnectPtr conn ATTRIBUTE_UNUSED,
> -                         struct private_data *priv,
> -                         remote_message_header *hdr,
> -                         XDR *xdr) {
> -    struct remote_thread_call *thecall;
> -
> -    /* Ok, definitely got an RPC reply now find
> -       out who's been waiting for it */
> -    thecall = priv->waitDispatch;
> -    while (thecall &&
> -           thecall->serial != hdr->serial)
> -        thecall = thecall->next;
> -
> -    if (!thecall) {
> -        remoteError(VIR_ERR_RPC,
> -                    _("no call waiting for reply with serial %d"),
> -                    hdr->serial);
> -        return -1;
> -    }
> -
> -    if (hdr->proc != thecall->proc_nr) {
> -        remoteError(VIR_ERR_RPC,
> -                    _("unknown procedure (received %x, expected %x)"),
> -                    hdr->proc, thecall->proc_nr);
> -        return -1;
> -    }
> -
> -    /* Status is either REMOTE_OK (meaning that what follows is a ret
> -     * structure), or REMOTE_ERROR (and what follows is a remote_error
> -     * structure).
> -     */
> -    switch (hdr->status) {
> -    case REMOTE_OK:
> -        if (!(*thecall->ret_filter) (xdr, thecall->ret)) {
> -            remoteError(VIR_ERR_RPC,
> -                        _("Unable to marshal reply for program %d version %d procedure %d type %d status %d"),
> -                        hdr->prog, hdr->vers, hdr->proc, hdr->type, hdr->status);
> -            return -1;
> -        }
> -        thecall->mode = REMOTE_MODE_COMPLETE;
> -        return 0;
> -
> -    case REMOTE_ERROR:
> -        memset (&thecall->err, 0, sizeof thecall->err);
> -        if (!xdr_remote_error (xdr, &thecall->err)) {
> -            remoteError(VIR_ERR_RPC,
> -                        _("Unable to marshal error for program %d version %d procedure %d type %d status %d"),
> -                        hdr->prog, hdr->vers, hdr->proc, hdr->type, hdr->status);
> -            return -1;
> -        }
> -        thecall->mode = REMOTE_MODE_ERROR;
> -        return 0;
> -
> -    default:
> -        remoteError(VIR_ERR_RPC, _("unknown status (received %x)"), hdr->status);
> -        return -1;
> -    }
> -}
> -
> -static int
> -processCallDispatchMessage(virConnectPtr conn, struct private_data *priv,
> -                           int in_open,
> -                           remote_message_header *hdr,
> -                           XDR *xdr) {
> -    virDomainEventPtr event = NULL;
> -    /* An async message has come in while we were waiting for the
> -     * response. Process it to pull it off the wire, and try again
> -     */
> -
> -    if (in_open) {
> -        VIR_DEBUG("Ignoring bogus event %d received while in open", hdr->proc);
> -        return -1;
> -    }
> -
> -    switch (hdr->proc) {
> -    case REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE:
> -        event = remoteDomainReadEventLifecycle(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_REBOOT:
> -        event = remoteDomainReadEventReboot(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE:
> -        event = remoteDomainReadEventRTCChange(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_WATCHDOG:
> -        event = remoteDomainReadEventWatchdog(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_IO_ERROR:
> -        event = remoteDomainReadEventIOError(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON:
> -        event = remoteDomainReadEventIOErrorReason(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_GRAPHICS:
> -        event = remoteDomainReadEventGraphics(conn, xdr);
> -        break;
> -
> -    case REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR:
> -        event = remoteDomainReadEventControlError(conn, xdr);
> -        break;
> -
> -    default:
> -        VIR_DEBUG("Unexpected event proc %d", hdr->proc);
> -        break;
> -    }
> -    VIR_DEBUG("Event ready for queue %p %p", event, conn);
> -
> -    if (!event)
> -        return -1;
> -
> -    remoteDomainEventQueue(priv, event);
> -    return 0;
> -}
> -
> -static int
> -processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED,
> -                          struct private_data *priv,
> -                          remote_message_header *hdr,
> -                          XDR *xdr) {
> -    struct private_stream_data *privst;
> -    struct remote_thread_call *thecall;
> -
> -    /* Try and find a matching stream */
> -    privst = priv->streams;
> -    while (privst &&
> -           privst->serial != hdr->serial &&
> -           privst->proc_nr != hdr->proc)
> -        privst = privst->next;
> -
> -    if (!privst) {
> -        VIR_DEBUG("No registered stream matching serial=%d, proc=%d",
> -                  hdr->serial, hdr->proc);
> -        return -1;
> -    }
> -
> -    /* See if there's also a (optional) call waiting for this reply */
> -    thecall = priv->waitDispatch;
> -    while (thecall &&
> -           thecall->serial != hdr->serial)
> -        thecall = thecall->next;
> -
> -
> -    /* Status is either REMOTE_OK (meaning that what follows is a ret
> -     * structure), or REMOTE_ERROR (and what follows is a remote_error
> -     * structure).
> -     */
> -    switch (hdr->status) {
> -    case REMOTE_CONTINUE: {
> -        int avail = privst->incomingLength - privst->incomingOffset;
> -        int need = priv->bufferLength - priv->bufferOffset;
> -        VIR_DEBUG("Got a stream data packet");
> -
> -        /* XXX flag stream as complete somwhere if need==0 */
> -
> -        if (need > avail) {
> -            int extra = need - avail;
> -            if (VIR_REALLOC_N(privst->incoming,
> -                              privst->incomingLength + extra) < 0) {
> -                VIR_DEBUG("Out of memory handling stream data");
> -                return -1;
> -            }
> -            privst->incomingLength += extra;
> -        }
> -
> -        memcpy(privst->incoming + privst->incomingOffset,
> -               priv->buffer + priv->bufferOffset,
> -               priv->bufferLength - priv->bufferOffset);
> -        privst->incomingOffset += (priv->bufferLength - priv->bufferOffset);
> -
> -        if (thecall && thecall->want_reply) {
> -            VIR_DEBUG("Got sync data packet offset=%d", privst->incomingOffset);
> -            thecall->mode = REMOTE_MODE_COMPLETE;
> -        } else {
> -            VIR_DEBUG("Got aysnc data packet offset=%d", privst->incomingOffset);
> -            remoteStreamEventTimerUpdate(privst);
> -        }
> -        return 0;
> -    }
> -
> -    case REMOTE_OK:
> -        VIR_DEBUG("Got a synchronous confirm");
> -        if (!thecall) {
> -            VIR_DEBUG("Got unexpected stream finish confirmation");
> -            return -1;
> -        }
> -        thecall->mode = REMOTE_MODE_COMPLETE;
> -        return 0;
> -
> -    case REMOTE_ERROR:
> -        if (thecall && thecall->want_reply) {
> -            VIR_DEBUG("Got a synchronous error");
> -            /* Give the error straight to this call */
> -            memset (&thecall->err, 0, sizeof thecall->err);
> -            if (!xdr_remote_error (xdr, &thecall->err)) {
> -                remoteError(VIR_ERR_RPC, "%s", _("unmarshaling remote_error"));
> -                return -1;
> -            }
> -            thecall->mode = REMOTE_MODE_ERROR;
> -        } else {
> -            VIR_DEBUG("Got a asynchronous error");
> -            /* No call, so queue the error against the stream */
> -            if (privst->has_error) {
> -                VIR_DEBUG("Got unexpected duplicate stream error");
> -                return -1;
> -            }
> -            privst->has_error = 1;
> -            memset (&privst->err, 0, sizeof privst->err);
> -            if (!xdr_remote_error (xdr, &privst->err)) {
> -                VIR_DEBUG("Failed to unmarshal error");
> -                return -1;
> -            }
> -        }
> -        return 0;
> -
> -    default:
> -        VIR_WARN("Stream with unexpected serial=%d, proc=%d, status=%d",
> -                 hdr->serial, hdr->proc, hdr->status);
> -        return -1;
> -    }
> -}
> -
> -static int
> -remoteIOHandleInput(virConnectPtr conn, struct private_data *priv,
> -                    int flags)
> -{
> -    /* Read as much data as is available, until we get
> -     * EAGAIN
> -     */
> -    for (;;) {
> -        int ret = remoteIOReadMessage(priv);
> -
> -        if (ret < 0)
> -            return -1;
> -        if (ret == 0)
> -            return 0;  /* Blocking on read */
> -
> -        /* Check for completion of our goal */
> -        if (priv->bufferOffset == priv->bufferLength) {
> -            if (priv->bufferOffset == 4) {
> -                ret = remoteIODecodeMessageLength(priv);
> -                if (ret < 0)
> -                    return -1;
> -
> -                /*
> -                 * We'll carry on around the loop to immediately
> -                 * process the message body, because it has probably
> -                 * already arrived. Worst case, we'll get EAGAIN on
> -                 * next iteration.
> -                 */
> -            } else {
> -                ret = processCallDispatch(conn, priv, flags);
> -                priv->bufferOffset = priv->bufferLength = 0;
> -                /*
> -                 * We've completed one call, but we don't want to
> -                 * spin around the loop forever if there are many
> -                 * incoming async events, or replies for other
> -                 * thread's RPC calls. We want to get out & let
> -                 * any other thread take over as soon as we've
> -                 * got our reply. When SASL is active though, we
> -                 * may have read more data off the wire than we
> -                 * initially wanted & cached it in memory. In this
> -                 * case, poll() would not detect that there is more
> -                 * ready todo.
> -                 *
> -                 * So if SASL is active *and* some SASL data is
> -                 * already cached, then we'll process that now,
> -                 * before returning.
> -                 */
> -#if HAVE_SASL
> -                if (ret == 0 &&
> -                    priv->saslconn &&
> -                    priv->saslDecoded)
> -                    continue;
> -#endif
> -                return ret;
> -            }
> -        }
> -    }
> -}
> -
> -/*
> - * Process all calls pending dispatch/receive until we
> - * get a reply to our own call. Then quit and pass the buck
> - * to someone else.
> - */
> -static int
> -remoteIOEventLoop(virConnectPtr conn,
> -                  struct private_data *priv,
> -                  int flags,
> -                  struct remote_thread_call *thiscall)
> -{
> -    struct pollfd fds[2];
> -    int ret;
> -
> -    fds[0].fd = priv->sock;
> -    fds[1].fd = priv->wakeupReadFD;
> -
> -    for (;;) {
> -        struct remote_thread_call *tmp = priv->waitDispatch;
> -        struct remote_thread_call *prev;
> -        char ignore;
> -#ifdef HAVE_PTHREAD_SIGMASK
> -        sigset_t oldmask, blockedsigs;
> -#endif
> -        int timeout = -1;
> -
> -        /* If we have existing SASL decoded data we
> -         * don't want to sleep in the poll(), just
> -         * check if any other FDs are also ready
> -         */
> -#if HAVE_SASL
> -        if (priv->saslDecoded)
> -            timeout = 0;
> -#endif
> -
> -        fds[0].events = fds[0].revents = 0;
> -        fds[1].events = fds[1].revents = 0;
> -
> -        fds[1].events = POLLIN;
> -        while (tmp) {
> -            if (tmp->mode == REMOTE_MODE_WAIT_RX)
> -                fds[0].events |= POLLIN;
> -            if (tmp->mode == REMOTE_MODE_WAIT_TX)
> -                fds[0].events |= POLLOUT;
> -
> -            tmp = tmp->next;
> -        }
> -
> -        if (priv->streams)
> -            fds[0].events |= POLLIN;
> -
> -        /* Release lock while poll'ing so other threads
> -         * can stuff themselves on the queue */
> -        remoteDriverUnlock(priv);
> -
> -        /* Block SIGWINCH from interrupting poll in curses programs,
> -         * then restore the original signal mask again immediately
> -         * after the call (RHBZ#567931).  Same for SIGCHLD and SIGPIPE
> -         * at the suggestion of Paolo Bonzini and Daniel Berrange.
> -         */
> -#ifdef HAVE_PTHREAD_SIGMASK
> -        sigemptyset (&blockedsigs);
> -        sigaddset (&blockedsigs, SIGWINCH);
> -        sigaddset (&blockedsigs, SIGCHLD);
> -        sigaddset (&blockedsigs, SIGPIPE);
> -        ignore_value(pthread_sigmask(SIG_BLOCK, &blockedsigs, &oldmask));
> -#endif
> -
> -    repoll:
> -        ret = poll(fds, ARRAY_CARDINALITY(fds), timeout);
> -        if (ret < 0 && errno == EAGAIN)
> -            goto repoll;
> -
> -#ifdef HAVE_PTHREAD_SIGMASK
> -        ignore_value(pthread_sigmask(SIG_SETMASK, &oldmask, NULL));
> -#endif
> -
> -        remoteDriverLock(priv);
> -
> -        /* If we have existing SASL decoded data, pretend
> -         * the socket became readable so we consume it
> -         */
> -#if HAVE_SASL
> -        if (priv->saslDecoded)
> -            fds[0].revents |= POLLIN;
> -#endif
> -
> -        if (fds[1].revents) {
> -            ssize_t s;
> -            VIR_DEBUG("Woken up from poll by other thread");
> -            s = saferead(priv->wakeupReadFD, &ignore, sizeof(ignore));
> -            if (s < 0) {
> -                virReportSystemError(errno, "%s",
> -                                     _("read on wakeup fd failed"));
> -                goto error;
> -            } else if (s != sizeof(ignore)) {
> -                remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                            _("read on wakeup fd failed"));
> -                goto error;
> -            }
> -        }
> -
> -        if (ret < 0) {
> -            if (errno == EWOULDBLOCK)
> -                continue;
> -            virReportSystemError(errno,
> -                                 "%s", _("poll on socket failed"));
> -            goto error;
> -        }
> -
> -        if (fds[0].revents & POLLOUT) {
> -            if (remoteIOHandleOutput(priv) < 0)
> -                goto error;
> -        }
> -
> -        if (fds[0].revents & POLLIN) {
> -            if (remoteIOHandleInput(conn, priv, flags) < 0)
> -                goto error;
> -        }
> -
> -        /* Iterate through waiting threads and if
> -         * any are complete then tell 'em to wakeup
> -         */
> -        tmp = priv->waitDispatch;
> -        prev = NULL;
> -        while (tmp) {
> -            if (tmp != thiscall &&
> -                (tmp->mode == REMOTE_MODE_COMPLETE ||
> -                 tmp->mode == REMOTE_MODE_ERROR)) {
> -                /* Take them out of the list */
> -                if (prev)
> -                    prev->next = tmp->next;
> -                else
> -                    priv->waitDispatch = tmp->next;
> -
> -                /* And wake them up....
> -                 * ...they won't actually wakeup until
> -                 * we release our mutex a short while
> -                 * later...
> -                 */
> -                VIR_DEBUG("Waking up sleep %d %p %p", tmp->proc_nr, tmp, priv->waitDispatch);
> -                virCondSignal(&tmp->cond);
> -            } else {
> -                prev = tmp;
> -            }
> -            tmp = tmp->next;
> -        }
> -
> -        /* Now see if *we* are done */
> -        if (thiscall->mode == REMOTE_MODE_COMPLETE ||
> -            thiscall->mode == REMOTE_MODE_ERROR) {
> -            /* We're at head of the list already, so
> -             * remove us
> -             */
> -            priv->waitDispatch = thiscall->next;
> -            VIR_DEBUG("Giving up the buck %d %p %p", thiscall->proc_nr, thiscall, priv->waitDispatch);
> -            /* See if someone else is still waiting
> -             * and if so, then pass the buck ! */
> -            if (priv->waitDispatch) {
> -                VIR_DEBUG("Passing the buck to %d %p", priv->waitDispatch->proc_nr, priv->waitDispatch);
> -                virCondSignal(&priv->waitDispatch->cond);
> -            }
> -            return 0;
> -        }
> -
> -
> -        if (fds[0].revents & (POLLHUP | POLLERR)) {
> -            remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                        _("received hangup / error event on socket"));
> -            goto error;
> -        }
> -    }
> -
> -
> -error:
> -    priv->waitDispatch = thiscall->next;
> -    VIR_DEBUG("Giving up the buck due to I/O error %d %p %p", thiscall->proc_nr, thiscall, priv->waitDispatch);
> -    /* See if someone else is still waiting
> -     * and if so, then pass the buck ! */
> -    if (priv->waitDispatch) {
> -        VIR_DEBUG("Passing the buck to %d %p", priv->waitDispatch->proc_nr, priv->waitDispatch);
> -        virCondSignal(&priv->waitDispatch->cond);
> -    }
> -    return -1;
> -}
> -
> -/*
> - * This function sends a message to remote server and awaits a reply
> - *
> - * NB. This does not free the args structure (not desirable, since you
> - * often want this allocated on the stack or else it contains strings
> - * which come from the user).  It does however free any intermediate
> - * results, eg. the error structure if there is one.
> - *
> - * NB(2). Make sure to memset (&ret, 0, sizeof ret) before calling,
> - * else Bad Things will happen in the XDR code.
> - *
> - * NB(3) You must have the private_data lock before calling this
> - *
> - * NB(4) This is very complicated. Due to connection cloning, multiple
> - * threads can want to use the socket at once. Obviously only one of
> - * them can. So if someone's using the socket, other threads are put
> - * to sleep on condition variables. The existing thread may completely
> - * send & receive their RPC call/reply while they're asleep. Or it
> - * may only get around to dealing with sending the call. Or it may
> - * get around to neither. So upon waking up from slumber, the other
> - * thread may or may not have more work todo.
> - *
> - * We call this dance  'passing the buck'
> - *
> - *      http://en.wikipedia.org/wiki/Passing_the_buck
> - *
> - *   "Buck passing or passing the buck is the action of transferring
> - *    responsibility or blame unto another person. It is also used as
> - *    a strategy in power politics when the actions of one country/
> - *    nation are blamed on another, providing an opportunity for war."
> - *
> - * NB(5) Don't Panic!
> - */
> -static int
> -remoteIO(virConnectPtr conn,
> -         struct private_data *priv,
> -         int flags,
> -         struct remote_thread_call *thiscall)
> -{
> -    int rv;
> -
> -    VIR_DEBUG("Do proc=%d serial=%d length=%d wait=%p",
> -          thiscall->proc_nr, thiscall->serial,
> -          thiscall->bufferLength, priv->waitDispatch);
> -
> -    /* Check to see if another thread is dispatching */
> -    if (priv->waitDispatch) {
> -        /* Stick ourselves on the end of the wait queue */
> -        struct remote_thread_call *tmp = priv->waitDispatch;
> -        char ignore = 1;
> -        ssize_t s;
> -        while (tmp && tmp->next)
> -            tmp = tmp->next;
> -        if (tmp)
> -            tmp->next = thiscall;
> -        else
> -            priv->waitDispatch = thiscall;
> -
> -        /* Force other thread to wakeup from poll */
> -        s = safewrite(priv->wakeupSendFD, &ignore, sizeof(ignore));
> -        if (s < 0) {
> -            char errout[1024];
> -            remoteError(VIR_ERR_INTERNAL_ERROR,
> -                        _("failed to wake up polling thread: %s"),
> -                        virStrerror(errno, errout, sizeof errout));
> -            return -1;
> -        } else if (s != sizeof(ignore)) {
> -            remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                        _("failed to wake up polling thread"));
> -            return -1;
> -        }
> -
> -        VIR_DEBUG("Going to sleep %d %p %p", thiscall->proc_nr, priv->waitDispatch, thiscall);
> -        /* Go to sleep while other thread is working... */
> -        if (virCondWait(&thiscall->cond, &priv->lock) < 0) {
> -            if (priv->waitDispatch == thiscall) {
> -                priv->waitDispatch = thiscall->next;
> -            } else {
> -                tmp = priv->waitDispatch;
> -                while (tmp && tmp->next &&
> -                       tmp->next != thiscall) {
> -                    tmp = tmp->next;
> -                }
> -                if (tmp && tmp->next == thiscall)
> -                    tmp->next = thiscall->next;
> -            }
> -            remoteError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                        _("failed to wait on condition"));
> -            return -1;
> -        }
> -
> -        VIR_DEBUG("Wokeup from sleep %d %p %p", thiscall->proc_nr, priv->waitDispatch, thiscall);
> -        /* Two reasons we can be woken up
> -         *  1. Other thread has got our reply ready for us
> -         *  2. Other thread is all done, and it is our turn to
> -         *     be the dispatcher to finish waiting for
> -         *     our reply
> -         */
> -        if (thiscall->mode == REMOTE_MODE_COMPLETE ||
> -            thiscall->mode == REMOTE_MODE_ERROR) {
> -            /*
> -             * We avoided catching the buck and our reply is ready !
> -             * We've already had 'thiscall' removed from the list
> -             * so just need to (maybe) handle errors & free it
> -             */
> -            goto cleanup;
> -        }
> -
> -        /* Grr, someone passed the buck onto us ... */
> -
> -    } else {
> -        /* We're first to catch the buck */
> -        priv->waitDispatch = thiscall;
> -    }
> -
> -    VIR_DEBUG("We have the buck %d %p %p", thiscall->proc_nr, priv->waitDispatch, thiscall);
> -    /*
> -     * The buck stops here!
> -     *
> -     * At this point we're about to own the dispatch
> -     * process...
> -     */
> -
> -    /*
> -     * Avoid needless wake-ups of the event loop in the
> -     * case where this call is being made from a different
> -     * thread than the event loop. These wake-ups would
> -     * cause the event loop thread to be blocked on the
> -     * mutex for the duration of the call
> -     */
> -    if (priv->watch >= 0)
> -        virEventUpdateHandle(priv->watch, 0);
> -
> -    rv = remoteIOEventLoop(conn, priv, flags, thiscall);
> -
> -    if (priv->watch >= 0)
> -        virEventUpdateHandle(priv->watch, VIR_EVENT_HANDLE_READABLE);
> -
> -    if (rv < 0)
> -        return -1;
> -
> -cleanup:
> -    VIR_DEBUG("All done with our call %d %p %p", thiscall->proc_nr,
> -          priv->waitDispatch, thiscall);
> -    if (thiscall->mode == REMOTE_MODE_ERROR) {
> -        /* Interop for virErrorNumber glitch in 0.8.0, if server is
> -         * 0.7.1 through 0.7.7; see comments in virterror.h. */
> -        switch (thiscall->err.code) {
> -        case VIR_WAR_NO_NWFILTER:
> -            /* no way to tell old VIR_WAR_NO_SECRET apart from
> -             * VIR_WAR_NO_NWFILTER, but both are very similar
> -             * warnings, so ignore the difference */
> -            break;
> -        case VIR_ERR_INVALID_NWFILTER:
> -        case VIR_ERR_NO_NWFILTER:
> -        case VIR_ERR_BUILD_FIREWALL:
> -            /* server was trying to pass VIR_ERR_INVALID_SECRET,
> -             * VIR_ERR_NO_SECRET, or VIR_ERR_CONFIG_UNSUPPORTED */
> -            if (thiscall->err.domain != VIR_FROM_NWFILTER)
> -                thiscall->err.code += 4;
> -            break;
> -        case VIR_WAR_NO_SECRET:
> -            if (thiscall->err.domain == VIR_FROM_QEMU)
> -                thiscall->err.code = VIR_ERR_OPERATION_TIMEOUT;
> -            break;
> -        case VIR_ERR_INVALID_SECRET:
> -            if (thiscall->err.domain == VIR_FROM_XEN)
> -                thiscall->err.code = VIR_ERR_MIGRATE_PERSIST_FAILED;
> -            break;
> -        default:
> -            /* Nothing to alter. */
> -            break;
> -        }
> -
> -        /* See if caller asked us to keep quiet about missing RPCs
> -         * eg for interop with older servers */
> -        if (flags & REMOTE_CALL_QUIET_MISSING_RPC &&
> -            thiscall->err.domain == VIR_FROM_REMOTE &&
> -            thiscall->err.code == VIR_ERR_RPC &&
> -            thiscall->err.level == VIR_ERR_ERROR &&
> -            thiscall->err.message &&
> -            STRPREFIX(*thiscall->err.message, "unknown procedure")) {
> -            rv = -2;
> -        } else if (thiscall->err.domain == VIR_FROM_REMOTE &&
> -                   thiscall->err.code == VIR_ERR_RPC &&
> -                   thiscall->err.level == VIR_ERR_ERROR &&
> -                   thiscall->err.message &&
> -                   STRPREFIX(*thiscall->err.message, "unknown procedure")) {
> -            /*
> -             * convert missing remote entry points into the unsupported
> -             * feature error
> -             */
> -            virRaiseErrorFull(__FILE__, __FUNCTION__, __LINE__,
> -                              thiscall->err.domain,
> -                              VIR_ERR_NO_SUPPORT,
> -                              thiscall->err.level,
> -                              thiscall->err.str1 ? *thiscall->err.str1 : NULL,
> -                              thiscall->err.str2 ? *thiscall->err.str2 : NULL,
> -                              thiscall->err.str3 ? *thiscall->err.str3 : NULL,
> -                              thiscall->err.int1,
> -                              thiscall->err.int2,
> -                              "%s", *thiscall->err.message);
> -            rv = -1;
> -        } else {
> -            virRaiseErrorFull(__FILE__, __FUNCTION__, __LINE__,
> -                              thiscall->err.domain,
> -                              thiscall->err.code,
> -                              thiscall->err.level,
> -                              thiscall->err.str1 ? *thiscall->err.str1 : NULL,
> -                              thiscall->err.str2 ? *thiscall->err.str2 : NULL,
> -                              thiscall->err.str3 ? *thiscall->err.str3 : NULL,
> -                              thiscall->err.int1,
> -                              thiscall->err.int2,
> -                              "%s", thiscall->err.message ? *thiscall->err.message : "unknown");
> -            rv = -1;
> -        }
> -        xdr_free((xdrproc_t)xdr_remote_error,  (char *)&thiscall->err);
> -    } else {
> -        rv = 0;
> -    }
> -    return rv;
> -}
> -
> -
>  /*
>   * Serial a set of arguments into a method call message,
>   * send that to the server and wait for reply
>   */
>  static int
> -call (virConnectPtr conn, struct private_data *priv,
> +call (virConnectPtr conn ATTRIBUTE_UNUSED,
> +      struct private_data *priv,
>        int flags,
>        int proc_nr,
>        xdrproc_t args_filter, char *args,
>        xdrproc_t ret_filter, char *ret)
>  {
> -    struct remote_thread_call *thiscall;
>      int rv;
> +    virNetClientProgramPtr prog = flags & REMOTE_CALL_QEMU ? priv->qemuProgram : priv->remoteProgram;
> +    int counter = priv->counter++;
> +    priv->localUses++;
>  
> -    thiscall = prepareCall(priv, flags, proc_nr, args_filter, args,
> -                           ret_filter, ret);
> -
> -    if (!thiscall) {
> -        return -1;
> -    }
> +    /* Unlock, so that if we get any async events/stream data
> +     * while processing the RPC, we don't deadlock when our
> +     * callbacks for those are invoked
> +     */
> +    remoteDriverUnlock(priv);
> +    rv = virNetClientProgramCall(prog,
> +                                 priv->client,
> +                                 counter,
> +                                 proc_nr,
> +                                 args_filter, args,
> +                                 ret_filter, ret);
> +    remoteDriverLock(priv);
> +    priv->localUses--;
>  
> -    rv = remoteIO(conn, priv, flags, thiscall);
> -    ignore_value(virCondDestroy(&thiscall->cond));
> -    VIR_FREE(thiscall);
>      return rv;
>  }
>  
>  
> -/** remoteDomainEventFired:
> - *
> - * The callback for monitoring the remote socket
> - * for event data
> - */
> -void
> -remoteDomainEventFired(int watch,
> -                       int fd,
> -                       int event,
> -                       void *opaque)
> -{
> -    virConnectPtr        conn = opaque;
> -    struct private_data *priv = conn->privateData;
> -
> -    remoteDriverLock(priv);
> -
> -    /* This should be impossible, but it doesn't hurt to check */
> -    if (priv->waitDispatch)
> -        goto done;
> -
> -    VIR_DEBUG("Event fired %d %d %d %X", watch, fd, event, event);
> -
> -    if (event & (VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR)) {
> -         VIR_DEBUG("%s : VIR_EVENT_HANDLE_HANGUP or "
> -               "VIR_EVENT_HANDLE_ERROR encountered", __FUNCTION__);
> -         virEventRemoveHandle(watch);
> -         priv->watch = -1;
> -         goto done;
> -    }
> -
> -    if (fd != priv->sock) {
> -        virEventRemoveHandle(watch);
> -        priv->watch = -1;
> -        goto done;
> -    }
> -
> -    if (remoteIOHandleInput(conn, priv, 0) < 0)
> -        VIR_DEBUG("Something went wrong during async message processing");
> -
> -done:
> -    remoteDriverUnlock(priv);
> -}
> -
>  static void remoteDomainEventDispatchFunc(virConnectPtr conn,
>                                            virDomainEventPtr event,
>                                            virConnectDomainEventGenericCallback cb,
> @@ -6266,7 +3960,7 @@ static void remoteDomainEventDispatchFunc(virConnectPtr conn,
>      remoteDriverLock(priv);
>  }
>  
> -void
> +static void
>  remoteDomainEventQueueFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
>  {
>      virConnectPtr conn = opaque;
> @@ -6282,7 +3976,7 @@ remoteDomainEventQueueFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
>      remoteDriverUnlock(priv);
>  }
>  
> -void
> +static void
>  remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event)
>  {
>      virDomainEventStateQueue(priv->domainEventState, event);
> diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl
> index 71085d9..d6264b9 100755
> --- a/src/rpc/gendispatch.pl
> +++ b/src/rpc/gendispatch.pl
> @@ -1326,7 +1326,7 @@ elsif ($opt_k) {
>          }
>  
>          if ($call->{streamflag} ne "none") {
> -            print "    struct private_stream_data *privst = NULL;\n";
> +            print "    virNetClientStreamPtr netst = NULL;\n";
>          }
>  
>          print "\n";
> @@ -1334,11 +1334,16 @@ elsif ($opt_k) {
>  
>          if ($call->{streamflag} ne "none") {
>              print "\n";
> -            print "    if (!(privst = remoteStreamOpen(st, REMOTE_PROC_$call->{UC_NAME}, priv->counter)))\n";
> +            print "    if (!(netst = virNetClientStreamNew(priv->remoteProgram, REMOTE_PROC_$call->{UC_NAME}, priv->counter)))\n";
>              print "       goto done;\n";
>              print "\n";
> +            print "    if (virNetClientAddStream(priv->client, netst) < 0) {";
> +            print "       virNetClientStreamFree(netst);\n";
> +            print "       goto done;\n";
> +            print "    }";
> +            print "\n";
>              print "    st->driver = &remoteStreamDrv;\n";
> -            print "    st->privateData = privst;\n";
> +            print "    st->privateData = netst;\n";
>          }
>  
>          if ($call->{ProcName} eq "SupportsFeature") {
> @@ -1403,7 +1408,8 @@ elsif ($opt_k) {
>          print "             (xdrproc_t)xdr_$call->{ret}, (char *)$call_ret) == -1) {\n";
>  
>          if ($call->{streamflag} ne "none") {
> -            print "        remoteStreamRelease(st);\n";
> +            print "        virNetClientRemoveStream(priv->client, netst);\n";
> +            print "        virNetClientStreamFree(netst);\n";
>          }
>  
>          print "        goto done;\n";

-- 
Eric Blake   eblake redhat com    +1-801-349-2682
Libvirt virtualization library http://libvirt.org

Attachment: signature.asc
Description: OpenPGP digital signature


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]