libvirtd.c 93.3 KB
Newer Older
D
Daniel P. Berrange 已提交
1
/*
D
Daniel P. Berrange 已提交
2
 * libvirtd.c: daemon start of day, guest process & i/o management
D
Daniel P. Berrange 已提交
3
 *
4
 * Copyright (C) 2006-2010 Red Hat, Inc.
D
Daniel P. Berrange 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

24
#include <config.h>
25

D
Daniel P. Berrange 已提交
26 27 28 29 30 31 32 33 34 35
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/poll.h>
#include <netinet/in.h>
36
#include <netinet/tcp.h>
D
Daniel P. Berrange 已提交
37 38 39 40
#include <netdb.h>
#include <stdlib.h>
#include <pwd.h>
#include <stdio.h>
41 42
#include <stdarg.h>
#include <syslog.h>
D
Daniel P. Berrange 已提交
43 44 45
#include <string.h>
#include <errno.h>
#include <getopt.h>
46
#include <fnmatch.h>
47
#include <grp.h>
48
#include <signal.h>
J
Jim Meyering 已提交
49
#include <netdb.h>
50

51
#include "libvirt_internal.h"
52
#include "virterror_internal.h"
53

54 55
#define VIR_FROM_THIS VIR_FROM_QEMU

D
Daniel P. Berrange 已提交
56
#include "libvirtd.h"
57 58
#include "dispatch.h"

59
#include "util.h"
60
#include "remote_driver.h"
61
#include "conf.h"
D
Daniel P. Berrange 已提交
62
#include "event.h"
63
#include "memory.h"
64
#include "stream.h"
65
#include "hooks.h"
66
#ifdef HAVE_AVAHI
67
# include "mdns.h"
68
#endif
D
Daniel P. Berrange 已提交
69

70
#ifdef WITH_DRIVER_MODULES
71
# include "driver.h"
72
#else
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
# ifdef WITH_QEMU
#  include "qemu/qemu_driver.h"
# endif
# ifdef WITH_LXC
#  include "lxc/lxc_driver.h"
# endif
# ifdef WITH_UML
#  include "uml/uml_driver.h"
# endif
# ifdef WITH_ONE
#  include "opennebula/one_driver.h"
# endif
# ifdef WITH_NETWORK
#  include "network/bridge_driver.h"
# endif
# ifdef WITH_NETCF
#  include "interface/netcf_driver.h"
# endif
# ifdef WITH_STORAGE_DIR
#  include "storage/storage_driver.h"
# endif
# ifdef WITH_NODE_DEVICES
#  include "node_device/node_device_driver.h"
# endif
# ifdef WITH_SECRETS
#  include "secret/secret_driver.h"
# endif
100 101 102
# ifdef WITH_NWFILTER
#  include "nwfilter/nwfilter_driver.h"
# endif
103
#endif
104 105


J
John Levon 已提交
106
#ifdef __sun
107 108
# include <ucred.h>
# include <priv.h>
J
John Levon 已提交
109

110 111 112
# ifndef PRIV_VIRT_MANAGE
#  define PRIV_VIRT_MANAGE ((const char *)"virt_manage")
# endif
J
John Levon 已提交
113

114 115 116
# ifndef PRIV_XVM_CONTROL
#  define PRIV_XVM_CONTROL ((const char *)"xvm_control")
# endif
J
John Levon 已提交
117

118 119
# define PU_RESETGROUPS          0x0001  /* Remove supplemental groups */
# define PU_CLEARLIMITSET        0x0008  /* L=0 */
J
John Levon 已提交
120 121 122

extern int __init_daemon_priv(int, uid_t, gid_t, ...);

123
# define SYSTEM_UID 60
J
John Levon 已提交
124 125 126 127 128 129 130 131 132 133 134 135 136

static gid_t unix_sock_gid = 60; /* Not used */
static int unix_sock_rw_mask = 0666;
static int unix_sock_ro_mask = 0666;

#else

static gid_t unix_sock_gid = 0; /* Only root by default */
static int unix_sock_rw_mask = 0700; /* Allow user only */
static int unix_sock_ro_mask = 0777; /* Allow world */

#endif /* __sun */

137 138
static int godaemon = 0;        /* -d: Be a daemon */
static int verbose = 0;         /* -v: Verbose mode */
139
static int timeout = -1;        /* -t: Shutdown timeout */
140
static int sigwrite = -1;       /* Signal handler pipe */
141
static int ipsock = 0;          /* -l  Listen for TCP/IP */
142

143
/* Defaults for configuration file elements */
144 145
static int listen_tls = 1;
static int listen_tcp = 0;
146
static char *listen_addr  = (char *) LIBVIRTD_LISTEN_ADDR;
147 148
static char *tls_port = (char *) LIBVIRTD_TLS_PORT;
static char *tcp_port = (char *) LIBVIRTD_TCP_PORT;
149

150 151
static char *unix_sock_dir = NULL;

152 153 154 155
#if HAVE_POLKIT
static int auth_unix_rw = REMOTE_AUTH_POLKIT;
static int auth_unix_ro = REMOTE_AUTH_POLKIT;
#else
156 157
static int auth_unix_rw = REMOTE_AUTH_NONE;
static int auth_unix_ro = REMOTE_AUTH_NONE;
158
#endif /* HAVE_POLKIT */
159 160 161 162 163 164 165
#if HAVE_SASL
static int auth_tcp = REMOTE_AUTH_SASL;
#else
static int auth_tcp = REMOTE_AUTH_NONE;
#endif
static int auth_tls = REMOTE_AUTH_NONE;

166
static int mdns_adv = 1;
167
static char *mdns_name = NULL;
168

169
static int tls_no_verify_certificate = 0;
170
static char **tls_allowed_dn_list = NULL;
171

172 173 174 175
static char *key_file = (char *) LIBVIRT_SERVERKEY;
static char *cert_file = (char *) LIBVIRT_SERVERCERT;
static char *ca_file = (char *) LIBVIRT_CACERT;
static char *crl_file = (char *) "";
176 177 178 179

static gnutls_certificate_credentials_t x509_cred;
static gnutls_dh_params_t dh_params;

180 181 182 183
static int min_workers = 5;
static int max_workers = 20;
static int max_clients = 20;

184 185 186 187 188
/* Total number of 'in-process' RPC calls allowed across all clients */
static int max_requests = 20;
/* Total number of 'in-process' RPC calls allowed by a single client*/
static int max_client_requests = 5;

189
#define DH_BITS 1024
190

191 192
static sig_atomic_t sig_errors = 0;
static int sig_lasterrno = 0;
193
static const char *argv0;
194

195 196 197 198 199 200 201 202 203
enum {
    VIR_DAEMON_ERR_NONE = 0,
    VIR_DAEMON_ERR_PIDFILE,
    VIR_DAEMON_ERR_RUNDIR,
    VIR_DAEMON_ERR_INIT,
    VIR_DAEMON_ERR_SIGNAL,
    VIR_DAEMON_ERR_PRIVS,
    VIR_DAEMON_ERR_NETWORK,
    VIR_DAEMON_ERR_CONFIG,
204
    VIR_DAEMON_ERR_HOOKS,
205 206 207 208 209 210 211 212 213 214 215 216 217

    VIR_DAEMON_ERR_LAST
};

VIR_ENUM_DECL(virDaemonErr)
VIR_ENUM_IMPL(virDaemonErr, VIR_DAEMON_ERR_LAST,
              "Initialization successful",
              "Unable to obtain pidfile",
              "Unable to create rundir",
              "Unable to initialize libvirt",
              "Unable to setup signal handlers",
              "Unable to drop privileges",
              "Unable to initialize network sockets",
218 219
              "Unable to load configuration file",
              "Unable to look for hook scripts")
220

221 222
static void sig_handler(int sig, siginfo_t * siginfo,
                        void* context ATTRIBUTE_UNUSED) {
223
    int origerrno;
224
    int r;
225

226 227
    /* set the sig num in the struct */
    siginfo->si_signo = sig;
228 229

    origerrno = errno;
230
    r = safewrite(sigwrite, siginfo, sizeof(*siginfo));
231 232 233 234
    if (r == -1) {
        sig_errors++;
        sig_lasterrno = errno;
    }
235
    errno = origerrno;
D
Daniel P. Berrange 已提交
236
}
237

238 239
static void qemudDispatchClientEvent(int watch, int fd, int events, void *opaque);
static void qemudDispatchServerEvent(int watch, int fd, int events, void *opaque);
240
static int qemudStartWorker(struct qemud_server *server, struct qemud_worker *worker);
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256

void
qemudClientMessageQueuePush(struct qemud_client_message **queue,
                            struct qemud_client_message *msg)
{
    struct qemud_client_message *tmp = *queue;

    if (tmp) {
        while (tmp->next)
            tmp = tmp->next;
        tmp->next = msg;
    } else {
        *queue = msg;
    }
}

257
struct qemud_client_message *
258 259 260 261 262 263 264 265 266 267 268
qemudClientMessageQueueServe(struct qemud_client_message **queue)
{
    struct qemud_client_message *tmp = *queue;

    if (tmp) {
        *queue = tmp->next;
        tmp->next = NULL;
    }

    return tmp;
}
D
Daniel P. Berrange 已提交
269

270 271 272 273 274
static int
remoteCheckCertFile(const char *type, const char *file)
{
    struct stat sb;
    if (stat(file, &sb) < 0) {
275 276 277
        char ebuf[1024];
        VIR_ERROR(_("Cannot access %s '%s': %s"),
                  type, file, virStrerror(errno, ebuf, sizeof ebuf));
278 279 280 281 282
        return -1;
    }
    return 0;
}

283 284 285 286 287 288 289 290 291 292
static int
remoteInitializeGnuTLS (void)
{
    int err;

    /* Initialise GnuTLS. */
    gnutls_global_init ();

    err = gnutls_certificate_allocate_credentials (&x509_cred);
    if (err) {
293
        VIR_ERROR(_("gnutls_certificate_allocate_credentials: %s"),
294 295 296 297 298
                  gnutls_strerror (err));
        return -1;
    }

    if (ca_file && ca_file[0] != '\0') {
299 300 301
        if (remoteCheckCertFile("CA certificate", ca_file) < 0)
            return -1;

302 303 304 305
        qemudDebug ("loading CA cert from %s", ca_file);
        err = gnutls_certificate_set_x509_trust_file (x509_cred, ca_file,
                                                      GNUTLS_X509_FMT_PEM);
        if (err < 0) {
306
            VIR_ERROR(_("gnutls_certificate_set_x509_trust_file: %s"),
307 308 309 310 311 312
                      gnutls_strerror (err));
            return -1;
        }
    }

    if (crl_file && crl_file[0] != '\0') {
J
Jim Meyering 已提交
313
        if (remoteCheckCertFile("CA revocation list", crl_file) < 0)
314 315
            return -1;

316
        DEBUG("loading CRL from %s", crl_file);
317 318 319
        err = gnutls_certificate_set_x509_crl_file (x509_cred, crl_file,
                                                    GNUTLS_X509_FMT_PEM);
        if (err < 0) {
320
            VIR_ERROR(_("gnutls_certificate_set_x509_crl_file: %s"),
321 322 323 324 325 326
                      gnutls_strerror (err));
            return -1;
        }
    }

    if (cert_file && cert_file[0] != '\0' && key_file && key_file[0] != '\0') {
327 328 329 330
        if (remoteCheckCertFile("server certificate", cert_file) < 0)
            return -1;
        if (remoteCheckCertFile("server key", key_file) < 0)
            return -1;
331
        DEBUG("loading cert and key from %s and %s", cert_file, key_file);
332 333 334 335 336
        err =
            gnutls_certificate_set_x509_key_file (x509_cred,
                                                  cert_file, key_file,
                                                  GNUTLS_X509_FMT_PEM);
        if (err < 0) {
337
            VIR_ERROR(_("gnutls_certificate_set_x509_key_file: %s"),
338 339 340 341 342 343 344 345 346 347 348 349
                      gnutls_strerror (err));
            return -1;
        }
    }

    /* Generate Diffie Hellman parameters - for use with DHE
     * kx algorithms. These should be discarded and regenerated
     * once a day, once a week or once a month. Depending on the
     * security requirements.
     */
    err = gnutls_dh_params_init (&dh_params);
    if (err < 0) {
350
        VIR_ERROR(_("gnutls_dh_params_init: %s"), gnutls_strerror (err));
351 352 353 354
        return -1;
    }
    err = gnutls_dh_params_generate2 (dh_params, DH_BITS);
    if (err < 0) {
355
        VIR_ERROR(_("gnutls_dh_params_generate2: %s"), gnutls_strerror (err));
356 357 358 359 360 361 362 363
        return -1;
    }

    gnutls_certificate_set_dh_params (x509_cred, dh_params);

    return 0;
}

364
static void
365 366
qemudDispatchSignalEvent(int watch ATTRIBUTE_UNUSED,
                         int fd ATTRIBUTE_UNUSED,
367 368
                         int events ATTRIBUTE_UNUSED,
                         void *opaque) {
D
Daniel P. Berrange 已提交
369
    struct qemud_server *server = (struct qemud_server *)opaque;
370
    siginfo_t siginfo;
371

372
    virMutexLock(&server->lock);
373

374
    if (saferead(server->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) {
375 376 377
        char ebuf[1024];
        VIR_ERROR(_("Failed to read from signal pipe: %s"),
                  virStrerror(errno, ebuf, sizeof ebuf));
378
        virMutexUnlock(&server->lock);
D
Daniel P. Berrange 已提交
379
        return;
380 381
    }

382
    switch (siginfo.si_signo) {
383
    case SIGHUP:
384
        VIR_INFO0(_("Reloading configuration on SIGHUP"));
385 386
        virHookCall(VIR_HOOK_DRIVER_DAEMON, "-",
                    VIR_HOOK_DAEMON_OP_RELOAD, SIGHUP, "SIGHUP", NULL);
387
        if (virStateReload() < 0)
388
            VIR_WARN0("Error while reloading drivers");
389

390 391 392
        break;

    case SIGINT:
393
    case SIGQUIT:
394
    case SIGTERM:
395
        VIR_WARN("Shutting down on signal %d", siginfo.si_signo);
396
        server->quitEventThread = 1;
397 398 399
        break;

    default:
400
        VIR_INFO(_("Received unexpected signal %d"), siginfo.si_signo);
401 402 403
        break;
    }

404
    virMutexUnlock(&server->lock);
405 406
}

407

408 409 410 411 412
static int daemonForkIntoBackground(void) {
    int statuspipe[2];
    if (pipe(statuspipe) < 0)
        return -1;

D
Daniel P. Berrange 已提交
413 414 415 416 417 418
    int pid = fork();
    switch (pid) {
    case 0:
        {
            int stdinfd = -1;
            int stdoutfd = -1;
419
            int nextpid;
D
Daniel P. Berrange 已提交
420

421 422
            close(statuspipe[0]);

423
            if ((stdinfd = open("/dev/null", O_RDONLY)) < 0)
D
Daniel P. Berrange 已提交
424
                goto cleanup;
425
            if ((stdoutfd = open("/dev/null", O_WRONLY)) < 0)
D
Daniel P. Berrange 已提交
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
                goto cleanup;
            if (dup2(stdinfd, STDIN_FILENO) != STDIN_FILENO)
                goto cleanup;
            if (dup2(stdoutfd, STDOUT_FILENO) != STDOUT_FILENO)
                goto cleanup;
            if (dup2(stdoutfd, STDERR_FILENO) != STDERR_FILENO)
                goto cleanup;
            if (close(stdinfd) < 0)
                goto cleanup;
            stdinfd = -1;
            if (close(stdoutfd) < 0)
                goto cleanup;
            stdoutfd = -1;

            if (setsid() < 0)
                goto cleanup;

            nextpid = fork();
            switch (nextpid) {
            case 0:
446
                return statuspipe[1];
D
Daniel P. Berrange 已提交
447 448 449
            case -1:
                return -1;
            default:
450
                _exit(0);
D
Daniel P. Berrange 已提交
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
            }

        cleanup:
            if (stdoutfd != -1)
                close(stdoutfd);
            if (stdinfd != -1)
                close(stdinfd);
            return -1;

        }

    case -1:
        return -1;

    default:
        {
467 468 469 470 471 472 473 474
            int got, exitstatus = 0;
            int ret;
            char status;

            close(statuspipe[1]);

            /* We wait to make sure the first child forked successfully */
            if ((got = waitpid(pid, &exitstatus, 0)) < 0 ||
D
Daniel P. Berrange 已提交
475
                got != pid ||
476
                exitstatus != 0) {
D
Daniel P. Berrange 已提交
477 478
                return -1;
            }
479 480 481 482 483 484 485 486

            /* Now block until the second child initializes successfully */
        again:
            ret = read(statuspipe[0], &status, 1);
            if (ret == -1 && errno == EINTR)
                goto again;

            if (ret == 1 && status != 0) {
487
                fprintf(stderr,
488 489
                        _("%s: error: %s. Check /var/log/messages or run without "
                          "--daemon for more info.\n"), argv0,
490
                        virDaemonErrTypeToString(status));
491 492
            }
            _exit(ret == 1 && status == 0 ? 0 : 1);
D
Daniel P. Berrange 已提交
493 494 495 496
        }
    }
}

497 498 499
static int qemudWritePidFile(const char *pidFile) {
    int fd;
    FILE *fh;
500
    char ebuf[1024];
501 502 503 504 505

    if (pidFile[0] == '\0')
        return 0;

    if ((fd = open(pidFile, O_WRONLY|O_CREAT|O_EXCL, 0644)) < 0) {
506
        VIR_ERROR(_("Failed to open pid file '%s' : %s"),
507
                  pidFile, virStrerror(errno, ebuf, sizeof ebuf));
508 509 510 511
        return -1;
    }

    if (!(fh = fdopen(fd, "w"))) {
512
        VIR_ERROR(_("Failed to fdopen pid file '%s' : %s"),
513
                  pidFile, virStrerror(errno, ebuf, sizeof ebuf));
514 515 516 517 518
        close(fd);
        return -1;
    }

    if (fprintf(fh, "%lu\n", (unsigned long)getpid()) < 0) {
519 520
        VIR_ERROR(_("%s: Failed to write to pid file '%s' : %s"),
                  argv0, pidFile, virStrerror(errno, ebuf, sizeof ebuf));
521
        fclose(fh);
522 523 524 525
        return -1;
    }

    if (fclose(fh) == EOF) {
526 527
        VIR_ERROR(_("%s: Failed to close pid file '%s' : %s"),
                  argv0, pidFile, virStrerror(errno, ebuf, sizeof ebuf));
528 529 530 531 532 533
        return -1;
    }

    return 0;
}

D
Daniel P. Berrange 已提交
534
static int qemudListenUnix(struct qemud_server *server,
535
                           const char *path, int readonly, int auth) {
536
    struct qemud_socket *sock;
D
Daniel P. Berrange 已提交
537 538
    struct sockaddr_un addr;
    mode_t oldmask;
539
    gid_t oldgrp;
540
    char ebuf[1024];
D
Daniel P. Berrange 已提交
541

542
    if (VIR_ALLOC(sock) < 0) {
543
        VIR_ERROR0(_("Failed to allocate memory for struct qemud_socket"));
D
Daniel P. Berrange 已提交
544
        return -1;
545
    }
D
Daniel P. Berrange 已提交
546 547

    sock->readonly = readonly;
548
    sock->port = -1;
549
    sock->type = QEMUD_SOCK_TYPE_UNIX;
550
    sock->auth = auth;
D
Daniel P. Berrange 已提交
551

552
    if ((sock->fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
553
        VIR_ERROR(_("Failed to create socket: %s"),
554
                  virStrerror(errno, ebuf, sizeof ebuf));
D
Daniel P. Berrange 已提交
555
        goto cleanup;
556
    }
D
Daniel P. Berrange 已提交
557

558 559
    if (virSetCloseExec(sock->fd) < 0 ||
        virSetNonBlock(sock->fd) < 0)
D
Daniel P. Berrange 已提交
560
        goto cleanup;
D
Daniel P. Berrange 已提交
561 562 563

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
C
Chris Lalancette 已提交
564 565 566 567
    if (virStrcpyStatic(addr.sun_path, path) == NULL) {
        VIR_ERROR(_("Path %s too long for unix socket"), path);
        goto cleanup;
    }
D
Daniel P. Berrange 已提交
568 569 570
    if (addr.sun_path[0] == '@')
        addr.sun_path[0] = '\0';

571
    oldgrp = getgid();
572
    oldmask = umask(readonly ? ~unix_sock_ro_mask : ~unix_sock_rw_mask);
573 574 575 576
    if (server->privileged && setgid(unix_sock_gid)) {
        VIR_ERROR(_("Failed to set group ID to %d"), unix_sock_gid);
        goto cleanup;
    }
577

578
    if (bind(sock->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
579
        VIR_ERROR(_("Failed to bind socket to '%s': %s"),
580
                  path, virStrerror(errno, ebuf, sizeof ebuf));
D
Daniel P. Berrange 已提交
581
        goto cleanup;
582
    }
D
Daniel P. Berrange 已提交
583
    umask(oldmask);
584 585 586 587
    if (server->privileged && setgid(oldgrp)) {
        VIR_ERROR(_("Failed to restore group ID to %d"), oldgrp);
        goto cleanup;
    }
D
Daniel P. Berrange 已提交
588

589
    if (listen(sock->fd, 30) < 0) {
590
        VIR_ERROR(_("Failed to listen for connections on '%s': %s"),
591
                  path, virStrerror(errno, ebuf, sizeof ebuf));
D
Daniel P. Berrange 已提交
592 593 594 595 596 597 598
        goto cleanup;
    }

    sock->next = server->sockets;
    server->sockets = sock;
    server->nsockets++;

D
Daniel P. Berrange 已提交
599
    return 0;
D
Daniel P. Berrange 已提交
600 601

 cleanup:
602
    if (sock->fd >= 0)
D
Daniel P. Berrange 已提交
603
        close(sock->fd);
604
    VIR_FREE(sock);
D
Daniel P. Berrange 已提交
605
    return -1;
D
Daniel P. Berrange 已提交
606 607
}

608 609
// See: http://people.redhat.com/drepper/userapi-ipv6.html
static int
610
remoteMakeSockets (int *fds, int max_fds, int *nfds_r, const char *node, const char *service)
611 612 613 614 615 616 617
{
    struct addrinfo *ai;
    struct addrinfo hints;
    memset (&hints, 0, sizeof hints);
    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
    hints.ai_socktype = SOCK_STREAM;

618
    int e = getaddrinfo (node, service, &hints, &ai);
619
    if (e != 0) {
620
        VIR_ERROR(_("getaddrinfo: %s"), gai_strerror (e));
621 622 623 624 625
        return -1;
    }

    struct addrinfo *runp = ai;
    while (runp && *nfds_r < max_fds) {
626
        char ebuf[1024];
627 628 629
        fds[*nfds_r] = socket (runp->ai_family, runp->ai_socktype,
                               runp->ai_protocol);
        if (fds[*nfds_r] == -1) {
630
            VIR_ERROR(_("socket: %s"), virStrerror (errno, ebuf, sizeof ebuf));
631 632 633 634 635 636
            return -1;
        }

        int opt = 1;
        setsockopt (fds[*nfds_r], SOL_SOCKET, SO_REUSEADDR, &opt, sizeof opt);

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
#ifdef IPV6_V6ONLY
        if (runp->ai_family == PF_INET6) {
            int on = 1;
            /*
             * Normally on Linux an INET6 socket will bind to the INET4
             * address too. If getaddrinfo returns results with INET4
             * first though, this will result in INET6 binding failing.
             * We can trivially cope with multiple server sockets, so
             * we force it to only listen on IPv6
             */
            setsockopt(fds[*nfds_r], IPPROTO_IPV6,IPV6_V6ONLY,
                       (void*)&on, sizeof on);
        }
#endif

652 653
        if (bind (fds[*nfds_r], runp->ai_addr, runp->ai_addrlen) == -1) {
            if (errno != EADDRINUSE) {
654
                VIR_ERROR(_("bind: %s"), virStrerror (errno, ebuf, sizeof ebuf));
655 656 657
                return -1;
            }
            close (fds[*nfds_r]);
658
        } else {
659 660 661 662
            ++*nfds_r;
        }
        runp = runp->ai_next;
    }
663

664 665 666 667 668 669 670 671 672
    freeaddrinfo (ai);
    return 0;
}

/* Listen on the named/numbered TCP port.  On a machine with IPv4 and
 * IPv6 interfaces this may generate several sockets.
 */
static int
remoteListenTCP (struct qemud_server *server,
673
                 const char *addr,
674
                 const char *port,
675
                 int type,
676
                 int auth)
677 678 679
{
    int fds[2];
    int nfds = 0;
680
    int i;
681 682
    struct qemud_socket *sock;

683
    if (remoteMakeSockets (fds, 2, &nfds, addr, port) == -1)
684 685 686
        return -1;

    for (i = 0; i < nfds; ++i) {
687 688 689 690 691 692 693 694
        union {
            struct sockaddr_storage sa_stor;
            struct sockaddr sa;
            struct sockaddr_in sa_in;
#ifdef AF_INET6
            struct sockaddr_in6 sa_in6;
#endif
        } s;
695
        char ebuf[1024];
696
        socklen_t salen = sizeof(s);
697

698
        if (VIR_ALLOC(sock) < 0) {
699 700
            VIR_ERROR(_("remoteListenTCP: calloc: %s"),
                      virStrerror (errno, ebuf, sizeof ebuf));
701
            goto cleanup;
702 703 704 705 706 707 708 709
        }

        sock->readonly = 0;
        sock->next = server->sockets;
        server->sockets = sock;
        server->nsockets++;

        sock->fd = fds[i];
710
        sock->type = type;
711
        sock->auth = auth;
D
Daniel P. Berrange 已提交
712

713
        if (getsockname(sock->fd, &s.sa, &salen) < 0)
714
            goto cleanup;
715

716 717
        if (s.sa.sa_family == AF_INET) {
            sock->port = htons(s.sa_in.sin_port);
718
#ifdef AF_INET6
719 720
        } else if (s.sa.sa_family == AF_INET6)
            sock->port = htons(s.sa_in6.sin6_port);
721
#endif
722 723 724
        else
            sock->port = -1;

725 726
        if (virSetCloseExec(sock->fd) < 0 ||
            virSetNonBlock(sock->fd) < 0)
727
            goto cleanup;
728 729

        if (listen (sock->fd, 30) < 0) {
730 731
            VIR_ERROR(_("remoteListenTCP: listen: %s"),
                      virStrerror (errno, ebuf, sizeof ebuf));
732
            goto cleanup;
733
        }
734 735 736
    }

    return 0;
737 738 739

cleanup:
    for (i = 0; i < nfds; ++i)
C
Cole Robinson 已提交
740
        close(fds[i]);
741
    return -1;
742 743 744 745 746
}

static int qemudInitPaths(struct qemud_server *server,
                          char *sockname,
                          char *roSockname,
J
John Levon 已提交
747 748
                          int maxlen)
{
749 750 751 752 753
    char *sock_dir;
    char *dir_prefix = NULL;
    int ret = -1;
    char *sock_dir_prefix = NULL;

D
Daniel P. Berrange 已提交
754
    if (unix_sock_dir) {
755
        sock_dir = unix_sock_dir;
D
Daniel P. Berrange 已提交
756 757 758 759 760 761 762
        /* Change the group ownership of /var/run/libvirt to unix_sock_gid */
        if (server->privileged) {
            if (chown(unix_sock_dir, -1, unix_sock_gid) < 0)
                VIR_ERROR(_("Failed to change group ownership of %s"),
                          unix_sock_dir);
        }
    } else {
763
        sock_dir = sockname;
764
        if (server->privileged) {
765 766
            dir_prefix = strdup (LOCAL_STATE_DIR);
            if (dir_prefix == NULL) {
767
                virReportOOMError();
768 769 770 771 772 773
                goto cleanup;
            }
            if (snprintf (sock_dir, maxlen, "%s/run/libvirt",
                          dir_prefix) >= maxlen)
                goto snprintf_error;
        } else {
774
            uid_t uid = geteuid();
775
            dir_prefix = virGetUserDirectory(uid);
776 777 778 779
            if (dir_prefix == NULL) {
                /* Do not diagnose here; virGetUserDirectory does that.  */
                goto snprintf_error;
            }
780

781 782 783 784
            if (snprintf(sock_dir, maxlen, "%s/.libvirt", dir_prefix) >= maxlen)
                goto snprintf_error;
        }
    }
785

786 787
    sock_dir_prefix = strdup (sock_dir);
    if (!sock_dir_prefix) {
788
        virReportOOMError();
789 790
        goto cleanup;
    }
D
Daniel P. Berrange 已提交
791

792
    if (server->privileged) {
793 794 795 796
        if (snprintf (sockname, maxlen, "%s/libvirt-sock",
                      sock_dir_prefix) >= maxlen
            || (snprintf (roSockname, maxlen, "%s/libvirt-sock-ro",
                          sock_dir_prefix) >= maxlen))
797
            goto snprintf_error;
798
        unlink(sockname);
799
        unlink(roSockname);
D
Daniel P. Berrange 已提交
800
    } else {
801 802
        if (snprintf(sockname, maxlen, "@%s/libvirt-sock",
                     sock_dir_prefix) >= maxlen)
803
            goto snprintf_error;
804
    }
805

806 807
    if (server->privileged) {
        if (!(server->logDir = strdup (LOCAL_STATE_DIR "/log/libvirt")))
808
            virReportOOMError();
809 810
    } else {
        if (virAsprintf(&server->logDir, "%s/.libvirt/log", dir_prefix) < 0)
811
            virReportOOMError();
812
    }
813

814
    if (server->logDir == NULL)
815
        goto cleanup;
816 817

    ret = 0;
818 819

 snprintf_error:
820
    if (ret)
821
        VIR_ERROR0(_("Resulting path too long for buffer in qemudInitPaths()"));
822 823

 cleanup:
824 825
    VIR_FREE(dir_prefix);
    VIR_FREE(sock_dir_prefix);
826
    return ret;
D
Daniel P. Berrange 已提交
827 828
}

829 830 831 832 833 834
static void virshErrorHandler(void *opaque ATTRIBUTE_UNUSED, virErrorPtr err ATTRIBUTE_UNUSED)
{
    /* Don't do anything, since logging infrastructure already
     * took care of reporting the error */
}

835
static struct qemud_server *qemudInitialize(void) {
D
Daniel P. Berrange 已提交
836 837
    struct qemud_server *server;

838
    if (VIR_ALLOC(server) < 0) {
839
        VIR_ERROR0(_("Failed to allocate struct qemud_server"));
D
Daniel P. Berrange 已提交
840
        return NULL;
841
    }
D
Daniel P. Berrange 已提交
842

843 844 845
    server->privileged = geteuid() == 0 ? 1 : 0;
    server->sigread = server->sigwrite = -1;

846
    if (virMutexInit(&server->lock) < 0) {
847
        VIR_ERROR0(_("cannot initialize mutex"));
848
        VIR_FREE(server);
849
        return NULL;
850 851
    }
    if (virCondInit(&server->job) < 0) {
852
        VIR_ERROR0(_("cannot initialize condition variable"));
853
        virMutexDestroy(&server->lock);
854
        VIR_FREE(server);
855
        return NULL;
856 857
    }

858
    if (virEventInit() < 0) {
859
        VIR_ERROR0(_("Failed to initialize event system"));
860 861 862
        virMutexDestroy(&server->lock);
        if (virCondDestroy(&server->job) < 0)
        {}
863 864 865 866
        VIR_FREE(server);
        return NULL;
    }

867 868 869 870 871 872 873
    /*
     * Note that the order is important: the first ones have a higher
     * priority when calling virStateInitialize. We must register
     * the network, storage and nodedev drivers before any domain
     * drivers, since their resources must be auto-started before
     * any domains can be auto-started.
     */
874 875 876
#ifdef WITH_DRIVER_MODULES
    /* We don't care if any of these fail, because the whole point
     * is to allow users to only install modules they want to use.
D
Dan Kenigsberg 已提交
877
     * If they try to open a connection for a module that
878 879 880 881
     * is not loaded they'll get a suitable error at that point
     */
    virDriverLoadModule("network");
    virDriverLoadModule("storage");
882
    virDriverLoadModule("nodedev");
883
    virDriverLoadModule("secret");
884 885 886
    virDriverLoadModule("qemu");
    virDriverLoadModule("lxc");
    virDriverLoadModule("uml");
D
Daniel Veillard 已提交
887
    virDriverLoadModule("one");
888
    virDriverLoadModule("nwfilter");
889
#else
890
# ifdef WITH_NETWORK
891
    networkRegister();
892 893
# endif
# ifdef WITH_NETCF
894
    interfaceRegister();
895 896
# endif
# ifdef WITH_STORAGE_DIR
897
    storageRegister();
898 899
# endif
# if defined(WITH_NODE_DEVICES)
900
    nodedevRegister();
901 902
# endif
# ifdef WITH_SECRETS
903
    secretRegister();
904
# endif
905 906 907
# ifdef WITH_NWFILTER
    nwfilterRegister();
# endif
908
# ifdef WITH_QEMU
909
    qemuRegister();
910 911
# endif
# ifdef WITH_LXC
912
    lxcRegister();
913 914
# endif
# ifdef WITH_UML
915
    umlRegister();
916 917
# endif
# ifdef WITH_ONE
D
Daniel Veillard 已提交
918
    oneRegister();
919
# endif
920 921
#endif

922 923 924 925 926 927
    virEventRegisterImpl(virEventAddHandleImpl,
                         virEventUpdateHandleImpl,
                         virEventRemoveHandleImpl,
                         virEventAddTimeoutImpl,
                         virEventUpdateTimeoutImpl,
                         virEventRemoveTimeoutImpl);
928

929 930 931
    return server;
}

932
static int qemudNetworkInit(struct qemud_server *server) {
933 934
    char sockname[PATH_MAX];
    char roSockname[PATH_MAX];
935
#if HAVE_SASL
936 937 938 939 940 941 942 943 944
    int err;
#endif /* HAVE_SASL */

    roSockname[0] = '\0';

    if (qemudInitPaths(server, sockname, roSockname, PATH_MAX) < 0)
        goto cleanup;

    if (qemudListenUnix(server, sockname, 0, auth_unix_rw) < 0)
945
        goto cleanup;
946 947 948 949 950 951 952 953 954 955

    if (roSockname[0] != '\0' && qemudListenUnix(server, roSockname, 1, auth_unix_ro) < 0)
        goto cleanup;

#if HAVE_SASL
    if (auth_unix_rw == REMOTE_AUTH_SASL ||
        auth_unix_ro == REMOTE_AUTH_SASL ||
        auth_tcp == REMOTE_AUTH_SASL ||
        auth_tls == REMOTE_AUTH_SASL) {
        if ((err = sasl_server_init(NULL, "libvirt")) != SASL_OK) {
956 957
            VIR_ERROR(_("Failed to initialize SASL authentication %s"),
                      sasl_errstring(err, NULL, NULL));
958 959
            goto cleanup;
        }
960 961 962
    }
#endif

963
#if HAVE_POLKIT0
964 965 966
    if (auth_unix_rw == REMOTE_AUTH_POLKIT ||
        auth_unix_ro == REMOTE_AUTH_POLKIT) {
        DBusError derr;
967 968 969 970

        dbus_connection_set_change_sigpipe(FALSE);
        dbus_threads_init_default();

971 972 973
        dbus_error_init(&derr);
        server->sysbus = dbus_bus_get(DBUS_BUS_SYSTEM, &derr);
        if (!(server->sysbus)) {
974 975
            VIR_ERROR(_("Failed to connect to system bus for PolicyKit auth: %s"),
                      derr.message);
976 977 978
            dbus_error_free(&derr);
            goto cleanup;
        }
979
        dbus_connection_set_exit_on_disconnect(server->sysbus, FALSE);
980 981 982
    }
#endif

983
    if (ipsock) {
984
        if (listen_tcp && remoteListenTCP (server, listen_addr, tcp_port, QEMUD_SOCK_TYPE_TCP, auth_tcp) < 0)
985 986 987 988 989 990
            goto cleanup;

        if (listen_tls) {
            if (remoteInitializeGnuTLS () < 0)
                goto cleanup;

991
            if (remoteListenTCP (server, listen_addr, tls_port, QEMUD_SOCK_TYPE_TLS, auth_tls) < 0)
992 993
                goto cleanup;
        }
D
Daniel P. Berrange 已提交
994 995
    }

996
#ifdef HAVE_AVAHI
997
    if (server->privileged && mdns_adv) {
998
        struct libvirtd_mdns_group *group;
999
        struct qemud_socket *sock;
1000
        int port = 0;
1001
        int ret;
1002 1003 1004 1005

        server->mdns = libvirtd_mdns_new();

        if (!mdns_name) {
1006 1007
            char *groupname, *localhost, *tmp;

1008 1009
            localhost = virGetHostname(NULL);
            if (localhost == NULL)
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
                /* we couldn't resolve the hostname; assume that we are
                 * running in disconnected operation, and report a less
                 * useful Avahi string
                 */
                ret = virAsprintf(&groupname, "Virtualization Host");
            else {
                /* Extract the host part of the potentially FQDN */
                if ((tmp = strchr(localhost, '.')))
                    *tmp = '\0';
                ret = virAsprintf(&groupname, "Virtualization Host %s",
                                  localhost);
            }
            VIR_FREE(localhost);
            if (ret < 0) {
                virReportOOMError();
1025
                goto cleanup;
1026
            }
1027
            group = libvirtd_mdns_add_group(server->mdns, groupname);
1028
            VIR_FREE(groupname);
1029 1030 1031 1032
        } else {
            group = libvirtd_mdns_add_group(server->mdns, mdns_name);
        }

1033
        /*
1034 1035 1036 1037 1038 1039
         * See if there's a TLS enabled port we can advertise. Cowardly
         * don't bother to advertise TCP since we don't want people using
         * them for real world apps
         */
        sock = server->sockets;
        while (sock) {
1040
            if (sock->port != -1 && sock->type == QEMUD_SOCK_TYPE_TLS) {
1041 1042 1043 1044 1045
                port = sock->port;
                break;
            }
            sock = sock->next;
        }
1046

1047 1048 1049 1050 1051 1052 1053 1054 1055
        /*
         * Add the primary entry - we choose SSH because its most likely to always
         * be available
         */
        libvirtd_mdns_add_entry(group, "_libvirt._tcp", port);
        libvirtd_mdns_start(server->mdns);
    }
#endif

1056
    return 0;
D
Daniel P. Berrange 已提交
1057 1058

 cleanup:
1059
    return -1;
D
Daniel P. Berrange 已提交
1060 1061
}

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
static int qemudNetworkEnable(struct qemud_server *server) {
    struct qemud_socket *sock;

    sock = server->sockets;
    while (sock) {
        if ((sock->watch = virEventAddHandleImpl(sock->fd,
                                                 VIR_EVENT_HANDLE_READABLE |
                                                 VIR_EVENT_HANDLE_ERROR |
                                                 VIR_EVENT_HANDLE_HANGUP,
                                                 qemudDispatchServerEvent,
                                                 server, NULL)) < 0) {
            VIR_ERROR0(_("Failed to add server event callback"));
            return -1;
        }

        sock = sock->next;
    }
    return 0;
}
1081

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
static gnutls_session_t
remoteInitializeTLSSession (void)
{
  gnutls_session_t session;
  int err;

  err = gnutls_init (&session, GNUTLS_SERVER);
  if (err != 0) goto failed;

  /* avoid calling all the priority functions, since the defaults
   * are adequate.
   */
  err = gnutls_set_default_priority (session);
  if (err != 0) goto failed;

  err = gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509_cred);
  if (err != 0) goto failed;

  /* request client certificate if any.
   */
  gnutls_certificate_server_set_request (session, GNUTLS_CERT_REQUEST);

  gnutls_dh_set_prime_bits (session, DH_BITS);

  return session;

 failed:
1109
  VIR_ERROR(_("remoteInitializeTLSSession: %s"),
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
            gnutls_strerror (err));
  return NULL;
}

/* Check DN is on tls_allowed_dn_list. */
static int
remoteCheckDN (gnutls_x509_crt_t cert)
{
    char name[256];
    size_t namesize = sizeof name;
1120
    char **wildcards;
1121 1122 1123 1124
    int err;

    err = gnutls_x509_crt_get_dn (cert, name, &namesize);
    if (err != 0) {
1125
        VIR_ERROR(_("remoteCheckDN: gnutls_x509_cert_get_dn: %s"),
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
                  gnutls_strerror (err));
        return 0;
    }

    /* If the list is not set, allow any DN. */
    wildcards = tls_allowed_dn_list;
    if (!wildcards)
        return 1;

    while (*wildcards) {
        if (fnmatch (*wildcards, name, 0) == 0)
            return 1;
        wildcards++;
    }

    /* Print the client's DN. */
1142
    DEBUG(_("remoteCheckDN: failed: client DN is %s"), name);
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156

    return 0; // Not found.
}

static int
remoteCheckCertificate (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){
1157
        VIR_ERROR(_("remoteCheckCertificate: verify failed: %s"),
1158 1159 1160 1161 1162 1163
                  gnutls_strerror (ret));
        return -1;
    }

    if (status != 0) {
        if (status & GNUTLS_CERT_INVALID)
1164 1165
            VIR_ERROR0(_("remoteCheckCertificate: "
                         "the client certificate is not trusted."));
1166 1167

        if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
1168 1169
            VIR_ERROR0(_("remoteCheckCertificate: the client "
                         "certificate has unknown issuer."));
1170 1171

        if (status & GNUTLS_CERT_REVOKED)
1172 1173
            VIR_ERROR0(_("remoteCheckCertificate: "
                         "the client certificate has been revoked."));
1174

1175
#ifndef GNUTLS_1_0_COMPAT
1176
        if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
1177 1178
            VIR_ERROR0(_("remoteCheckCertificate: the client certificate"
                         " uses an insecure algorithm."));
1179
#endif
1180 1181 1182 1183 1184

        return -1;
    }

    if (gnutls_certificate_type_get (session) != GNUTLS_CRT_X509) {
1185
        VIR_ERROR0(_("remoteCheckCertificate: certificate is not X.509"));
1186 1187 1188 1189
        return -1;
    }

    if (!(certs = gnutls_certificate_get_peers(session, &nCerts))) {
1190
        VIR_ERROR0(_("remoteCheckCertificate: no peers"));
1191 1192 1193 1194 1195 1196 1197 1198 1199
        return -1;
    }

    now = time (NULL);

    for (i = 0; i < nCerts; i++) {
        gnutls_x509_crt_t cert;

        if (gnutls_x509_crt_init (&cert) < 0) {
1200
            VIR_ERROR0(_("remoteCheckCertificate: gnutls_x509_crt_init failed"));
1201 1202 1203 1204 1205 1206 1207
            return -1;
        }

        if (gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER) < 0) {
            gnutls_x509_crt_deinit (cert);
            return -1;
        }
1208

1209
        if (gnutls_x509_crt_get_expiration_time (cert) < now) {
1210 1211
            VIR_ERROR0(_("remoteCheckCertificate: "
                         "the client certificate has expired"));
1212 1213 1214
            gnutls_x509_crt_deinit (cert);
            return -1;
        }
1215

1216
        if (gnutls_x509_crt_get_activation_time (cert) > now) {
1217 1218
            VIR_ERROR0(_("remoteCheckCertificate: the client "
                         "certificate is not yet activated"));
1219 1220 1221 1222 1223 1224 1225
            gnutls_x509_crt_deinit (cert);
            return -1;
        }

        if (i == 0) {
            if (!remoteCheckDN (cert)) {
                /* This is the most common error: make it informative. */
1226
                VIR_ERROR0(_("remoteCheckCertificate: client's Distinguished Name is not on the list of allowed clients (tls_allowed_dn_list).  Use 'openssl x509 -in clientcert.pem -text' to view the Distinguished Name field in the client certificate, or run this daemon with --verbose option."));
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
                gnutls_x509_crt_deinit (cert);
                return -1;
            }
        }
    }

    return 0;
}

/* Check the client's access. */
static int
remoteCheckAccess (struct qemud_client *client)
{
1240 1241
    struct qemud_client_message *confirm;

1242
    /* Verify client certificate. */
1243
    if (remoteCheckCertificate (client->tlssession) == -1) {
1244 1245
        VIR_ERROR0(_("remoteCheckCertificate: "
                     "failed to verify client's certificate"));
1246
        if (!tls_no_verify_certificate) return -1;
1247 1248
        else VIR_INFO0(_("remoteCheckCertificate: tls_no_verify_certificate "
                          "is set so the bad certificate is ignored"));
1249 1250
    }

1251 1252 1253 1254 1255 1256 1257 1258 1259
    if (client->tx) {
        VIR_INFO("%s",
                 _("client had unexpected data pending tx after access check"));
        return -1;
    }

    if (VIR_ALLOC(confirm) < 0)
        return -1;

1260 1261 1262 1263
    /* Checks have succeeded.  Write a '\1' byte back to the client to
     * indicate this (otherwise the socket is abruptly closed).
     * (NB. The '\1' byte is sent in an encrypted record).
     */
1264 1265 1266 1267 1268 1269
    confirm->async = 1;
    confirm->bufferLength = 1;
    confirm->bufferOffset = 0;
    confirm->buffer[0] = '\1';

    client->tx = confirm;
1270 1271
    return 0;
}
D
Daniel P. Berrange 已提交
1272

1273 1274
#if HAVE_POLKIT
int qemudGetSocketIdentity(int fd, uid_t *uid, pid_t *pid) {
1275
# ifdef SO_PEERCRED
1276 1277 1278 1279
    struct ucred cr;
    unsigned int cr_len = sizeof (cr);

    if (getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) < 0) {
1280
        char ebuf[1024];
1281
        VIR_ERROR(_("Failed to verify client credentials: %s"),
1282
                  virStrerror(errno, ebuf, sizeof ebuf));
1283 1284 1285 1286 1287
        return -1;
    }

    *pid = cr.pid;
    *uid = cr.uid;
1288
# else
1289
    /* XXX Many more OS support UNIX socket credentials we could port to. See dbus ....*/
1290 1291
#  error "UNIX socket credentials not supported/implemented on this platform yet..."
# endif
1292 1293 1294 1295
    return 0;
}
#endif

1296

D
Daniel P. Berrange 已提交
1297 1298 1299
static int qemudDispatchServer(struct qemud_server *server, struct qemud_socket *sock) {
    int fd;
    struct sockaddr_storage addr;
1300
    socklen_t addrlen = (socklen_t) (sizeof addr);
D
Daniel P. Berrange 已提交
1301
    struct qemud_client *client;
1302
    int no_slow_start = 1;
1303
    int i;
D
Daniel P. Berrange 已提交
1304 1305

    if ((fd = accept(sock->fd, (struct sockaddr *)&addr, &addrlen)) < 0) {
1306
        char ebuf[1024];
D
Daniel P. Berrange 已提交
1307 1308
        if (errno == EAGAIN)
            return 0;
1309 1310
        VIR_ERROR(_("Failed to accept connection: %s"),
                  virStrerror(errno, ebuf, sizeof ebuf));
D
Daniel P. Berrange 已提交
1311 1312 1313
        return -1;
    }

1314
    if (server->nclients >= max_clients) {
1315
        VIR_ERROR(_("Too many active clients (%d), dropping connection"), max_clients);
1316 1317 1318 1319
        close(fd);
        return -1;
    }

1320
    if (VIR_REALLOC_N(server->clients, server->nclients+1) < 0) {
1321
        VIR_ERROR0(_("Out of memory allocating clients"));
1322 1323 1324 1325
        close(fd);
        return -1;
    }

J
John Levon 已提交
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
#ifdef __sun
    {
        ucred_t *ucred = NULL;
        const priv_set_t *privs;

        if (getpeerucred (fd, &ucred) == -1 ||
            (privs = ucred_getprivset (ucred, PRIV_EFFECTIVE)) == NULL) {
            if (ucred != NULL)
                ucred_free (ucred);
            close (fd);
            return -1;
        }

        if (!priv_ismember (privs, PRIV_VIRT_MANAGE)) {
            ucred_free (ucred);
            close (fd);
            return -1;
        }

        ucred_free (ucred);
    }
#endif /* __sun */

1349 1350 1351 1352
    /* Disable Nagle.  Unix sockets will ignore this. */
    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&no_slow_start,
                sizeof no_slow_start);

1353 1354
    if (virSetCloseExec(fd) < 0 ||
        virSetNonBlock(fd) < 0) {
D
Daniel P. Berrange 已提交
1355 1356 1357 1358
        close(fd);
        return -1;
    }

1359
    if (VIR_ALLOC(client) < 0)
1360
        goto cleanup;
1361
    if (virMutexInit(&client->lock) < 0) {
1362
        VIR_ERROR0(_("cannot initialize mutex"));
1363
        VIR_FREE(client);
1364
        goto cleanup;
1365
    }
1366

1367
    client->magic = QEMUD_CLIENT_MAGIC;
D
Daniel P. Berrange 已提交
1368 1369
    client->fd = fd;
    client->readonly = sock->readonly;
1370
    client->type = sock->type;
1371
    client->auth = sock->auth;
1372 1373 1374
    memcpy (&client->addr, &addr, sizeof addr);
    client->addrlen = addrlen;

1375 1376 1377 1378
    for (i = 0 ; i < VIR_DOMAIN_EVENT_ID_LAST ; i++) {
        client->domainEventCallbackID[i] = -1;
    }

1379 1380 1381 1382 1383 1384
    /* Prepare one for packet receive */
    if (VIR_ALLOC(client->rx) < 0)
        goto cleanup;
    client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;


1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
#if HAVE_POLKIT
    /* Only do policy checks for non-root - allow root user
       through with no checks, as a fail-safe - root can easily
       change policykit policy anyway, so its pointless trying
       to restrict root */
    if (client->auth == REMOTE_AUTH_POLKIT) {
        uid_t uid;
        pid_t pid;

        if (qemudGetSocketIdentity(client->fd, &uid, &pid) < 0)
            goto cleanup;

1397
        /* Client is running as root, so disable auth */
1398
        if (uid == 0) {
1399
            VIR_INFO(_("Turn off polkit auth for privileged client %d"), pid);
1400 1401 1402 1403 1404
            client->auth = REMOTE_AUTH_NONE;
        }
    }
#endif

1405
    if (client->type != QEMUD_SOCK_TYPE_TLS) {
1406
        /* Plain socket, so prepare to read first message */
1407
        if (qemudRegisterClientEvent (server, client) < 0)
D
Daniel P. Berrange 已提交
1408
            goto cleanup;
1409 1410 1411
    } else {
        int ret;

1412 1413
        client->tlssession = remoteInitializeTLSSession ();
        if (client->tlssession == NULL)
D
Daniel P. Berrange 已提交
1414
            goto cleanup;
1415

1416
        gnutls_transport_set_ptr (client->tlssession,
1417 1418 1419
                                  (gnutls_transport_ptr_t) (long) fd);

        /* Begin the TLS handshake. */
1420
        ret = gnutls_handshake (client->tlssession);
1421
        if (ret == 0) {
1422 1423
            client->handshake = 0;

1424 1425
            /* Unlikely, but ...  Next step is to check the certificate. */
            if (remoteCheckAccess (client) == -1)
D
Daniel P. Berrange 已提交
1426 1427
                goto cleanup;

1428
            /* Handshake & cert check OK,  so prepare to read first message */
1429
            if (qemudRegisterClientEvent(server, client) < 0)
D
Daniel P. Berrange 已提交
1430
                goto cleanup;
1431
        } else if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
1432 1433
            /* Most likely, need to do more handshake data */
            client->handshake = 1;
D
Daniel P. Berrange 已提交
1434

1435
            if (qemudRegisterClientEvent (server, client) < 0)
D
Daniel P. Berrange 已提交
1436
                goto cleanup;
1437
        } else {
1438
            VIR_ERROR(_("TLS handshake failed: %s"),
1439
                      gnutls_strerror (ret));
D
Daniel P. Berrange 已提交
1440
            goto cleanup;
1441 1442
        }
    }
D
Daniel P. Berrange 已提交
1443

1444
    server->clients[server->nclients++] = client;
D
Daniel P. Berrange 已提交
1445

1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
    if (server->nclients > server->nactiveworkers &&
        server->nactiveworkers < server->nworkers) {
        for (i = 0 ; i < server->nworkers ; i++) {
            if (!server->workers[i].hasThread) {
                if (qemudStartWorker(server, &server->workers[i]) < 0)
                    return -1;
                server->nactiveworkers++;
                break;
            }
        }
    }


D
Daniel P. Berrange 已提交
1459
    return 0;
1460

D
Daniel P. Berrange 已提交
1461
 cleanup:
1462 1463
    if (client &&
        client->tlssession) gnutls_deinit (client->tlssession);
1464
    close (fd);
1465 1466
    if (client)
        VIR_FREE(client->rx);
1467
    VIR_FREE(client);
1468
    return -1;
D
Daniel P. Berrange 已提交
1469 1470 1471
}


1472 1473 1474 1475 1476 1477 1478
/*
 * You must hold lock for at least the client
 * We don't free stuff here, merely disconnect the client's
 * network socket & resources.
 * We keep the libvirt connection open until any async
 * jobs have finished, then clean it up elsehwere
 */
1479
void qemudDispatchClientFailure(struct qemud_client *client) {
1480 1481 1482 1483
    if (client->watch != -1) {
        virEventRemoveHandleImpl(client->watch);
        client->watch = -1;
    }
D
Daniel P. Berrange 已提交
1484

1485
    /* Deregister event delivery callback */
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
    if (client->conn) {
        int i;

        for (i = 0 ; i < VIR_DOMAIN_EVENT_ID_LAST ; i++) {
            if (client->domainEventCallbackID[i] != -1) {
                DEBUG("Deregistering to relay remote events %d", i);
                virConnectDomainEventDeregisterAny(client->conn,
                                                   client->domainEventCallbackID[i]);
            }
            client->domainEventCallbackID[i] = -1;
        }
1497 1498
    }

1499
#if HAVE_SASL
1500 1501 1502 1503
    if (client->saslconn) {
        sasl_dispose(&client->saslconn);
        client->saslconn = NULL;
    }
1504
    VIR_FREE(client->saslUsername);
1505
#endif
1506 1507 1508 1509 1510 1511 1512 1513
    if (client->tlssession) {
        gnutls_deinit (client->tlssession);
        client->tlssession = NULL;
    }
    if (client->fd != -1) {
        close(client->fd);
        client->fd = -1;
    }
1514 1515 1516 1517 1518 1519 1520 1521
}


/* Caller must hold server lock */
static struct qemud_client *qemudPendingJob(struct qemud_server *server)
{
    int i;
    for (i = 0 ; i < server->nclients ; i++) {
1522
        virMutexLock(&server->clients[i]->lock);
1523
        if (server->clients[i]->dx) {
1524 1525 1526
            /* Delibrately don't unlock client - caller wants the lock */
            return server->clients[i];
        }
1527
        virMutexUnlock(&server->clients[i]->lock);
1528 1529
    }
    return NULL;
D
Daniel P. Berrange 已提交
1530 1531
}

1532 1533
static void *qemudWorker(void *data)
{
1534 1535
    struct qemud_worker *worker = data;
    struct qemud_server *server = worker->server;
1536 1537

    while (1) {
1538
        struct qemud_client *client = NULL;
1539
        struct qemud_client_message *msg;
1540

1541
        virMutexLock(&server->lock);
1542 1543 1544
        while ((client = qemudPendingJob(server)) == NULL) {
            if (worker->quitRequest ||
                virCondWait(&server->job, &server->lock) < 0) {
1545 1546 1547 1548
                virMutexUnlock(&server->lock);
                return NULL;
            }
        }
1549
        if (worker->quitRequest) {
1550
            virMutexUnlock(&client->lock);
1551 1552 1553 1554
            virMutexUnlock(&server->lock);
            return NULL;
        }
        worker->processingCall = 1;
1555
        virMutexUnlock(&server->lock);
1556 1557 1558 1559

        /* We own a locked client now... */
        client->refs++;

1560
        /* Remove our message from dispatch queue while we use it */
1561
        msg = qemudClientMessageQueueServe(&client->dx);
1562 1563 1564

        /* This function drops the lock during dispatch,
         * and re-acquires it before returning */
1565
        if (remoteDispatchClientRequest (server, client, msg) < 0) {
1566
            VIR_FREE(msg);
1567 1568 1569 1570 1571
            qemudDispatchClientFailure(client);
            client->refs--;
            virMutexUnlock(&client->lock);
            continue;
        }
1572 1573

        client->refs--;
1574
        virMutexUnlock(&client->lock);
1575 1576 1577 1578

        virMutexLock(&server->lock);
        worker->processingCall = 0;
        virMutexUnlock(&server->lock);
1579 1580
    }
}
D
Daniel P. Berrange 已提交
1581

1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
static int qemudStartWorker(struct qemud_server *server,
                            struct qemud_worker *worker) {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    /* We want to join workers, so don't detach them */
    /*pthread_attr_setdetachstate(&attr, 1);*/

    if (worker->hasThread)
        return -1;

    worker->server = server;
    worker->hasThread = 1;
    worker->quitRequest = 0;
    worker->processingCall = 0;

    if (pthread_create(&worker->thread,
                       &attr,
                       qemudWorker,
                       worker) != 0) {
        worker->hasThread = 0;
        worker->server = NULL;
        return -1;
    }

    return 0;
}

D
Daniel P. Berrange 已提交
1609

1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
/*
 * Read data into buffer using wire decoding (plain or TLS)
 *
 * Returns:
 *   -1 on error or EOF
 *    0 on EAGAIN
 *    n number of bytes
 */
static ssize_t qemudClientReadBuf(struct qemud_client *client,
                                  char *data, ssize_t len) {
    ssize_t ret;

    if (len < 0) {
1623 1624
        VIR_ERROR(_("unexpected negative length request %lld"),
                  (long long int) len);
1625 1626 1627
        qemudDispatchClientFailure(client);
        return -1;
    }
1628 1629 1630

    /*qemudDebug ("qemudClientRead: len = %d", len);*/

1631
    if (!client->tlssession) {
1632
        char ebuf[1024];
1633 1634 1635 1636 1637 1638
        ret = read (client->fd, data, len);
        if (ret == -1 && (errno == EAGAIN ||
                          errno == EINTR))
            return 0;
        if (ret <= 0) {
            if (ret != 0)
1639 1640
                VIR_ERROR(_("read: %s"),
                          virStrerror (errno, ebuf, sizeof ebuf));
1641
            qemudDispatchClientFailure(client);
1642 1643 1644
            return -1;
        }
    } else {
1645
        ret = gnutls_record_recv (client->tlssession, data, len);
1646 1647 1648 1649 1650 1651 1652 1653 1654

        if (ret < 0 && (ret == GNUTLS_E_AGAIN ||
                        ret == GNUTLS_E_INTERRUPTED))
            return 0;
        if (ret <= 0) {
            if (ret != 0)
                VIR_ERROR(_("gnutls_record_recv: %s"),
                          gnutls_strerror (ret));
            qemudDispatchClientFailure(client);
1655 1656
            return -1;
        }
D
Daniel P. Berrange 已提交
1657
    }
1658

1659 1660 1661
    return ret;
}

1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
/*
 * Read data into buffer without decoding
 *
 * Returns:
 *   -1 on error or EOF
 *    0 on EAGAIN
 *    n number of bytes
 */
static ssize_t qemudClientReadPlain(struct qemud_client *client) {
    ssize_t ret;
    ret = qemudClientReadBuf(client,
                             client->rx->buffer + client->rx->bufferOffset,
                             client->rx->bufferLength - client->rx->bufferOffset);
    if (ret <= 0)
        return ret; /* -1 error, 0 eagain */

    client->rx->bufferOffset += ret;
    return ret;
D
Daniel P. Berrange 已提交
1680 1681
}

1682
#if HAVE_SASL
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
/*
 * Read data into buffer decoding with SASL
 *
 * Returns:
 *   -1 on error or EOF
 *    0 on EAGAIN
 *    n number of bytes
 */
static ssize_t qemudClientReadSASL(struct qemud_client *client) {
    ssize_t got, want;
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702

    /* We're doing a SSF data read, so now its times to ensure
     * future writes are under SSF too.
     *
     * cf remoteSASLCheckSSF in remote.c
     */
    client->saslSSF |= QEMUD_SASL_SSF_WRITE;

    /* Need to read some more data off the wire */
    if (client->saslDecoded == NULL) {
1703
        int ret;
1704
        char encoded[8192];
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
        ssize_t encodedLen = sizeof(encoded);
        encodedLen = qemudClientReadBuf(client, encoded, encodedLen);

        if (encodedLen <= 0)
            return encodedLen;

        ret = sasl_decode(client->saslconn, encoded, encodedLen,
                          &client->saslDecoded, &client->saslDecodedLength);
        if (ret != SASL_OK) {
            VIR_ERROR(_("failed to decode SASL data %s"),
                      sasl_errstring(ret, NULL, NULL));
            qemudDispatchClientFailure(client);
1717
            return -1;
1718
        }
1719 1720 1721 1722 1723 1724

        client->saslDecodedOffset = 0;
    }

    /* Some buffered decoded data to return now */
    got = client->saslDecodedLength - client->saslDecodedOffset;
1725
    want = client->rx->bufferLength - client->rx->bufferOffset;
1726 1727 1728 1729

    if (want > got)
        want = got;

1730
    memcpy(client->rx->buffer + client->rx->bufferOffset,
1731 1732
           client->saslDecoded + client->saslDecodedOffset, want);
    client->saslDecodedOffset += want;
1733
    client->rx->bufferOffset += want;
1734 1735 1736 1737 1738 1739

    if (client->saslDecodedOffset == client->saslDecodedLength) {
        client->saslDecoded = NULL;
        client->saslDecodedOffset = client->saslDecodedLength = 0;
    }

1740
    return want;
1741 1742 1743
}
#endif

1744 1745 1746 1747 1748
/*
 * Read as much data off wire as possible till we fill our
 * buffer, or would block on I/O
 */
static ssize_t qemudClientRead(struct qemud_client *client) {
1749 1750
#if HAVE_SASL
    if (client->saslSSF & QEMUD_SASL_SSF_READ)
1751
        return qemudClientReadSASL(client);
1752 1753
    else
#endif
1754
        return qemudClientReadPlain(client);
1755 1756 1757
}


1758 1759 1760 1761 1762
/*
 * Read data until we get a complete message to process
 */
static void qemudDispatchClientRead(struct qemud_server *server,
                                    struct qemud_client *client) {
1763
    /*qemudDebug ("qemudDispatchClientRead: mode = %d", client->mode);*/
D
Daniel P. Berrange 已提交
1764

1765 1766 1767
readmore:
    if (qemudClientRead(client) < 0)
        return; /* Error */
1768

1769 1770
    if (client->rx->bufferOffset < client->rx->bufferLength)
        return; /* Still not read enough */
1771

1772 1773 1774 1775
    /* Either done with length word header */
    if (client->rx->bufferLength == REMOTE_MESSAGE_HEADER_XDR_LEN) {
        unsigned int len;
        XDR x;
1776

1777
        xdrmem_create(&x, client->rx->buffer, client->rx->bufferLength, XDR_DECODE);
1778

1779 1780
        if (!xdr_u_int(&x, &len)) {
            xdr_destroy (&x);
1781
            DEBUG0("Failed to decode packet length");
1782
            qemudDispatchClientFailure(client);
D
Daniel P. Berrange 已提交
1783 1784
            return;
        }
1785
        xdr_destroy (&x);
1786

1787 1788 1789
        if (len < REMOTE_MESSAGE_HEADER_XDR_LEN) {
            DEBUG("Packet length %u too small", len);
            qemudDispatchClientFailure(client);
1790
            return;
D
Daniel P. Berrange 已提交
1791
        }
1792

1793 1794 1795 1796 1797 1798
        /* Length includes the size of the length word itself */
        len -= REMOTE_MESSAGE_HEADER_XDR_LEN;

        if (len > REMOTE_MESSAGE_MAX) {
            DEBUG("Packet length %u too large", len);
            qemudDispatchClientFailure(client);
1799 1800 1801
            return;
        }

1802 1803
        /* Prepare to read rest of message */
        client->rx->bufferLength += len;
1804

1805
        qemudUpdateClientEvent(client);
D
Daniel P. Berrange 已提交
1806

1807 1808 1809 1810 1811
        /* Try and read payload immediately instead of going back
           into poll() because chances are the data is already
           waiting for us */
        goto readmore;
    } else {
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824
        /* Grab the completed message */
        struct qemud_client_message *msg = qemudClientMessageQueueServe(&client->rx);
        struct qemud_client_filter *filter;

        /* Decode the header so we can use it for routing decisions */
        if (remoteDecodeClientMessageHeader(msg) < 0) {
            VIR_FREE(msg);
            qemudDispatchClientFailure(client);
        }

        /* Check if any filters match this message */
        filter = client->filters;
        while (filter) {
1825 1826 1827
            int ret;
            ret = (filter->query)(client, msg, filter->opaque);
            if (ret == 1) {
1828 1829
                msg = NULL;
                break;
1830 1831 1832 1833
            } else if (ret == -1) {
                VIR_FREE(msg);
                qemudDispatchClientFailure(client);
                return;
1834 1835 1836 1837
            }
            filter = filter->next;
        }

1838
        /* Move completed message to the end of the dispatch queue */
1839 1840
        if (msg)
            qemudClientMessageQueuePush(&client->dx, msg);
1841 1842 1843 1844 1845 1846
        client->nrequests++;

        /* Possibly need to create another receive buffer */
        if ((client->nrequests < max_client_requests &&
             VIR_ALLOC(client->rx) < 0)) {
            qemudDispatchClientFailure(client);
D
Daniel P. Berrange 已提交
1847
        } else {
1848 1849 1850
            if (client->rx)
                client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;

1851 1852 1853 1854
            qemudUpdateClientEvent(client);

            /* Tell one of the workers to get on with it... */
            virCondSignal(&server->job);
D
Daniel P. Berrange 已提交
1855
        }
D
Daniel P. Berrange 已提交
1856 1857 1858 1859
    }
}


1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
/*
 * Send a chunk of data using wire encoding (plain or TLS)
 *
 * Returns:
 *   -1 on error
 *    0 on EAGAIN
 *    n number of bytes
 */
static ssize_t qemudClientWriteBuf(struct qemud_client *client,
                                   const char *data, ssize_t len) {
    ssize_t ret;

    if (len < 0) {
1873 1874
        VIR_ERROR(_("unexpected negative length request %lld"),
                  (long long int) len);
1875 1876 1877 1878
        qemudDispatchClientFailure(client);
        return -1;
    }

1879
    if (!client->tlssession) {
1880
        char ebuf[1024];
1881 1882 1883
        if ((ret = write(client->fd, data, len)) == -1) {
            if (errno == EAGAIN || errno == EINTR)
                return 0;
1884
            VIR_ERROR(_("write: %s"), virStrerror (errno, ebuf, sizeof ebuf));
1885
            qemudDispatchClientFailure(client);
1886 1887 1888
            return -1;
        }
    } else {
1889
        ret = gnutls_record_send (client->tlssession, data, len);
1890 1891 1892 1893 1894 1895 1896
        if (ret < 0) {
            if (ret == GNUTLS_E_INTERRUPTED ||
                ret == GNUTLS_E_AGAIN)
                return 0;

            VIR_ERROR(_("gnutls_record_send: %s"), gnutls_strerror (ret));
            qemudDispatchClientFailure(client);
1897 1898
            return -1;
        }
D
Daniel P. Berrange 已提交
1899
    }
1900 1901
    return ret;
}
1902

1903

1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
/*
 * Send client->tx using no encoding
 *
 * Returns:
 *   -1 on error or EOF
 *    0 on EAGAIN
 *    n number of bytes
 */
static int qemudClientWritePlain(struct qemud_client *client) {
    int ret = qemudClientWriteBuf(client,
                                  client->tx->buffer + client->tx->bufferOffset,
                                  client->tx->bufferLength - client->tx->bufferOffset);
    if (ret <= 0)
        return ret; /* -1 error, 0 = egain */
    client->tx->bufferOffset += ret;
    return ret;
D
Daniel P. Berrange 已提交
1920 1921 1922
}


1923
#if HAVE_SASL
1924 1925 1926 1927 1928 1929 1930 1931 1932
/*
 * Send client->tx using SASL encoding
 *
 * Returns:
 *   -1 on error
 *    0 on EAGAIN
 *    n number of bytes
 */
static int qemudClientWriteSASL(struct qemud_client *client) {
1933 1934 1935 1936
    int ret;

    /* Not got any pending encoded data, so we need to encode raw stuff */
    if (client->saslEncoded == NULL) {
1937 1938 1939
        ret = sasl_encode(client->saslconn,
                          client->tx->buffer + client->tx->bufferOffset,
                          client->tx->bufferLength - client->tx->bufferOffset,
1940 1941 1942
                          &client->saslEncoded,
                          &client->saslEncodedLength);

1943 1944 1945 1946 1947 1948 1949
        if (ret != SASL_OK) {
            VIR_ERROR(_("failed to encode SASL data %s"),
                      sasl_errstring(ret, NULL, NULL));
            qemudDispatchClientFailure(client);
            return -1;
        }

1950 1951 1952 1953
        client->saslEncodedOffset = 0;
    }

    /* Send some of the encoded stuff out on the wire */
1954
    ret = qemudClientWriteBuf(client,
1955 1956 1957
                              client->saslEncoded + client->saslEncodedOffset,
                              client->saslEncodedLength - client->saslEncodedOffset);

1958 1959
    if (ret <= 0)
        return ret; /* -1 error, 0 == egain */
1960 1961 1962 1963 1964 1965 1966 1967

    /* Note how much we sent */
    client->saslEncodedOffset += ret;

    /* Sent all encoded, so update raw buffer to indicate completion */
    if (client->saslEncodedOffset == client->saslEncodedLength) {
        client->saslEncoded = NULL;
        client->saslEncodedOffset = client->saslEncodedLength = 0;
1968 1969 1970

        /* Mark as complete, so caller detects completion */
        client->tx->bufferOffset = client->tx->bufferLength;
1971 1972
    }

1973
    return ret;
1974 1975 1976
}
#endif

1977 1978 1979 1980 1981 1982 1983 1984 1985
/*
 * Send as much data in the client->tx as possible
 *
 * Returns:
 *   -1 on error or EOF
 *    0 on EAGAIN
 *    n number of bytes
 */
static ssize_t qemudClientWrite(struct qemud_client *client) {
1986 1987
#if HAVE_SASL
    if (client->saslSSF & QEMUD_SASL_SSF_WRITE)
1988
        return qemudClientWriteSASL(client);
1989 1990
    else
#endif
1991
        return qemudClientWritePlain(client);
1992 1993 1994
}


1995 1996 1997 1998
void
qemudClientMessageRelease(struct qemud_client *client,
                          struct qemud_client_message *msg)
{
1999 2000 2001
    if (msg->streamTX) {
        remoteStreamMessageFinished(client, msg);
    } else if (!msg->async)
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
        client->nrequests--;

    /* See if the recv queue is currently throttled */
    if (!client->rx &&
        client->nrequests < max_client_requests) {
        /* Reset message record for next RX attempt */
        memset(msg, 0, sizeof(*msg));
        client->rx = msg;
        /* Get ready to receive next message */
        client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
    } else {
        VIR_FREE(msg);
    }

    qemudUpdateClientEvent(client);
}


2020 2021 2022 2023 2024
/*
 * Process all queued client->tx messages until
 * we would block on I/O
 */
static void
2025
qemudDispatchClientWrite(struct qemud_client *client) {
2026 2027
    while (client->tx) {
        ssize_t ret;
2028

2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
        ret = qemudClientWrite(client);
        if (ret < 0) {
            qemudDispatchClientFailure(client);
            return;
        }
        if (ret == 0)
            return; /* Would block on write EAGAIN */

        if (client->tx->bufferOffset == client->tx->bufferLength) {
            struct qemud_client_message *reply;

            /* Get finished reply from head of tx queue */
            reply = qemudClientMessageQueueServe(&client->tx);

2043
            qemudClientMessageRelease(client, reply);
2044

2045 2046
            if (client->closing)
                qemudDispatchClientFailure(client);
2047
         }
2048
    }
2049
}
2050

2051
static void
2052
qemudDispatchClientHandshake(struct qemud_client *client) {
2053 2054 2055 2056
    int ret;
    /* Continue the handshake. */
    ret = gnutls_handshake (client->tlssession);
    if (ret == 0) {
2057 2058
        client->handshake = 0;

2059 2060 2061
        /* Finished.  Next step is to check the certificate. */
        if (remoteCheckAccess (client) == -1)
            qemudDispatchClientFailure(client);
2062 2063
        else
            qemudUpdateClientEvent(client);
2064 2065 2066 2067 2068
    } else if (ret == GNUTLS_E_AGAIN ||
               ret == GNUTLS_E_INTERRUPTED) {
        /* Carry on waiting for more handshake. Update
           the events just in case handshake data flow
           direction has changed */
2069
        qemudUpdateClientEvent (client);
2070 2071 2072 2073 2074
    } else {
        /* Fatal error in handshake */
        VIR_ERROR(_("TLS handshake failed: %s"),
                  gnutls_strerror (ret));
        qemudDispatchClientFailure(client);
D
Daniel P. Berrange 已提交
2075 2076 2077
    }
}

2078
static void
2079
qemudDispatchClientEvent(int watch, int fd, int events, void *opaque) {
D
Daniel P. Berrange 已提交
2080
    struct qemud_server *server = (struct qemud_server *)opaque;
2081 2082
    struct qemud_client *client = NULL;
    int i;
2083

2084
    virMutexLock(&server->lock);
2085

2086
    for (i = 0 ; i < server->nclients ; i++) {
2087
        virMutexLock(&server->clients[i]->lock);
2088 2089
        if (server->clients[i]->watch == watch) {
            client = server->clients[i];
D
Daniel P. Berrange 已提交
2090
            break;
2091
        }
2092
        virMutexUnlock(&server->clients[i]->lock);
D
Daniel P. Berrange 已提交
2093
    }
2094

2095 2096
    virMutexUnlock(&server->lock);

2097
    if (!client) {
D
Daniel P. Berrange 已提交
2098
        return;
2099 2100
    }

2101 2102
    if (client->fd != fd) {
        virMutexUnlock(&client->lock);
2103
        return;
2104 2105 2106 2107 2108
    }

    if (events & (VIR_EVENT_HANDLE_WRITABLE |
                  VIR_EVENT_HANDLE_READABLE)) {
        if (client->handshake) {
2109
            qemudDispatchClientHandshake(client);
2110 2111
        } else {
            if (events & VIR_EVENT_HANDLE_WRITABLE)
2112
                qemudDispatchClientWrite(client);
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122
            if (events & VIR_EVENT_HANDLE_READABLE)
                qemudDispatchClientRead(server, client);
        }
    }

    /* NB, will get HANGUP + READABLE at same time upon
     * disconnect */
    if (events & (VIR_EVENT_HANDLE_ERROR |
                  VIR_EVENT_HANDLE_HANGUP))
        qemudDispatchClientFailure(client);
2123

2124
    virMutexUnlock(&client->lock);
D
Daniel P. Berrange 已提交
2125 2126
}

2127 2128 2129 2130 2131 2132

/*
 * @client: a locked client object
 */
static int
qemudCalculateHandleMode(struct qemud_client *client) {
2133 2134 2135
    int mode = 0;

    if (client->handshake) {
2136
        if (gnutls_record_get_direction (client->tlssession) == 0)
2137
            mode |= VIR_EVENT_HANDLE_READABLE;
2138
        else
2139 2140 2141 2142 2143 2144
            mode |= VIR_EVENT_HANDLE_WRITABLE;
    } else {
        /* If there is a message on the rx queue then
         * we're wanting more input */
        if (client->rx)
            mode |= VIR_EVENT_HANDLE_READABLE;
2145

2146 2147 2148 2149
        /* If there are one or more messages to send back to client,
           then monitor for writability on socket */
        if (client->tx)
            mode |= VIR_EVENT_HANDLE_WRITABLE;
2150 2151
    }

2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
    return mode;
}

/*
 * @server: a locked or unlocked server object
 * @client: a locked client object
 */
int qemudRegisterClientEvent(struct qemud_server *server,
                             struct qemud_client *client) {
    int mode;

    mode = qemudCalculateHandleMode(client);

    if ((client->watch = virEventAddHandleImpl(client->fd,
                                               mode,
                                               qemudDispatchClientEvent,
                                               server, NULL)) < 0)
        return -1;
D
Daniel P. Berrange 已提交
2170 2171 2172 2173

    return 0;
}

2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185
/*
 * @client: a locked client object
 */
void qemudUpdateClientEvent(struct qemud_client *client) {
    int mode;

    mode = qemudCalculateHandleMode(client);

    virEventUpdateHandleImpl(client->watch, mode);
}


2186
static void
2187
qemudDispatchServerEvent(int watch, int fd, int events, void *opaque) {
D
Daniel P. Berrange 已提交
2188
    struct qemud_server *server = (struct qemud_server *)opaque;
2189 2190
    struct qemud_socket *sock;

2191
    virMutexLock(&server->lock);
2192 2193

    sock = server->sockets;
D
Daniel P. Berrange 已提交
2194

D
Daniel P. Berrange 已提交
2195
    while (sock) {
2196
        if (sock->watch == watch)
D
Daniel P. Berrange 已提交
2197 2198 2199
            break;

        sock = sock->next;
D
Daniel P. Berrange 已提交
2200
    }
D
Daniel P. Berrange 已提交
2201

2202
    if (sock && sock->fd == fd && events)
D
Daniel P. Berrange 已提交
2203
        qemudDispatchServer(server, sock);
2204

2205
    virMutexUnlock(&server->lock);
D
Daniel P. Berrange 已提交
2206 2207 2208
}


2209
static int qemudOneLoop(void) {
2210
    sig_atomic_t errors;
D
Daniel P. Berrange 已提交
2211

D
Daniel P. Berrange 已提交
2212
    if (virEventRunOnce() < 0)
D
Daniel P. Berrange 已提交
2213 2214
        return -1;

2215 2216 2217
    /* Check for any signal handling errors and log them. */
    errors = sig_errors;
    if (errors) {
2218
        char ebuf[1024];
2219
        sig_errors -= errors;
2220
        VIR_ERROR(_("Signal handler reported %d errors: last error: %s"),
2221
                  errors, virStrerror (sig_lasterrno, ebuf, sizeof ebuf));
2222 2223 2224
        return -1;
    }

D
Daniel P. Berrange 已提交
2225 2226 2227
    return 0;
}

2228
static void qemudInactiveTimer(int timerid, void *data) {
2229
    struct qemud_server *server = (struct qemud_server *)data;
2230 2231 2232 2233 2234 2235 2236

    if (virStateActive() ||
        server->clients) {
        DEBUG0("Timer expired but still active, not shutting down");
        virEventUpdateTimeoutImpl(timerid, -1);
    } else {
        DEBUG0("Timer expired and inactive, shutting down");
2237
        server->quitEventThread = 1;
2238 2239 2240
    }
}

2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
static void qemudFreeClient(struct qemud_client *client) {
    while (client->rx) {
        struct qemud_client_message *msg
            = qemudClientMessageQueueServe(&client->rx);
        VIR_FREE(msg);
    }
    while (client->dx) {
        struct qemud_client_message *msg
            = qemudClientMessageQueueServe(&client->dx);
        VIR_FREE(msg);
    }
    while (client->tx) {
        struct qemud_client_message *msg
            = qemudClientMessageQueueServe(&client->tx);
        VIR_FREE(msg);
    }

2258 2259 2260
    while (client->streams)
        remoteRemoveClientStream(client, client->streams);

2261 2262 2263 2264 2265 2266
    if (client->conn)
        virConnectClose(client->conn);
    virMutexDestroy(&client->lock);
    VIR_FREE(client);
}

2267 2268
static void *qemudRunLoop(void *opaque) {
    struct qemud_server *server = opaque;
2269
    int timerid = -1;
2270
    int i;
2271
    int timerActive = 0;
2272

2273
    virMutexLock(&server->lock);
2274

2275 2276 2277 2278 2279
    if (timeout > 0 &&
        (timerid = virEventAddTimeoutImpl(-1,
                                          qemudInactiveTimer,
                                          server, NULL)) < 0) {
        VIR_ERROR0(_("Failed to register shutdown timeout"));
2280
        return NULL;
2281 2282
    }

2283 2284 2285 2286
    if (min_workers > max_workers)
        max_workers = min_workers;

    server->nworkers = max_workers;
2287
    if (VIR_ALLOC_N(server->workers, server->nworkers) < 0) {
2288
        VIR_ERROR0(_("Failed to allocate workers"));
2289
        return NULL;
2290 2291
    }

2292 2293 2294 2295
    for (i = 0 ; i < min_workers ; i++) {
        if (qemudStartWorker(server, &server->workers[i]) < 0)
            goto cleanup;
        server->nactiveworkers++;
2296
    }
2297

2298
    for (;!server->quitEventThread;) {
2299 2300 2301 2302
        /* A shutdown timeout is specified, so check
         * if any drivers have active state, if not
         * shutdown after timeout seconds
         */
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
        if (timeout > 0) {
            if (timerActive) {
                if (server->clients) {
                    DEBUG("Deactivating shutdown timer %d", timerid);
                    virEventUpdateTimeoutImpl(timerid, -1);
                    timerActive = 0;
                }
            } else {
                if (!virStateActive() &&
                    !server->clients) {
                    DEBUG("Activating shutdown timer %d", timerid);
                    virEventUpdateTimeoutImpl(timerid, timeout * 1000);
                    timerActive = 1;
                }
            }
2318 2319
        }

2320
        virMutexUnlock(&server->lock);
2321 2322
        if (qemudOneLoop() < 0) {
            virMutexLock(&server->lock);
2323
            DEBUG0("Loop iteration error, exiting");
2324
            break;
2325
        }
2326
        virMutexLock(&server->lock);
2327 2328 2329 2330

    reprocess:
        for (i = 0 ; i < server->nclients ; i++) {
            int inactive;
2331
            virMutexLock(&server->clients[i]->lock);
2332 2333
            inactive = server->clients[i]->fd == -1
                && server->clients[i]->refs == 0;
2334
            virMutexUnlock(&server->clients[i]->lock);
2335
            if (inactive) {
2336
                qemudFreeClient(server->clients[i]);
2337
                server->nclients--;
2338
                if (i < server->nclients)
2339 2340
                    memmove(server->clients + i,
                            server->clients + i + 1,
2341 2342 2343 2344 2345
                            sizeof (*server->clients) * (server->nclients - i));

                if (VIR_REALLOC_N(server->clients,
                                  server->nclients) < 0) {
                    ; /* ignore */
2346
                }
2347
                goto reprocess;
2348 2349
            }
        }
D
Daniel P. Berrange 已提交
2350

2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369
        /* If number of active workers exceeds both the min_workers
         * threshold and the number of clients, then kill some
         * off */
        for (i = 0 ; (i < server->nworkers &&
                      server->nactiveworkers > server->nclients &&
                      server->nactiveworkers > min_workers) ; i++) {

            if (server->workers[i].hasThread &&
                !server->workers[i].processingCall) {
                server->workers[i].quitRequest = 1;

                virCondBroadcast(&server->job);
                virMutexUnlock(&server->lock);
                pthread_join(server->workers[i].thread, NULL);
                virMutexLock(&server->lock);
                server->workers[i].hasThread = 0;
                server->nactiveworkers--;
            }
        }
2370 2371
    }

2372
cleanup:
2373
    for (i = 0 ; i < server->nworkers ; i++) {
2374 2375 2376 2377 2378 2379
        if (!server->workers[i].hasThread)
            continue;

        server->workers[i].quitRequest = 1;
        virCondBroadcast(&server->job);

2380
        virMutexUnlock(&server->lock);
2381
        pthread_join(server->workers[i].thread, NULL);
2382
        virMutexLock(&server->lock);
2383
        server->workers[i].hasThread = 0;
2384
    }
2385
    VIR_FREE(server->workers);
2386

2387
    virMutexUnlock(&server->lock);
2388
    return NULL;
D
Daniel P. Berrange 已提交
2389 2390
}

2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409

static int qemudStartEventLoop(struct qemud_server *server) {
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    /* We want to join the eventloop, so don't detach it */
    /*pthread_attr_setdetachstate(&attr, 1);*/

    if (pthread_create(&server->eventThread,
                       &attr,
                       qemudRunLoop,
                       server) != 0)
        return -1;

    server->hasEventThread = 1;

    return 0;
}


D
Daniel P. Berrange 已提交
2410
static void qemudCleanup(struct qemud_server *server) {
2411 2412
    struct qemud_socket *sock;

2413 2414 2415 2416
    if (server->sigread != -1)
        close(server->sigread);
    if (server->sigwrite != -1)
        close(server->sigwrite);
2417 2418

    sock = server->sockets;
D
Daniel P. Berrange 已提交
2419
    while (sock) {
2420
        struct qemud_socket *next = sock->next;
2421 2422
        if (sock->watch)
            virEventRemoveHandleImpl(sock->watch);
D
Daniel P. Berrange 已提交
2423
        close(sock->fd);
2424
        VIR_FREE(sock);
2425
        sock = next;
D
Daniel P. Berrange 已提交
2426
    }
2427
    VIR_FREE(server->logDir);
2428

2429
#ifdef HAVE_SASL
2430 2431 2432
    if (server->saslUsernameWhitelist) {
        char **list = server->saslUsernameWhitelist;
        while (*list) {
2433
            VIR_FREE(*list);
2434 2435
            list++;
        }
2436
        VIR_FREE(server->saslUsernameWhitelist);
2437
    }
2438
#endif
2439

2440 2441 2442 2443 2444
#if HAVE_POLKIT0
        if (server->sysbus)
            dbus_connection_unref(server->sysbus);
#endif

2445
    virStateCleanup();
2446

2447 2448 2449 2450 2451 2452
    if (virCondDestroy(&server->job) < 0) {
        ;
    }
    virMutexDestroy(&server->lock);

    VIR_FREE(server);
D
Daniel P. Berrange 已提交
2453 2454
}

2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
/* Allocate an array of malloc'd strings from the config file, filename
 * (used only in diagnostics), using handle "conf".  Upon error, return -1
 * and free any allocated memory.  Otherwise, save the array in *list_arg
 * and return 0.
 */
static int
remoteConfigGetStringList(virConfPtr conf, const char *key, char ***list_arg,
                          const char *filename)
{
    char **list;
    virConfValuePtr p = virConfGetValue (conf, key);
    if (!p)
        return 0;

    switch (p->type) {
    case VIR_CONF_STRING:
2471
        if (VIR_ALLOC_N(list, 2) < 0) {
2472
            VIR_ERROR(_("failed to allocate memory for %s config list"), key);
2473 2474 2475 2476 2477
            return -1;
        }
        list[0] = strdup (p->str);
        list[1] = NULL;
        if (list[0] == NULL) {
2478
            VIR_ERROR(_("failed to allocate memory for %s config list value"),
2479
                      key);
2480
            VIR_FREE(list);
2481 2482 2483 2484 2485 2486 2487 2488 2489
            return -1;
        }
        break;

    case VIR_CONF_LIST: {
        int i, len = 0;
        virConfValuePtr pp;
        for (pp = p->list; pp; pp = pp->next)
            len++;
2490
        if (VIR_ALLOC_N(list, 1+len) < 0) {
2491
            VIR_ERROR(_("failed to allocate memory for %s config list"), key);
2492 2493 2494 2495
            return -1;
        }
        for (i = 0, pp = p->list; pp; ++i, pp = pp->next) {
            if (pp->type != VIR_CONF_STRING) {
2496
                VIR_ERROR(_("remoteReadConfigFile: %s: %s:"
2497
                            " must be a string or list of strings"),
2498
                          filename, key);
2499
                VIR_FREE(list);
2500 2501 2502 2503 2504 2505
                return -1;
            }
            list[i] = strdup (pp->str);
            if (list[i] == NULL) {
                int j;
                for (j = 0 ; j < i ; j++)
2506 2507
                    VIR_FREE(list[j]);
                VIR_FREE(list);
2508 2509
                VIR_ERROR(_("failed to allocate memory for %s config list value"),
                          key);
2510 2511 2512 2513 2514 2515 2516 2517 2518
                return -1;
            }

        }
        list[i] = NULL;
        break;
    }

    default:
2519
        VIR_ERROR(_("remoteReadConfigFile: %s: %s:"
2520
                    " must be a string or list of strings"),
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534
                  filename, key);
        return -1;
    }

    *list_arg = list;
    return 0;
}

/* A helper function used by each of the following macros.  */
static int
checkType (virConfValuePtr p, const char *filename,
           const char *key, virConfType required_type)
{
    if (p->type != required_type) {
2535
        VIR_ERROR(_("remoteReadConfigFile: %s: %s: invalid type:"
2536
                    " got %s; expected %s"), filename, key,
2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555
                  virConfTypeName (p->type),
                  virConfTypeName (required_type));
        return -1;
    }
    return 0;
}

/* If there is no config data for the key, #var_name, then do nothing.
   If there is valid data of type VIR_CONF_STRING, and strdup succeeds,
   store the result in var_name.  Otherwise, (i.e. invalid type, or strdup
   failure), give a diagnostic and "goto" the cleanup-and-fail label.  */
#define GET_CONF_STR(conf, filename, var_name)                          \
    do {                                                                \
        virConfValuePtr p = virConfGetValue (conf, #var_name);          \
        if (p) {                                                        \
            if (checkType (p, filename, #var_name, VIR_CONF_STRING) < 0) \
                goto free_and_fail;                                     \
            (var_name) = strdup (p->str);                               \
            if ((var_name) == NULL) {                                   \
2556
                char ebuf[1024];                                        \
2557
                VIR_ERROR(_("remoteReadConfigFile: %s"),		\
2558
                          virStrerror(errno, ebuf, sizeof ebuf));       \
2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
                goto free_and_fail;                                     \
            }                                                           \
        }                                                               \
    } while (0)

/* Like GET_CONF_STR, but for integral values.  */
#define GET_CONF_INT(conf, filename, var_name)                          \
    do {                                                                \
        virConfValuePtr p = virConfGetValue (conf, #var_name);          \
        if (p) {                                                        \
            if (checkType (p, filename, #var_name, VIR_CONF_LONG) < 0)  \
                goto free_and_fail;                                     \
            (var_name) = p->l;                                          \
        }                                                               \
    } while (0)

2575 2576 2577 2578 2579 2580 2581 2582

static int remoteConfigGetAuth(virConfPtr conf, const char *key, int *auth, const char *filename) {
    virConfValuePtr p;

    p = virConfGetValue (conf, key);
    if (!p)
        return 0;

2583
    if (checkType (p, filename, key, VIR_CONF_STRING) < 0)
2584 2585 2586 2587 2588 2589 2590 2591 2592 2593
        return -1;

    if (!p->str)
        return 0;

    if (STREQ(p->str, "none")) {
        *auth = REMOTE_AUTH_NONE;
#if HAVE_SASL
    } else if (STREQ(p->str, "sasl")) {
        *auth = REMOTE_AUTH_SASL;
2594 2595 2596 2597
#endif
#if HAVE_POLKIT
    } else if (STREQ(p->str, "polkit")) {
        *auth = REMOTE_AUTH_POLKIT;
2598 2599
#endif
    } else {
2600
        VIR_ERROR(_("remoteReadConfigFile: %s: %s: unsupported auth %s"),
2601
                  filename, key, p->str);
2602 2603 2604 2605 2606 2607
        return -1;
    }

    return 0;
}

2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
#ifdef HAVE_SASL
static inline int
remoteReadSaslAllowedUsernameList (virConfPtr conf,
                                   struct qemud_server *server,
                                   const char *filename)
{
    return
        remoteConfigGetStringList (conf, "sasl_allowed_username_list",
                                   &server->saslUsernameWhitelist, filename);
}
#else
static inline int
remoteReadSaslAllowedUsernameList (virConfPtr conf ATTRIBUTE_UNUSED,
                                   struct qemud_server *server ATTRIBUTE_UNUSED,
                                   const char *filename ATTRIBUTE_UNUSED)
{
    return 0;
}
#endif

2628 2629 2630 2631 2632 2633
/*
 * Set up the logging environment
 * By default if daemonized all errors go to syslog and the logging
 * is also saved onto the logfile libvird.log, but if verbose or error
 * debugging is asked for then output informations or debug.
 */
2634
static int
2635 2636 2637
qemudSetLogging(virConfPtr conf, const char *filename)
{
    int log_level = 0;
2638 2639
    char *log_filters = NULL;
    char *log_outputs = NULL;
2640 2641
    int ret = -1;

2642 2643
    virLogReset();

2644
    /*
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
     * Libvirtd's order of precedence is:
     * cmdline > environment > config
     *
     * In order to achieve this, we must process configuration in
     * different order for the log level versus the filters and
     * outputs. Because filters and outputs append, we have to look at
     * the environment first and then only check the config file if
     * there was no result from the environment. The default output is
     * then applied only if there was no setting from either of the
     * first two. Because we don't have a way to determine if the log
     * level has been set, we must process variables in the opposite
     * order, each one overriding the previous.
2657
     */
2658
    GET_CONF_INT (conf, filename, log_level);
2659 2660 2661
    if (log_level != 0)
        virLogSetDefaultPriority(log_level);

2662
    virLogSetFromEnv();
2663 2664 2665 2666

    if (virLogGetNbFilters() == 0) {
        GET_CONF_STR (conf, filename, log_filters);
        virLogParseFilters(log_filters);
2667
    }
2668

2669 2670 2671
    if (virLogGetNbOutputs() == 0) {
        GET_CONF_STR (conf, filename, log_outputs);
        virLogParseOutputs(log_outputs);
2672
    }
2673 2674

    /*
2675 2676
     * If no defined outputs, then direct to syslog when running
     * as daemon. Otherwise the default output is stderr.
2677
     */
2678
    if (virLogGetNbOutputs() == 0) {
2679
        char *tmp = NULL;
2680
        if (godaemon) {
2681 2682
            if (virAsprintf (&tmp, "%d:syslog:libvirtd",
                             virLogGetDefaultPriority()) < 0)
2683 2684
                goto free_and_fail;
        } else {
2685 2686
            if (virAsprintf (&tmp, "%d:stderr",
                             virLogGetDefaultPriority()) < 0)
2687
                goto free_and_fail;
2688
        }
2689 2690
        virLogParseOutputs(tmp);
        VIR_FREE(tmp);
2691
    }
2692 2693 2694 2695 2696 2697 2698

    /*
     * Command line override for --verbose
     */
    if ((verbose) && (virLogGetDefaultPriority() > VIR_LOG_INFO))
        virLogSetDefaultPriority(VIR_LOG_INFO);

2699 2700
    ret = 0;

2701 2702 2703
free_and_fail:
    VIR_FREE(log_filters);
    VIR_FREE(log_outputs);
2704
    return(ret);
2705
}
2706

2707 2708 2709 2710
/* Read the config file if it exists.
 * Only used in the remote case, hence the name.
 */
static int
2711
remoteReadConfigFile (struct qemud_server *server, const char *filename)
2712 2713 2714
{
    virConfPtr conf;

2715 2716 2717 2718 2719
    /* The following variable names must match the corresponding
       configuration strings.  */
    char *unix_sock_ro_perms = NULL;
    char *unix_sock_rw_perms = NULL;
    char *unix_sock_group = NULL;
2720
    char *buf = NULL;
2721

2722 2723
#if HAVE_POLKIT
    /* Change the default back to no auth for non-root */
2724
    if (!server->privileged && auth_unix_rw == REMOTE_AUTH_POLKIT)
2725
        auth_unix_rw = REMOTE_AUTH_NONE;
2726
    if (!server->privileged && auth_unix_ro == REMOTE_AUTH_POLKIT)
2727 2728 2729
        auth_unix_ro = REMOTE_AUTH_NONE;
#endif

2730
    conf = virConfReadFile (filename, 0);
2731
    if (!conf) return -1;
2732

2733 2734 2735
    /*
     * First get all the logging settings and activate them
     */
2736 2737
    if (qemudSetLogging(conf, filename) < 0)
        goto free_and_fail;
2738

2739 2740
    GET_CONF_INT (conf, filename, listen_tcp);
    GET_CONF_INT (conf, filename, listen_tls);
2741 2742
    GET_CONF_STR (conf, filename, tls_port);
    GET_CONF_STR (conf, filename, tcp_port);
2743
    GET_CONF_STR (conf, filename, listen_addr);
J
Jim Meyering 已提交
2744

2745
    if (remoteConfigGetAuth(conf, "auth_unix_rw", &auth_unix_rw, filename) < 0)
J
Jim Meyering 已提交
2746
        goto free_and_fail;
2747 2748 2749 2750 2751 2752 2753
#if HAVE_POLKIT
    /* Change default perms to be wide-open if PolicyKit is enabled.
     * Admin can always override in config file
     */
    if (auth_unix_rw == REMOTE_AUTH_POLKIT)
        unix_sock_rw_mask = 0777;
#endif
2754
    if (remoteConfigGetAuth(conf, "auth_unix_ro", &auth_unix_ro, filename) < 0)
J
Jim Meyering 已提交
2755
        goto free_and_fail;
2756
    if (remoteConfigGetAuth(conf, "auth_tcp", &auth_tcp, filename) < 0)
J
Jim Meyering 已提交
2757
        goto free_and_fail;
2758
    if (remoteConfigGetAuth(conf, "auth_tls", &auth_tls, filename) < 0)
J
Jim Meyering 已提交
2759
        goto free_and_fail;
2760

2761 2762
    GET_CONF_STR (conf, filename, unix_sock_group);
    if (unix_sock_group) {
2763
        if (!server->privileged) {
2764
            VIR_WARN0("Cannot set group when not running as root");
2765
        } else {
2766
            int ret;
2767
            struct group grpdata, *grp;
2768 2769 2770 2771 2772 2773
            size_t maxbuf = sysconf(_SC_GETGR_R_SIZE_MAX);

            if (maxbuf == -1)
                maxbuf = 1024;

            if (VIR_ALLOC_N(buf, maxbuf) < 0) {
2774
                VIR_ERROR0(_("Failed to allocate memory for buffer"));
2775 2776 2777 2778 2779 2780 2781 2782
                goto free_and_fail;
            }

            while ((ret = getgrnam_r(unix_sock_group, &grpdata,
                                     buf, maxbuf,
                                     &grp)) == ERANGE) {
                    maxbuf *= 2;
                    if (maxbuf > 65536 || VIR_REALLOC_N(buf, maxbuf) < 0) {
2783
                        VIR_ERROR0(_("Failed to reallocate enough memory for buffer"));
2784 2785 2786 2787 2788
                        goto free_and_fail;
                    }
            }

            if (ret != 0 || !grp) {
2789
                VIR_ERROR(_("Failed to lookup group '%s'"), unix_sock_group);
2790
                goto free_and_fail;
2791 2792
            }
            unix_sock_gid = grp->gr_gid;
2793
            VIR_FREE(buf);
2794
        }
2795
        VIR_FREE(unix_sock_group);
2796 2797
    }

2798 2799
    GET_CONF_STR (conf, filename, unix_sock_ro_perms);
    if (unix_sock_ro_perms) {
2800
        if (virStrToLong_i (unix_sock_ro_perms, NULL, 8, &unix_sock_ro_mask) != 0) {
2801
            VIR_ERROR(_("Failed to parse mode '%s'"), unix_sock_ro_perms);
2802
            goto free_and_fail;
2803
        }
2804
        VIR_FREE(unix_sock_ro_perms);
2805 2806
    }

2807 2808
    GET_CONF_STR (conf, filename, unix_sock_rw_perms);
    if (unix_sock_rw_perms) {
2809
        if (virStrToLong_i (unix_sock_rw_perms, NULL, 8, &unix_sock_rw_mask) != 0) {
2810
            VIR_ERROR(_("Failed to parse mode '%s'"), unix_sock_rw_perms);
2811
            goto free_and_fail;
2812
        }
2813
        VIR_FREE(unix_sock_rw_perms);
2814 2815
    }

2816 2817
    GET_CONF_STR (conf, filename, unix_sock_dir);

2818 2819
    GET_CONF_INT (conf, filename, mdns_adv);
    GET_CONF_STR (conf, filename, mdns_name);
2820

2821
    GET_CONF_INT (conf, filename, tls_no_verify_certificate);
2822

2823 2824 2825 2826
    GET_CONF_STR (conf, filename, key_file);
    GET_CONF_STR (conf, filename, cert_file);
    GET_CONF_STR (conf, filename, ca_file);
    GET_CONF_STR (conf, filename, crl_file);
2827

2828 2829 2830
    if (remoteConfigGetStringList (conf, "tls_allowed_dn_list",
                                   &tls_allowed_dn_list, filename) < 0)
        goto free_and_fail;
2831

2832
    if (remoteReadSaslAllowedUsernameList (conf, server, filename) < 0)
2833
        goto free_and_fail;
2834

2835 2836 2837 2838 2839

    GET_CONF_INT (conf, filename, min_workers);
    GET_CONF_INT (conf, filename, max_workers);
    GET_CONF_INT (conf, filename, max_clients);

2840 2841 2842
    GET_CONF_INT (conf, filename, max_requests);
    GET_CONF_INT (conf, filename, max_client_requests);

2843 2844
    virConfFree (conf);
    return 0;
2845

2846 2847
 free_and_fail:
    virConfFree (conf);
2848 2849 2850 2851 2852
    VIR_FREE(mdns_name);
    VIR_FREE(unix_sock_ro_perms);
    VIR_FREE(unix_sock_rw_perms);
    VIR_FREE(unix_sock_group);
    VIR_FREE(buf);
2853

2854 2855 2856 2857
    /* Don't bother trying to free listen_addr, tcp_port, tls_port, key_file,
       cert_file, ca_file, or crl_file, since they are initialized to
       non-malloc'd strings.  Besides, these are static variables, and callers
       are unlikely to call this function more than once, so there wouldn't
2858 2859 2860 2861 2862
       even be a real leak.  */

    if (tls_allowed_dn_list) {
        int i;
        for (i = 0; tls_allowed_dn_list[i]; i++)
2863 2864
            VIR_FREE(tls_allowed_dn_list[i]);
        VIR_FREE(tls_allowed_dn_list);
2865 2866 2867
    }

    return -1;
2868 2869
}

2870 2871
/* Display version information. */
static void
2872
version (void)
2873 2874 2875 2876
{
    printf ("%s (%s) %s\n", argv0, PACKAGE_NAME, PACKAGE_VERSION);
}

J
John Levon 已提交
2877 2878 2879 2880 2881 2882 2883 2884
#ifdef __sun
static int
qemudSetupPrivs (void)
{
    chown ("/var/run/libvirt", SYSTEM_UID, SYSTEM_UID);

    if (__init_daemon_priv (PU_RESETGROUPS | PU_CLEARLIMITSET,
        SYSTEM_UID, SYSTEM_UID, PRIV_XVM_CONTROL, NULL)) {
2885
        VIR_ERROR0(_("additional privileges are required"));
J
John Levon 已提交
2886 2887 2888 2889 2890
        return -1;
    }

    if (priv_set (PRIV_OFF, PRIV_ALLSETS, PRIV_FILE_LINK_ANY, PRIV_PROC_INFO,
        PRIV_PROC_SESSION, PRIV_PROC_EXEC, PRIV_PROC_FORK, NULL)) {
2891
        VIR_ERROR0(_("failed to set reduced privileges"));
J
John Levon 已提交
2892 2893 2894 2895 2896 2897
        return -1;
    }

    return 0;
}
#else
2898
# define qemudSetupPrivs() 0
J
John Levon 已提交
2899 2900
#endif

2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961

/*
 * Doing anything non-trivial in signal handlers is pretty dangerous,
 * since there are very few async-signal safe POSIX funtions. To
 * deal with this we setup a very simple signal handler. It simply
 * writes the signal number to a pipe. The main event loop then sees
 * the signal on the pipe and can safely do the processing from
 * event loop context
 */
static int
daemonSetupSignals(struct qemud_server *server)
{
    struct sigaction sig_action;
    int sigpipe[2];

    if (pipe(sigpipe) < 0)
        return -1;

    if (virSetNonBlock(sigpipe[0]) < 0 ||
        virSetNonBlock(sigpipe[1]) < 0 ||
        virSetCloseExec(sigpipe[0]) < 0 ||
        virSetCloseExec(sigpipe[1]) < 0) {
        char ebuf[1024];
        VIR_ERROR(_("Failed to create pipe: %s"),
                  virStrerror(errno, ebuf, sizeof ebuf));
        goto error;
    }

    sig_action.sa_sigaction = sig_handler;
    sig_action.sa_flags = SA_SIGINFO;
    sigemptyset(&sig_action.sa_mask);

    sigaction(SIGHUP, &sig_action, NULL);
    sigaction(SIGINT, &sig_action, NULL);
    sigaction(SIGQUIT, &sig_action, NULL);
    sigaction(SIGTERM, &sig_action, NULL);
    sigaction(SIGCHLD, &sig_action, NULL);

    sig_action.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &sig_action, NULL);

    if (virEventAddHandleImpl(sigpipe[0],
                              VIR_EVENT_HANDLE_READABLE,
                              qemudDispatchSignalEvent,
                              server, NULL) < 0) {
        VIR_ERROR0(_("Failed to register callback for signal pipe"));
        goto error;
    }

    server->sigread = sigpipe[0];
    server->sigwrite = sigpipe[1];
    sigwrite = sigpipe[1];

    return 0;

error:
    close(sigpipe[0]);
    close(sigpipe[1]);
    return -1;
}

2962 2963
/* Print command-line usage. */
static void
2964
usage (void)
2965 2966
{
    fprintf (stderr,
2967
             _("\n\
2968 2969 2970 2971 2972 2973
Usage:\n\
  %s [options]\n\
\n\
Options:\n\
  -v | --verbose         Verbose messages.\n\
  -d | --daemon          Run as a daemon & write PID file.\n\
2974 2975
  -l | --listen          Listen for TCP/IP connections.\n\
  -t | --timeout <secs>  Exit after timeout period.\n\
2976
  -f | --config <file>   Configuration file.\n\
2977
     | --version         Display version information.\n\
2978 2979
  -p | --pid-file <file> Change name of PID file.\n\
\n\
2980
libvirt management daemon:\n\
2981 2982 2983
\n\
  Default paths:\n\
\n\
W
Wolfgang Mauerer 已提交
2984
    Configuration file (unless overridden by -f):\n\
2985
      %s/libvirt/libvirtd.conf\n\
2986
\n\
2987
    Sockets (as root):\n\
2988 2989
      %s/run/libvirt/libvirt-sock\n\
      %s/run/libvirt/libvirt-sock-ro\n\
2990 2991 2992
\n\
    Sockets (as non-root):\n\
      $HOME/.libvirt/libvirt-sock (in UNIX abstract namespace)\n\
2993 2994
\n\
    TLS:\n\
2995 2996 2997
      CA certificate:     %s\n\
      Server certificate: %s\n\
      Server private key: %s\n\
2998 2999 3000
\n\
    PID file (unless overridden by --pid-file):\n\
      %s\n\
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
\n"),
               argv0,
               SYSCONF_DIR,
               LOCAL_STATE_DIR,
               LOCAL_STATE_DIR,
               LIBVIRT_CACERT,
               LIBVIRT_SERVERCERT,
               LIBVIRT_SERVERKEY,
               (REMOTE_PID_FILE[0] != '\0'
                ? REMOTE_PID_FILE
                : _("(disabled in ./configure)")));
3012 3013
}

3014 3015 3016 3017
enum {
    OPT_VERSION = 129
};

D
Daniel P. Berrange 已提交
3018 3019
#define MAX_LISTEN 5
int main(int argc, char **argv) {
3020
    struct qemud_server *server = NULL;
3021
    const char *pid_file = NULL;
3022
    const char *remote_config_file = NULL;
3023
    int statuswrite = -1;
3024
    int ret = 1;
3025
    argv0 = argv[0];
D
Daniel P. Berrange 已提交
3026 3027 3028 3029

    struct option opts[] = {
        { "verbose", no_argument, &verbose, 1},
        { "daemon", no_argument, &godaemon, 1},
3030
        { "listen", no_argument, &ipsock, 1},
3031
        { "config", required_argument, NULL, 'f'},
3032 3033
        { "timeout", required_argument, NULL, 't'},
        { "pid-file", required_argument, NULL, 'p'},
3034
        { "version", no_argument, NULL, OPT_VERSION },
3035
        { "help", no_argument, NULL, '?' },
D
Daniel P. Berrange 已提交
3036 3037 3038
        {0, 0, 0, 0}
    };

3039
    if (virInitialize() < 0) {
3040
        fprintf (stderr, _("%s: initialization failed\n"), argv0);
3041 3042
        exit (EXIT_FAILURE);
    }
D
Daniel P. Berrange 已提交
3043

D
Daniel P. Berrange 已提交
3044 3045 3046 3047 3048
    while (1) {
        int optidx = 0;
        int c;
        char *tmp;

3049
        c = getopt_long(argc, argv, "ldf:p:t:v", opts, &optidx);
D
Daniel P. Berrange 已提交
3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064

        if (c == -1) {
            break;
        }

        switch (c) {
        case 0:
            /* Got one of the flags */
            break;
        case 'v':
            verbose = 1;
            break;
        case 'd':
            godaemon = 1;
            break;
3065 3066
        case 'l':
            ipsock = 1;
D
Daniel P. Berrange 已提交
3067 3068 3069
            break;

        case 't':
3070
            if (virStrToLong_i(optarg, &tmp, 10, &timeout) != 0
3071 3072 3073
                || timeout <= 0
                /* Ensure that we can multiply by 1000 without overflowing.  */
                || timeout > INT_MAX / 1000)
D
Daniel P. Berrange 已提交
3074 3075
                timeout = -1;
            break;
3076 3077

        case 'p':
3078 3079 3080 3081 3082
            pid_file = optarg;
            break;

        case 'f':
            remote_config_file = optarg;
3083 3084
            break;

3085
        case OPT_VERSION:
3086
            version ();
3087 3088
            return 0;

D
Daniel P. Berrange 已提交
3089
        case '?':
3090
            usage ();
D
Daniel P. Berrange 已提交
3091 3092 3093
            return 2;

        default:
3094 3095
            fprintf (stderr, _("%s: internal error: unknown flag: %c\n"),
                     argv0, c);
3096
            exit (EXIT_FAILURE);
D
Daniel P. Berrange 已提交
3097 3098 3099
        }
    }

3100 3101 3102 3103
    if (remote_config_file == NULL) {
        static const char *default_config_file
            = SYSCONF_DIR "/libvirt/libvirtd.conf";
        remote_config_file =
3104
            (access(default_config_file, R_OK) == 0
3105 3106 3107 3108
             ? default_config_file
             : "/dev/null");
    }

3109
    if (godaemon) {
3110
        char ebuf[1024];
3111
        if ((statuswrite = daemonForkIntoBackground()) < 0) {
3112 3113
            VIR_ERROR(_("Failed to fork as daemon: %s"),
                      virStrerror(errno, ebuf, sizeof ebuf));
3114
            goto error;
3115 3116 3117 3118 3119
        }
    }

    /* If running as root and no PID file is set, use the default */
    if (pid_file == NULL &&
3120
        geteuid() == 0 &&
3121 3122 3123 3124 3125
        REMOTE_PID_FILE[0] != '\0')
        pid_file = REMOTE_PID_FILE;

    /* If we have a pidfile set, claim it now, exiting if already taken */
    if (pid_file != NULL &&
3126 3127 3128
        qemudWritePidFile (pid_file) < 0) {
        pid_file = NULL; /* Prevent unlinking of someone else's pid ! */
        ret = VIR_DAEMON_ERR_PIDFILE;
3129
        goto error;
3130
    }
3131

J
John Levon 已提交
3132
    /* Ensure the rundir exists (on tmpfs on some systems) */
3133
    if (geteuid() == 0) {
J
John Levon 已提交
3134 3135 3136 3137
        const char *rundir = LOCAL_STATE_DIR "/run/libvirt";

        if (mkdir (rundir, 0755)) {
            if (errno != EEXIST) {
3138 3139 3140
                char ebuf[1024];
                VIR_ERROR(_("unable to create rundir %s: %s"), rundir,
                          virStrerror(errno, ebuf, sizeof(ebuf)));
3141 3142
                ret = VIR_DAEMON_ERR_RUNDIR;
                goto error;
J
John Levon 已提交
3143 3144 3145 3146
            }
        }
    }

3147 3148 3149 3150 3151 3152
    /* Beyond this point, nothing should rely on using
     * getuid/geteuid() == 0, for privilege level checks.
     * It must all use the flag 'server->privileged'
     * which is also passed into all libvirt stateful
     * drivers
     */
3153 3154
    if (qemudSetupPrivs() < 0) {
        ret = VIR_DAEMON_ERR_PRIVS;
3155
        goto error;
3156
    }
J
John Levon 已提交
3157

3158
    if (!(server = qemudInitialize())) {
3159
        ret = VIR_DAEMON_ERR_INIT;
3160
        goto error;
3161
    }
3162

3163 3164
    if ((daemonSetupSignals(server)) < 0) {
        ret = VIR_DAEMON_ERR_SIGNAL;
3165
        goto error;
3166
    }
3167

3168
    /* Read the config file (if it exists). */
3169 3170
    if (remoteReadConfigFile (server, remote_config_file) < 0) {
        ret = VIR_DAEMON_ERR_CONFIG;
3171
        goto error;
3172
    }
D
Daniel P. Berrange 已提交
3173

3174
    /* setup the hooks if any */
3175
    if (virHookInitialize() < 0) {
3176 3177 3178 3179
        ret = VIR_DAEMON_ERR_HOOKS;
        goto error;
    }

3180 3181 3182
    /* Disable error func, now logging is setup */
    virSetErrorFunc(NULL, virshErrorHandler);

3183 3184 3185 3186 3187 3188 3189 3190
    /*
     * Call the daemon startup hook
     * TODO: should we abort the daemon startup if the script returned
     *       an error ?
     */
    virHookCall(VIR_HOOK_DRIVER_DAEMON, "-", VIR_HOOK_DAEMON_OP_START,
                0, "start", NULL);

3191
    if (qemudNetworkInit(server) < 0) {
3192
        ret = VIR_DAEMON_ERR_NETWORK;
3193
        goto error;
3194 3195
    }

3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
    /* Tell parent of daemon that basic initialization is complete
     * In particular we're ready to accept net connections & have
     * written the pidfile
     */
    if (statuswrite != -1) {
        char status = 0;
        while (write(statuswrite, &status, 1) == -1 &&
               errno == EINTR)
            ;
        close(statuswrite);
        statuswrite = -1;
    }

3209 3210 3211
    /* Start the event loop in a background thread, since
     * state initialization needs events to be being processed */
    if (qemudStartEventLoop(server) < 0) {
3212
        VIR_ERROR0(_("Event thread startup failed"));
3213 3214 3215
        goto error;
    }

3216 3217 3218 3219 3220
    /* Start the stateful HV drivers
     * This is delibrately done after telling the parent process
     * we're ready, since it can take a long time and this will
     * seriously delay OS bootup process */
    if (virStateInitialize(server->privileged) < 0) {
3221
        VIR_ERROR0(_("Driver state initialization failed"));
3222
        goto shutdown;
3223
    }
D
Daniel P. Berrange 已提交
3224

3225 3226 3227
    /* Start accepting new clients from network */
    virMutexLock(&server->lock);
    if (qemudNetworkEnable(server) < 0) {
3228
        VIR_ERROR0(_("Network event loop enablement failed"));
3229 3230 3231 3232
        goto shutdown;
    }
    virMutexUnlock(&server->lock);

3233 3234
    ret = 0;

3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
shutdown:
    /* In a non-0 shutdown scenario we need to tell event loop
     * to quit immediately. Otherwise in normal case we just
     * sit in the thread join forever. Sure this means the
     * main thread doesn't do anything useful ever, but that's
     * not too much of drain on resources
     */
    if (ret != 0) {
        virMutexLock(&server->lock);
        if (server->hasEventThread)
            /* This SIGQUIT triggers the shutdown process */
            kill(getpid(), SIGQUIT);
        virMutexUnlock(&server->lock);
    }
    pthread_join(server->eventThread, NULL);

3251 3252 3253
    virHookCall(VIR_HOOK_DRIVER_DAEMON, "-", VIR_HOOK_DAEMON_OP_SHUTDOWN,
                0, "shutdown", NULL);

3254
error:
3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
    if (statuswrite != -1) {
        if (ret != 0) {
            /* Tell parent of daemon what failed */
            char status = ret;
            while (write(statuswrite, &status, 1) == -1 &&
                   errno == EINTR)
                ;
        }
        close(statuswrite);
    }
3265 3266
    if (server)
        qemudCleanup(server);
3267 3268
    if (pid_file)
        unlink (pid_file);
3269
    virLogShutdown();
3270
    return ret;
D
Daniel P. Berrange 已提交
3271
}