~ubuntu-branches/ubuntu/quantal/libvirt/quantal

« back to all changes in this revision

Viewing changes to .pc/netcf-daemon-fix-wrong-macro-name/daemon/libvirtd.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2012-08-08 07:54:16 UTC
  • Revision ID: package-import@ubuntu.com-20120808075416-ydw40hvvliag1bjb
Tags: 0.9.13-0ubuntu6
* enable netcf support (LP: #520386)
  - debian/control: build-dep on libnetcf-dev
  - debian/rules: add --with-netcf to configure args
* add patch netcf-daemon-fix-wrong-macro-name from upstream so netcf support
  can actually work.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * libvirtd.c: daemon start of day, guest process & i/o management
 
3
 *
 
4
 * Copyright (C) 2006-2012 Red Hat, Inc.
 
5
 * Copyright (C) 2006 Daniel P. Berrange
 
6
 *
 
7
 * This library is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU Lesser General Public
 
9
 * License as published by the Free Software Foundation; either
 
10
 * version 2.1 of the License, or (at your option) any later version.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with this library; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 
20
 *
 
21
 * Author: Daniel P. Berrange <berrange@redhat.com>
 
22
 */
 
23
 
 
24
#include <config.h>
 
25
 
 
26
#include <unistd.h>
 
27
#include <fcntl.h>
 
28
#include <sys/wait.h>
 
29
#include <sys/stat.h>
 
30
#include <getopt.h>
 
31
#include <stdlib.h>
 
32
#include <grp.h>
 
33
#include <locale.h>
 
34
 
 
35
#include "libvirt_internal.h"
 
36
#include "virterror_internal.h"
 
37
#include "virfile.h"
 
38
#include "virpidfile.h"
 
39
 
 
40
#define VIR_FROM_THIS VIR_FROM_QEMU
 
41
 
 
42
#include "libvirtd.h"
 
43
#include "libvirtd-config.h"
 
44
 
 
45
#include "util.h"
 
46
#include "uuid.h"
 
47
#include "remote_driver.h"
 
48
#include "memory.h"
 
49
#include "conf.h"
 
50
#include "virnetlink.h"
 
51
#include "virnetserver.h"
 
52
#include "threads.h"
 
53
#include "remote.h"
 
54
#include "remote_driver.h"
 
55
#include "hooks.h"
 
56
#include "uuid.h"
 
57
#include "viraudit.h"
 
58
 
 
59
#ifdef WITH_DRIVER_MODULES
 
60
# include "driver.h"
 
61
#else
 
62
# ifdef WITH_QEMU
 
63
#  include "qemu/qemu_driver.h"
 
64
# endif
 
65
# ifdef WITH_LXC
 
66
#  include "lxc/lxc_driver.h"
 
67
# endif
 
68
# ifdef WITH_LIBXL
 
69
#  include "libxl/libxl_driver.h"
 
70
# endif
 
71
# ifdef WITH_UML
 
72
#  include "uml/uml_driver.h"
 
73
# endif
 
74
# ifdef WITH_NETWORK
 
75
#  include "network/bridge_driver.h"
 
76
# endif
 
77
# ifdef WITH_NETCF
 
78
#  include "interface/netcf_driver.h"
 
79
# endif
 
80
# ifdef WITH_STORAGE
 
81
#  include "storage/storage_driver.h"
 
82
# endif
 
83
# ifdef WITH_NODE_DEVICES
 
84
#  include "node_device/node_device_driver.h"
 
85
# endif
 
86
# ifdef WITH_SECRETS
 
87
#  include "secret/secret_driver.h"
 
88
# endif
 
89
# ifdef WITH_NWFILTER
 
90
#  include "nwfilter/nwfilter_driver.h"
 
91
# endif
 
92
#endif
 
93
 
 
94
#include "configmake.h"
 
95
 
 
96
#if HAVE_SASL
 
97
virNetSASLContextPtr saslCtxt = NULL;
 
98
#endif
 
99
virNetServerProgramPtr remoteProgram = NULL;
 
100
virNetServerProgramPtr qemuProgram = NULL;
 
101
 
 
102
enum {
 
103
    VIR_DAEMON_ERR_NONE = 0,
 
104
    VIR_DAEMON_ERR_PIDFILE,
 
105
    VIR_DAEMON_ERR_RUNDIR,
 
106
    VIR_DAEMON_ERR_INIT,
 
107
    VIR_DAEMON_ERR_SIGNAL,
 
108
    VIR_DAEMON_ERR_PRIVS,
 
109
    VIR_DAEMON_ERR_NETWORK,
 
110
    VIR_DAEMON_ERR_CONFIG,
 
111
    VIR_DAEMON_ERR_HOOKS,
 
112
    VIR_DAEMON_ERR_AUDIT,
 
113
 
 
114
    VIR_DAEMON_ERR_LAST
 
115
};
 
116
 
 
117
VIR_ENUM_DECL(virDaemonErr)
 
118
VIR_ENUM_IMPL(virDaemonErr, VIR_DAEMON_ERR_LAST,
 
119
              "Initialization successful",
 
120
              "Unable to obtain pidfile",
 
121
              "Unable to create rundir",
 
122
              "Unable to initialize libvirt",
 
123
              "Unable to setup signal handlers",
 
124
              "Unable to drop privileges",
 
125
              "Unable to initialize network sockets",
 
126
              "Unable to load configuration file",
 
127
              "Unable to look for hook scripts",
 
128
              "Unable to initialize audit system")
 
129
 
 
130
static int daemonForkIntoBackground(const char *argv0)
 
131
{
 
132
    int statuspipe[2];
 
133
    if (pipe(statuspipe) < 0)
 
134
        return -1;
 
135
 
 
136
    pid_t pid = fork();
 
137
    switch (pid) {
 
138
    case 0:
 
139
        {
 
140
            /* intermediate child */
 
141
            int stdinfd = -1;
 
142
            int stdoutfd = -1;
 
143
            int nextpid;
 
144
 
 
145
            VIR_FORCE_CLOSE(statuspipe[0]);
 
146
 
 
147
            if ((stdinfd = open("/dev/null", O_RDONLY)) < 0)
 
148
                goto cleanup;
 
149
            if ((stdoutfd = open("/dev/null", O_WRONLY)) < 0)
 
150
                goto cleanup;
 
151
            if (dup2(stdinfd, STDIN_FILENO) != STDIN_FILENO)
 
152
                goto cleanup;
 
153
            if (dup2(stdoutfd, STDOUT_FILENO) != STDOUT_FILENO)
 
154
                goto cleanup;
 
155
            if (dup2(stdoutfd, STDERR_FILENO) != STDERR_FILENO)
 
156
                goto cleanup;
 
157
            if (stdinfd > STDERR_FILENO && VIR_CLOSE(stdinfd) < 0)
 
158
                goto cleanup;
 
159
            if (stdoutfd > STDERR_FILENO && VIR_CLOSE(stdoutfd) < 0)
 
160
                goto cleanup;
 
161
 
 
162
            if (setsid() < 0)
 
163
                goto cleanup;
 
164
 
 
165
            nextpid = fork();
 
166
            switch (nextpid) {
 
167
            case 0: /* grandchild */
 
168
                return statuspipe[1];
 
169
            case -1: /* error */
 
170
                goto cleanup;
 
171
            default: /* intermediate child succeeded */
 
172
                _exit(EXIT_SUCCESS);
 
173
            }
 
174
 
 
175
        cleanup:
 
176
            VIR_FORCE_CLOSE(stdoutfd);
 
177
            VIR_FORCE_CLOSE(stdinfd);
 
178
            VIR_FORCE_CLOSE(statuspipe[1]);
 
179
            _exit(EXIT_FAILURE);
 
180
 
 
181
        }
 
182
 
 
183
    case -1: /* error in parent */
 
184
        goto error;
 
185
 
 
186
    default:
 
187
        {
 
188
            /* parent */
 
189
            int ret;
 
190
            char status;
 
191
 
 
192
            VIR_FORCE_CLOSE(statuspipe[1]);
 
193
 
 
194
            /* We wait to make sure the first child forked successfully */
 
195
            if (virPidWait(pid, NULL) < 0)
 
196
                goto error;
 
197
 
 
198
            /* If we get here, then the grandchild was spawned, so we
 
199
             * must exit.  Block until the second child initializes
 
200
             * successfully */
 
201
        again:
 
202
            ret = read(statuspipe[0], &status, 1);
 
203
            if (ret == -1 && errno == EINTR)
 
204
                goto again;
 
205
 
 
206
            VIR_FORCE_CLOSE(statuspipe[0]);
 
207
 
 
208
            if (ret != 1) {
 
209
                char ebuf[1024];
 
210
 
 
211
                fprintf(stderr,
 
212
                        _("%s: error: unable to determine if daemon is "
 
213
                          "running: %s\n"), argv0,
 
214
                        virStrerror(errno, ebuf, sizeof(ebuf)));
 
215
                exit(EXIT_FAILURE);
 
216
            } else if (status != 0) {
 
217
                fprintf(stderr,
 
218
                        _("%s: error: %s. Check /var/log/messages or run "
 
219
                          "without --daemon for more info.\n"), argv0,
 
220
                        virDaemonErrTypeToString(status));
 
221
                exit(EXIT_FAILURE);
 
222
            }
 
223
            _exit(EXIT_SUCCESS);
 
224
        }
 
225
    }
 
226
 
 
227
error:
 
228
    VIR_FORCE_CLOSE(statuspipe[0]);
 
229
    VIR_FORCE_CLOSE(statuspipe[1]);
 
230
    return -1;
 
231
}
 
232
 
 
233
 
 
234
static int
 
235
daemonPidFilePath(bool privileged,
 
236
                  char **pidfile)
 
237
{
 
238
    if (privileged) {
 
239
        if (!(*pidfile = strdup(LOCALSTATEDIR "/run/libvirtd.pid")))
 
240
            goto no_memory;
 
241
    } else {
 
242
        char *rundir = NULL;
 
243
        mode_t old_umask;
 
244
 
 
245
        if (!(rundir = virGetUserRuntimeDirectory()))
 
246
            goto error;
 
247
 
 
248
        old_umask = umask(077);
 
249
        if (virFileMakePath(rundir) < 0) {
 
250
            umask(old_umask);
 
251
            goto error;
 
252
        }
 
253
        umask(old_umask);
 
254
 
 
255
        if (virAsprintf(pidfile, "%s/libvirtd.pid", rundir) < 0) {
 
256
            VIR_FREE(rundir);
 
257
            goto no_memory;
 
258
        }
 
259
 
 
260
        VIR_FREE(rundir);
 
261
    }
 
262
 
 
263
    return 0;
 
264
 
 
265
no_memory:
 
266
    virReportOOMError();
 
267
error:
 
268
    return -1;
 
269
}
 
270
 
 
271
static int
 
272
daemonUnixSocketPaths(struct daemonConfig *config,
 
273
                      bool privileged,
 
274
                      char **sockfile,
 
275
                      char **rosockfile)
 
276
{
 
277
    if (config->unix_sock_dir) {
 
278
        if (virAsprintf(sockfile, "%s/libvirt-sock", config->unix_sock_dir) < 0)
 
279
            goto no_memory;
 
280
        if (privileged &&
 
281
            virAsprintf(rosockfile, "%s/libvirt-sock-ro", config->unix_sock_dir) < 0)
 
282
            goto no_memory;
 
283
    } else {
 
284
        if (privileged) {
 
285
            if (!(*sockfile = strdup(LOCALSTATEDIR "/run/libvirt/libvirt-sock")))
 
286
                goto no_memory;
 
287
            if (!(*rosockfile = strdup(LOCALSTATEDIR "/run/libvirt/libvirt-sock-ro")))
 
288
                goto no_memory;
 
289
        } else {
 
290
            char *rundir = NULL;
 
291
            mode_t old_umask;
 
292
 
 
293
            if (!(rundir = virGetUserRuntimeDirectory()))
 
294
                goto error;
 
295
 
 
296
            old_umask = umask(077);
 
297
            if (virFileMakePath(rundir) < 0) {
 
298
                umask(old_umask);
 
299
                goto error;
 
300
            }
 
301
            umask(old_umask);
 
302
 
 
303
            if (virAsprintf(sockfile, "%s/libvirt-sock", rundir) < 0) {
 
304
                VIR_FREE(rundir);
 
305
                goto no_memory;
 
306
            }
 
307
 
 
308
            VIR_FREE(rundir);
 
309
        }
 
310
    }
 
311
    return 0;
 
312
 
 
313
no_memory:
 
314
    virReportOOMError();
 
315
error:
 
316
    return -1;
 
317
}
 
318
 
 
319
 
 
320
static void daemonErrorHandler(void *opaque ATTRIBUTE_UNUSED,
 
321
                               virErrorPtr err ATTRIBUTE_UNUSED)
 
322
{
 
323
    /* Don't do anything, since logging infrastructure already
 
324
     * took care of reporting the error */
 
325
}
 
326
 
 
327
static int daemonErrorLogFilter(virErrorPtr err, int priority)
 
328
{
 
329
    /* These error codes don't really reflect real errors. They
 
330
     * are expected events that occur when an app tries to check
 
331
     * whether a particular guest already exists. This filters
 
332
     * them to a lower log level to prevent pollution of syslog
 
333
     */
 
334
    switch (err->code) {
 
335
    case VIR_ERR_NO_DOMAIN:
 
336
    case VIR_ERR_NO_NETWORK:
 
337
    case VIR_ERR_NO_STORAGE_POOL:
 
338
    case VIR_ERR_NO_STORAGE_VOL:
 
339
    case VIR_ERR_NO_NODE_DEVICE:
 
340
    case VIR_ERR_NO_INTERFACE:
 
341
    case VIR_ERR_NO_NWFILTER:
 
342
    case VIR_ERR_NO_SECRET:
 
343
    case VIR_ERR_NO_DOMAIN_SNAPSHOT:
 
344
    case VIR_ERR_OPERATION_INVALID:
 
345
        return VIR_LOG_DEBUG;
 
346
    }
 
347
 
 
348
    return priority;
 
349
}
 
350
 
 
351
static void daemonInitialize(void)
 
352
{
 
353
    /*
 
354
     * Note that the order is important: the first ones have a higher
 
355
     * priority when calling virStateInitialize. We must register
 
356
     * the network, storage and nodedev drivers before any domain
 
357
     * drivers, since their resources must be auto-started before
 
358
     * any domains can be auto-started.
 
359
     */
 
360
#ifdef WITH_DRIVER_MODULES
 
361
    /* We don't care if any of these fail, because the whole point
 
362
     * is to allow users to only install modules they want to use.
 
363
     * If they try to open a connection for a module that
 
364
     * is not loaded they'll get a suitable error at that point
 
365
     */
 
366
# ifdef WITH_NETWORK
 
367
    virDriverLoadModule("network");
 
368
# endif
 
369
# ifdef WITH_STORAGE
 
370
    virDriverLoadModule("storage");
 
371
# endif
 
372
# ifdef WITH_NODE_DEVICES
 
373
    virDriverLoadModule("nodedev");
 
374
# endif
 
375
# ifdef WITH_SECRETS
 
376
    virDriverLoadModule("secret");
 
377
# endif
 
378
# ifdef WITH_NWFILTER
 
379
    virDriverLoadModule("nwfilter");
 
380
# endif
 
381
# ifdef WITH_INTERFACE
 
382
    virDriverLoadModule("interface");
 
383
# endif
 
384
# ifdef WITH_QEMU
 
385
    virDriverLoadModule("qemu");
 
386
# endif
 
387
# ifdef WITH_LXC
 
388
    virDriverLoadModule("lxc");
 
389
# endif
 
390
# ifdef WITH_UML
 
391
    virDriverLoadModule("uml");
 
392
# endif
 
393
# ifdef WITH_XEN
 
394
    virDriverLoadModule("xen");
 
395
# endif
 
396
# ifdef WITH_LIBXL
 
397
    virDriverLoadModule("libxl");
 
398
# endif
 
399
#else
 
400
# ifdef WITH_NETWORK
 
401
    networkRegister();
 
402
# endif
 
403
# ifdef WITH_NETCF
 
404
    interfaceRegister();
 
405
# endif
 
406
# ifdef WITH_STORAGE
 
407
    storageRegister();
 
408
# endif
 
409
# ifdef WITH_NODE_DEVICES
 
410
    nodedevRegister();
 
411
# endif
 
412
# ifdef WITH_SECRETS
 
413
    secretRegister();
 
414
# endif
 
415
# ifdef WITH_NWFILTER
 
416
    nwfilterRegister();
 
417
# endif
 
418
# ifdef WITH_LIBXL
 
419
    libxlRegister();
 
420
# endif
 
421
# ifdef WITH_QEMU
 
422
    qemuRegister();
 
423
# endif
 
424
# ifdef WITH_LXC
 
425
    lxcRegister();
 
426
# endif
 
427
# ifdef WITH_UML
 
428
    umlRegister();
 
429
# endif
 
430
#endif
 
431
}
 
432
 
 
433
 
 
434
static int daemonSetupNetworking(virNetServerPtr srv,
 
435
                                 struct daemonConfig *config,
 
436
                                 const char *sock_path,
 
437
                                 const char *sock_path_ro,
 
438
                                 bool ipsock,
 
439
                                 bool privileged)
 
440
{
 
441
    virNetServerServicePtr svc = NULL;
 
442
    virNetServerServicePtr svcRO = NULL;
 
443
    virNetServerServicePtr svcTCP = NULL;
 
444
    virNetServerServicePtr svcTLS = NULL;
 
445
    gid_t unix_sock_gid = 0;
 
446
    int unix_sock_ro_mask = 0;
 
447
    int unix_sock_rw_mask = 0;
 
448
 
 
449
    if (config->unix_sock_group) {
 
450
        if (virGetGroupID(config->unix_sock_group, &unix_sock_gid) < 0)
 
451
            return -1;
 
452
    }
 
453
 
 
454
    if (virStrToLong_i(config->unix_sock_ro_perms, NULL, 8, &unix_sock_ro_mask) != 0) {
 
455
        VIR_ERROR(_("Failed to parse mode '%s'"), config->unix_sock_ro_perms);
 
456
        goto error;
 
457
    }
 
458
 
 
459
    if (virStrToLong_i(config->unix_sock_rw_perms, NULL, 8, &unix_sock_rw_mask) != 0) {
 
460
        VIR_ERROR(_("Failed to parse mode '%s'"), config->unix_sock_rw_perms);
 
461
        goto error;
 
462
    }
 
463
 
 
464
    VIR_DEBUG("Registering unix socket %s", sock_path);
 
465
    if (!(svc = virNetServerServiceNewUNIX(sock_path,
 
466
                                           unix_sock_rw_mask,
 
467
                                           unix_sock_gid,
 
468
                                           config->auth_unix_rw,
 
469
                                           false,
 
470
                                           config->max_client_requests,
 
471
                                           NULL)))
 
472
        goto error;
 
473
    if (sock_path_ro) {
 
474
        VIR_DEBUG("Registering unix socket %s", sock_path_ro);
 
475
        if (!(svcRO = virNetServerServiceNewUNIX(sock_path_ro,
 
476
                                                 unix_sock_ro_mask,
 
477
                                                 unix_sock_gid,
 
478
                                                 config->auth_unix_ro,
 
479
                                                 true,
 
480
                                                 config->max_client_requests,
 
481
                                                 NULL)))
 
482
            goto error;
 
483
    }
 
484
 
 
485
    if (virNetServerAddService(srv, svc,
 
486
                               config->mdns_adv && !ipsock ?
 
487
                               "_libvirt._tcp" :
 
488
                               NULL) < 0)
 
489
        goto error;
 
490
 
 
491
    if (svcRO &&
 
492
        virNetServerAddService(srv, svcRO, NULL) < 0)
 
493
        goto error;
 
494
 
 
495
    if (ipsock) {
 
496
        if (config->listen_tcp) {
 
497
            VIR_DEBUG("Registering TCP socket %s:%s",
 
498
                      config->listen_addr, config->tcp_port);
 
499
            if (!(svcTCP = virNetServerServiceNewTCP(config->listen_addr,
 
500
                                                     config->tcp_port,
 
501
                                                     config->auth_tcp,
 
502
                                                     false,
 
503
                                                     config->max_client_requests,
 
504
                                                     NULL)))
 
505
                goto error;
 
506
 
 
507
            if (virNetServerAddService(srv, svcTCP,
 
508
                                       config->mdns_adv ? "_libvirt._tcp" : NULL) < 0)
 
509
                goto error;
 
510
        }
 
511
 
 
512
        if (config->listen_tls) {
 
513
            virNetTLSContextPtr ctxt = NULL;
 
514
 
 
515
            if (config->ca_file ||
 
516
                config->cert_file ||
 
517
                config->key_file) {
 
518
                if (!(ctxt = virNetTLSContextNewServer(config->ca_file,
 
519
                                                       config->crl_file,
 
520
                                                       config->cert_file,
 
521
                                                       config->key_file,
 
522
                                                       (const char *const*)config->tls_allowed_dn_list,
 
523
                                                       config->tls_no_sanity_certificate ? false : true,
 
524
                                                       config->tls_no_verify_certificate ? false : true)))
 
525
                    goto error;
 
526
            } else {
 
527
                if (!(ctxt = virNetTLSContextNewServerPath(NULL,
 
528
                                                           !privileged,
 
529
                                                           (const char *const*)config->tls_allowed_dn_list,
 
530
                                                           config->tls_no_sanity_certificate ? false : true,
 
531
                                                           config->tls_no_verify_certificate ? false : true)))
 
532
                    goto error;
 
533
            }
 
534
 
 
535
            VIR_DEBUG("Registering TLS socket %s:%s",
 
536
                      config->listen_addr, config->tls_port);
 
537
            if (!(svcTLS =
 
538
                  virNetServerServiceNewTCP(config->listen_addr,
 
539
                                            config->tls_port,
 
540
                                            config->auth_tls,
 
541
                                            false,
 
542
                                            config->max_client_requests,
 
543
                                            ctxt))) {
 
544
                virNetTLSContextFree(ctxt);
 
545
                goto error;
 
546
            }
 
547
            if (virNetServerAddService(srv, svcTLS,
 
548
                                       config->mdns_adv &&
 
549
                                       !config->listen_tcp ? "_libvirt._tcp" : NULL) < 0)
 
550
                goto error;
 
551
 
 
552
            virNetTLSContextFree(ctxt);
 
553
        }
 
554
    }
 
555
 
 
556
#if HAVE_SASL
 
557
    if (config->auth_unix_rw == REMOTE_AUTH_SASL ||
 
558
        config->auth_unix_ro == REMOTE_AUTH_SASL ||
 
559
        config->auth_tcp == REMOTE_AUTH_SASL ||
 
560
        config->auth_tls == REMOTE_AUTH_SASL) {
 
561
        saslCtxt = virNetSASLContextNewServer(
 
562
            (const char *const*)config->sasl_allowed_username_list);
 
563
        if (!saslCtxt)
 
564
            goto error;
 
565
    }
 
566
#endif
 
567
 
 
568
    return 0;
 
569
 
 
570
error:
 
571
    virNetServerServiceFree(svcTLS);
 
572
    virNetServerServiceFree(svcTCP);
 
573
    virNetServerServiceFree(svc);
 
574
    virNetServerServiceFree(svcRO);
 
575
    return -1;
 
576
}
 
577
 
 
578
 
 
579
static int daemonShutdownCheck(virNetServerPtr srv ATTRIBUTE_UNUSED,
 
580
                               void *opaque ATTRIBUTE_UNUSED)
 
581
{
 
582
    if (virStateActive())
 
583
        return 0;
 
584
 
 
585
    return 1;
 
586
}
 
587
 
 
588
 
 
589
/*
 
590
 * Set up the logging environment
 
591
 * By default if daemonized all errors go to the logfile libvirtd.log,
 
592
 * but if verbose or error debugging is asked for then also output
 
593
 * informational and debug messages. Default size if 64 kB.
 
594
 */
 
595
static int
 
596
daemonSetupLogging(struct daemonConfig *config,
 
597
                   bool privileged,
 
598
                   bool verbose,
 
599
                   bool godaemon)
 
600
{
 
601
    virLogReset();
 
602
 
 
603
    /*
 
604
     * Libvirtd's order of precedence is:
 
605
     * cmdline > environment > config
 
606
     *
 
607
     * In order to achieve this, we must process configuration in
 
608
     * different order for the log level versus the filters and
 
609
     * outputs. Because filters and outputs append, we have to look at
 
610
     * the environment first and then only check the config file if
 
611
     * there was no result from the environment. The default output is
 
612
     * then applied only if there was no setting from either of the
 
613
     * first two. Because we don't have a way to determine if the log
 
614
     * level has been set, we must process variables in the opposite
 
615
     * order, each one overriding the previous.
 
616
     */
 
617
    if (config->log_level != 0)
 
618
        virLogSetDefaultPriority(config->log_level);
 
619
 
 
620
    virLogSetFromEnv();
 
621
 
 
622
    virLogSetBufferSize(config->log_buffer_size);
 
623
 
 
624
    if (virLogGetNbFilters() == 0)
 
625
        virLogParseFilters(config->log_filters);
 
626
 
 
627
    if (virLogGetNbOutputs() == 0)
 
628
        virLogParseOutputs(config->log_outputs);
 
629
 
 
630
    /*
 
631
     * If no defined outputs, then direct to libvirtd.log when running
 
632
     * as daemon. Otherwise the default output is stderr.
 
633
     */
 
634
    if (virLogGetNbOutputs() == 0) {
 
635
        char *tmp = NULL;
 
636
 
 
637
        if (godaemon) {
 
638
            if (privileged) {
 
639
                if (virAsprintf(&tmp, "%d:file:%s/log/libvirt/libvirtd.log",
 
640
                                virLogGetDefaultPriority(),
 
641
                                LOCALSTATEDIR) == -1)
 
642
                    goto no_memory;
 
643
            } else {
 
644
                char *logdir = virGetUserCacheDirectory();
 
645
                mode_t old_umask;
 
646
 
 
647
                if (!logdir)
 
648
                    goto error;
 
649
 
 
650
                old_umask = umask(077);
 
651
                if (virFileMakePath(logdir) < 0) {
 
652
                    umask(old_umask);
 
653
                    goto error;
 
654
                }
 
655
                umask(old_umask);
 
656
 
 
657
                if (virAsprintf(&tmp, "%d:file:%s/libvirtd.log",
 
658
                                virLogGetDefaultPriority(), logdir) == -1) {
 
659
                    VIR_FREE(logdir);
 
660
                    goto no_memory;
 
661
                }
 
662
                VIR_FREE(logdir);
 
663
            }
 
664
        } else {
 
665
            if (virAsprintf(&tmp, "%d:stderr", virLogGetDefaultPriority()) < 0)
 
666
                goto no_memory;
 
667
        }
 
668
        virLogParseOutputs(tmp);
 
669
        VIR_FREE(tmp);
 
670
    }
 
671
 
 
672
    /*
 
673
     * Command line override for --verbose
 
674
     */
 
675
    if ((verbose) && (virLogGetDefaultPriority() > VIR_LOG_INFO))
 
676
        virLogSetDefaultPriority(VIR_LOG_INFO);
 
677
 
 
678
    return 0;
 
679
 
 
680
no_memory:
 
681
    virReportOOMError();
 
682
error:
 
683
    return -1;
 
684
}
 
685
 
 
686
 
 
687
/* Display version information. */
 
688
static void
 
689
daemonVersion(const char *argv0)
 
690
{
 
691
    printf ("%s (%s) %s\n", argv0, PACKAGE_NAME, PACKAGE_VERSION);
 
692
}
 
693
 
 
694
#ifdef __sun
 
695
static int
 
696
daemonSetupPrivs(void)
 
697
{
 
698
    chown ("/var/run/libvirt", SYSTEM_UID, SYSTEM_UID);
 
699
 
 
700
    if (__init_daemon_priv (PU_RESETGROUPS | PU_CLEARLIMITSET,
 
701
        SYSTEM_UID, SYSTEM_UID, PRIV_XVM_CONTROL, NULL)) {
 
702
        VIR_ERROR(_("additional privileges are required"));
 
703
        return -1;
 
704
    }
 
705
 
 
706
    if (priv_set (PRIV_OFF, PRIV_ALLSETS, PRIV_FILE_LINK_ANY, PRIV_PROC_INFO,
 
707
        PRIV_PROC_SESSION, PRIV_PROC_EXEC, PRIV_PROC_FORK, NULL)) {
 
708
        VIR_ERROR(_("failed to set reduced privileges"));
 
709
        return -1;
 
710
    }
 
711
 
 
712
    return 0;
 
713
}
 
714
#else
 
715
# define daemonSetupPrivs() 0
 
716
#endif
 
717
 
 
718
 
 
719
static void daemonShutdownHandler(virNetServerPtr srv,
 
720
                                  siginfo_t *sig ATTRIBUTE_UNUSED,
 
721
                                  void *opaque ATTRIBUTE_UNUSED)
 
722
{
 
723
    virNetServerQuit(srv);
 
724
}
 
725
 
 
726
static void daemonReloadHandler(virNetServerPtr srv ATTRIBUTE_UNUSED,
 
727
                                siginfo_t *sig ATTRIBUTE_UNUSED,
 
728
                                void *opaque ATTRIBUTE_UNUSED)
 
729
{
 
730
        VIR_INFO("Reloading configuration on SIGHUP");
 
731
        virHookCall(VIR_HOOK_DRIVER_DAEMON, "-",
 
732
                    VIR_HOOK_DAEMON_OP_RELOAD, SIGHUP, "SIGHUP", NULL, NULL);
 
733
        if (virStateReload() < 0)
 
734
            VIR_WARN("Error while reloading drivers");
 
735
}
 
736
 
 
737
static int daemonSetupSignals(virNetServerPtr srv)
 
738
{
 
739
    if (virNetServerAddSignalHandler(srv, SIGINT, daemonShutdownHandler, NULL) < 0)
 
740
        return -1;
 
741
    if (virNetServerAddSignalHandler(srv, SIGQUIT, daemonShutdownHandler, NULL) < 0)
 
742
        return -1;
 
743
    if (virNetServerAddSignalHandler(srv, SIGTERM, daemonShutdownHandler, NULL) < 0)
 
744
        return -1;
 
745
    if (virNetServerAddSignalHandler(srv, SIGHUP, daemonReloadHandler, NULL) < 0)
 
746
        return -1;
 
747
    return 0;
 
748
}
 
749
 
 
750
static void daemonRunStateInit(void *opaque)
 
751
{
 
752
    virNetServerPtr srv = opaque;
 
753
 
 
754
    /* Start the stateful HV drivers
 
755
     * This is deliberately done after telling the parent process
 
756
     * we're ready, since it can take a long time and this will
 
757
     * seriously delay OS bootup process */
 
758
    if (virStateInitialize(virNetServerIsPrivileged(srv)) < 0) {
 
759
        VIR_ERROR(_("Driver state initialization failed"));
 
760
        /* Ensure the main event loop quits */
 
761
        kill(getpid(), SIGTERM);
 
762
        virNetServerFree(srv);
 
763
        return;
 
764
    }
 
765
 
 
766
    /* Only now accept clients from network */
 
767
    virNetServerUpdateServices(srv, true);
 
768
    virNetServerFree(srv);
 
769
}
 
770
 
 
771
static int daemonStateInit(virNetServerPtr srv)
 
772
{
 
773
    virThread thr;
 
774
    virNetServerRef(srv);
 
775
    if (virThreadCreate(&thr, false, daemonRunStateInit, srv) < 0) {
 
776
        virNetServerFree(srv);
 
777
        return -1;
 
778
    }
 
779
    return 0;
 
780
}
 
781
 
 
782
static int migrateProfile(void)
 
783
{
 
784
    char *old_base = NULL;
 
785
    char *updated = NULL;
 
786
    char *home = NULL;
 
787
    char *xdg_dir = NULL;
 
788
    char *config_dir = NULL;
 
789
    const char *config_home;
 
790
    int ret = -1;
 
791
    mode_t old_umask;
 
792
 
 
793
    VIR_DEBUG("Checking if user profile needs migrating");
 
794
 
 
795
    if (!(home = virGetUserDirectory()))
 
796
        goto cleanup;
 
797
 
 
798
    if (virAsprintf(&old_base, "%s/.libvirt", home) < 0) {
 
799
        goto cleanup;
 
800
    }
 
801
 
 
802
    /* if the new directory is there or the old one is not: do nothing */
 
803
    if (!(config_dir = virGetUserConfigDirectory()))
 
804
        goto cleanup;
 
805
 
 
806
    if (!virFileIsDir(old_base) || virFileExists(config_dir)) {
 
807
        VIR_DEBUG("No old profile in '%s' / "
 
808
                  "new profile directory already present '%s'",
 
809
                  old_base, config_dir);
 
810
        ret = 0;
 
811
        goto cleanup;
 
812
    }
 
813
 
 
814
    /* test if we already attempted to migrate first */
 
815
    if (virAsprintf(&updated, "%s/DEPRECATED-DIRECTORY", old_base) < 0) {
 
816
        goto cleanup;
 
817
    }
 
818
    if (virFileExists(updated)) {
 
819
        goto cleanup;
 
820
    }
 
821
 
 
822
    config_home = getenv("XDG_CONFIG_HOME");
 
823
    if (config_home && config_home[0] != '\0') {
 
824
        xdg_dir = strdup(config_home);
 
825
    } else {
 
826
        if (virAsprintf(&xdg_dir, "%s/.config", home) < 0) {
 
827
            goto cleanup;
 
828
        }
 
829
    }
 
830
 
 
831
    old_umask = umask(077);
 
832
    if (virFileMakePath(xdg_dir) < 0) {
 
833
        umask(old_umask);
 
834
        goto cleanup;
 
835
    }
 
836
    umask(old_umask);
 
837
 
 
838
    if (rename(old_base, config_dir) < 0) {
 
839
        int fd = creat(updated, 0600);
 
840
        VIR_FORCE_CLOSE(fd);
 
841
        VIR_ERROR(_("Unable to migrate %s to %s"), old_base, config_dir);
 
842
        goto cleanup;
 
843
    }
 
844
 
 
845
    VIR_DEBUG("Profile migrated from %s to %s", old_base, config_dir);
 
846
    ret = 0;
 
847
 
 
848
 cleanup:
 
849
    VIR_FREE(home);
 
850
    VIR_FREE(old_base);
 
851
    VIR_FREE(xdg_dir);
 
852
    VIR_FREE(config_dir);
 
853
    VIR_FREE(updated);
 
854
 
 
855
    return ret;
 
856
}
 
857
 
 
858
/* Print command-line usage. */
 
859
static void
 
860
daemonUsage(const char *argv0, bool privileged)
 
861
{
 
862
    fprintf (stderr,
 
863
             _("\n\
 
864
Usage:\n\
 
865
  %s [options]\n\
 
866
\n\
 
867
Options:\n\
 
868
  -v | --verbose         Verbose messages.\n\
 
869
  -d | --daemon          Run as a daemon & write PID file.\n\
 
870
  -l | --listen          Listen for TCP/IP connections.\n\
 
871
  -t | --timeout <secs>  Exit after timeout period.\n\
 
872
  -f | --config <file>   Configuration file.\n\
 
873
     | --version         Display version information.\n\
 
874
  -p | --pid-file <file> Change name of PID file.\n\
 
875
\n\
 
876
libvirt management daemon:\n"), argv0);
 
877
 
 
878
    if (privileged) {
 
879
        fprintf(stderr,
 
880
                _("\n\
 
881
  Default paths:\n\
 
882
\n\
 
883
    Configuration file (unless overridden by -f):\n\
 
884
      %s/libvirt/libvirtd.conf\n\
 
885
\n\
 
886
    Sockets:\n\
 
887
      %s/run/libvirt/libvirt-sock\n\
 
888
      %s/run/libvirt/libvirt-sock-ro\n\
 
889
\n\
 
890
    TLS:\n\
 
891
      CA certificate:     %s/pki/CA/caert.pem\n\
 
892
      Server certificate: %s/pki/libvirt/servercert.pem\n\
 
893
      Server private key: %s/pki/libvirt/private/serverkey.pem\n\
 
894
\n\
 
895
    PID file (unless overridden by -p):\n\
 
896
      %s/run/libvirtd.pid\n\
 
897
\n"),
 
898
                SYSCONFDIR,
 
899
                LOCALSTATEDIR,
 
900
                LOCALSTATEDIR,
 
901
                SYSCONFDIR,
 
902
                SYSCONFDIR,
 
903
                SYSCONFDIR,
 
904
                LOCALSTATEDIR);
 
905
    } else {
 
906
        fprintf(stderr,
 
907
                "%s", _("\n\
 
908
  Default paths:\n\
 
909
\n\
 
910
    Configuration file (unless overridden by -f):\n\
 
911
      $XDG_CONFIG_HOME/libvirt/libvirtd.conf\n\
 
912
\n\
 
913
    Sockets:\n\
 
914
      $XDG_RUNTIME_HOME/libvirt/libvirt-sock (in UNIX abstract namespace)\n\
 
915
\n\
 
916
    TLS:\n\
 
917
      CA certificate:     $HOME/.pki/libvirt/cacert.pem\n\
 
918
      Server certificate: $HOME/.pki/libvirt/servercert.pem\n\
 
919
      Server private key: $HOME/.pki/libvirt/serverkey.pem\n\
 
920
\n\
 
921
    PID file:\n\
 
922
      $XDG_RUNTIME_HOME/libvirt/libvirtd.pid\n\
 
923
\n"));
 
924
    }
 
925
}
 
926
 
 
927
enum {
 
928
    OPT_VERSION = 129
 
929
};
 
930
 
 
931
#define MAX_LISTEN 5
 
932
int main(int argc, char **argv) {
 
933
    virNetServerPtr srv = NULL;
 
934
    char *remote_config_file = NULL;
 
935
    int statuswrite = -1;
 
936
    int ret = 1;
 
937
    int pid_file_fd = -1;
 
938
    char *pid_file = NULL;
 
939
    char *sock_file = NULL;
 
940
    char *sock_file_ro = NULL;
 
941
    int timeout = -1;        /* -t: Shutdown timeout */
 
942
    int verbose = 0;
 
943
    int godaemon = 0;
 
944
    int ipsock = 0;
 
945
    struct daemonConfig *config;
 
946
    bool privileged = geteuid() == 0 ? true : false;
 
947
    bool implicit_conf = false;
 
948
    char *run_dir = NULL;
 
949
    mode_t old_umask;
 
950
 
 
951
    struct option opts[] = {
 
952
        { "verbose", no_argument, &verbose, 1},
 
953
        { "daemon", no_argument, &godaemon, 1},
 
954
        { "listen", no_argument, &ipsock, 1},
 
955
        { "config", required_argument, NULL, 'f'},
 
956
        { "timeout", required_argument, NULL, 't'},
 
957
        { "pid-file", required_argument, NULL, 'p'},
 
958
        { "version", no_argument, NULL, OPT_VERSION },
 
959
        { "help", no_argument, NULL, '?' },
 
960
        {0, 0, 0, 0}
 
961
    };
 
962
 
 
963
    if (setlocale (LC_ALL, "") == NULL ||
 
964
        bindtextdomain (PACKAGE, LOCALEDIR) == NULL ||
 
965
        textdomain(PACKAGE) == NULL ||
 
966
        virInitialize() < 0) {
 
967
        fprintf(stderr, _("%s: initialization failed\n"), argv[0]);
 
968
        exit(EXIT_FAILURE);
 
969
    }
 
970
 
 
971
    /* initialize early logging */
 
972
    virLogSetFromEnv();
 
973
 
 
974
#ifdef WITH_DRIVER_MODULES
 
975
    if (strstr(argv[0], "lt-libvirtd") &&
 
976
        (access("./.git", R_OK) >= 0 || access("../.git", R_OK) >= 0))
 
977
        virDriverModuleInitialize("./src/.libs");
 
978
#endif
 
979
 
 
980
    while (1) {
 
981
        int optidx = 0;
 
982
        int c;
 
983
        char *tmp;
 
984
 
 
985
        c = getopt_long(argc, argv, "ldf:p:t:v", opts, &optidx);
 
986
 
 
987
        if (c == -1) {
 
988
            break;
 
989
        }
 
990
 
 
991
        switch (c) {
 
992
        case 0:
 
993
            /* Got one of the flags */
 
994
            break;
 
995
        case 'v':
 
996
            verbose = 1;
 
997
            break;
 
998
        case 'd':
 
999
            godaemon = 1;
 
1000
            break;
 
1001
        case 'l':
 
1002
            ipsock = 1;
 
1003
            break;
 
1004
 
 
1005
        case 't':
 
1006
            if (virStrToLong_i(optarg, &tmp, 10, &timeout) != 0
 
1007
                || timeout <= 0
 
1008
                /* Ensure that we can multiply by 1000 without overflowing.  */
 
1009
                || timeout > INT_MAX / 1000) {
 
1010
                VIR_ERROR(_("Invalid value for timeout"));
 
1011
                exit(EXIT_FAILURE);
 
1012
            }
 
1013
            break;
 
1014
 
 
1015
        case 'p':
 
1016
            VIR_FREE(pid_file);
 
1017
            if (!(pid_file = strdup(optarg))) {
 
1018
                VIR_ERROR(_("Can't allocate memory"));
 
1019
                exit(EXIT_FAILURE);
 
1020
            }
 
1021
            break;
 
1022
 
 
1023
        case 'f':
 
1024
            VIR_FREE(remote_config_file);
 
1025
            if (!(remote_config_file = strdup(optarg))) {
 
1026
                VIR_ERROR(_("Can't allocate memory"));
 
1027
                exit(EXIT_FAILURE);
 
1028
            }
 
1029
            break;
 
1030
 
 
1031
        case OPT_VERSION:
 
1032
            daemonVersion(argv[0]);
 
1033
            return 0;
 
1034
 
 
1035
        case '?':
 
1036
            daemonUsage(argv[0], privileged);
 
1037
            return 2;
 
1038
 
 
1039
        default:
 
1040
            VIR_ERROR(_("%s: internal error: unknown flag: %c"),
 
1041
                      argv[0], c);
 
1042
            exit (EXIT_FAILURE);
 
1043
        }
 
1044
    }
 
1045
 
 
1046
    if (optind != argc) {
 
1047
        fprintf(stderr, "%s: unexpected, non-option, command line arguments\n",
 
1048
                argv[0]);
 
1049
        exit(EXIT_FAILURE);
 
1050
    }
 
1051
 
 
1052
    if (!(config = daemonConfigNew(privileged))) {
 
1053
        VIR_ERROR(_("Can't create initial configuration"));
 
1054
        exit(EXIT_FAILURE);
 
1055
    }
 
1056
 
 
1057
    /* No explicit config, so try and find a default one */
 
1058
    if (remote_config_file == NULL) {
 
1059
        implicit_conf = true;
 
1060
        if (daemonConfigFilePath(privileged,
 
1061
                                 &remote_config_file) < 0) {
 
1062
            VIR_ERROR(_("Can't determine config path"));
 
1063
            exit(EXIT_FAILURE);
 
1064
        }
 
1065
    }
 
1066
 
 
1067
    /* Read the config file if it exists*/
 
1068
    if (remote_config_file &&
 
1069
        daemonConfigLoadFile(config, remote_config_file, implicit_conf) < 0) {
 
1070
        virErrorPtr err = virGetLastError();
 
1071
        if (err && err->message)
 
1072
            VIR_ERROR(_("Can't load config file: %s: %s"),
 
1073
                      err->message, remote_config_file);
 
1074
        else
 
1075
            VIR_ERROR(_("Can't load config file: %s"), remote_config_file);
 
1076
        exit(EXIT_FAILURE);
 
1077
    }
 
1078
 
 
1079
    if (!privileged &&
 
1080
        migrateProfile() < 0) {
 
1081
        VIR_ERROR(_("Exiting due to failure to migrate profile"));
 
1082
        exit(EXIT_FAILURE);
 
1083
    }
 
1084
 
 
1085
    if (config->host_uuid &&
 
1086
        virSetHostUUIDStr(config->host_uuid) < 0) {
 
1087
        VIR_ERROR(_("invalid host UUID: %s"), config->host_uuid);
 
1088
        exit(EXIT_FAILURE);
 
1089
    }
 
1090
 
 
1091
    if (daemonSetupLogging(config, privileged, verbose, godaemon) < 0) {
 
1092
        VIR_ERROR(_("Can't initialize logging"));
 
1093
        exit(EXIT_FAILURE);
 
1094
    }
 
1095
 
 
1096
    if (!pid_file &&
 
1097
        daemonPidFilePath(privileged,
 
1098
                          &pid_file) < 0) {
 
1099
        VIR_ERROR(_("Can't determine pid file path."));
 
1100
        exit(EXIT_FAILURE);
 
1101
    }
 
1102
    VIR_DEBUG("Decided on pid file path '%s'", NULLSTR(pid_file));
 
1103
 
 
1104
    if (daemonUnixSocketPaths(config,
 
1105
                              privileged,
 
1106
                              &sock_file,
 
1107
                              &sock_file_ro) < 0) {
 
1108
        VIR_ERROR(_("Can't determine socket paths"));
 
1109
        exit(EXIT_FAILURE);
 
1110
    }
 
1111
    VIR_DEBUG("Decided on socket paths '%s' and '%s'",
 
1112
              sock_file, NULLSTR(sock_file_ro));
 
1113
 
 
1114
    if (godaemon) {
 
1115
        char ebuf[1024];
 
1116
 
 
1117
        if (chdir("/") < 0) {
 
1118
            VIR_ERROR(_("cannot change to root directory: %s"),
 
1119
                      virStrerror(errno, ebuf, sizeof(ebuf)));
 
1120
            goto cleanup;
 
1121
        }
 
1122
 
 
1123
        if ((statuswrite = daemonForkIntoBackground(argv[0])) < 0) {
 
1124
            VIR_ERROR(_("Failed to fork as daemon: %s"),
 
1125
                      virStrerror(errno, ebuf, sizeof(ebuf)));
 
1126
            goto cleanup;
 
1127
        }
 
1128
    }
 
1129
 
 
1130
    /* Ensure the rundir exists (on tmpfs on some systems) */
 
1131
    if (privileged) {
 
1132
        run_dir = strdup(LOCALSTATEDIR "/run/libvirt");
 
1133
    } else {
 
1134
        run_dir = virGetUserRuntimeDirectory();
 
1135
 
 
1136
        if (!run_dir) {
 
1137
            VIR_ERROR(_("Can't determine user directory"));
 
1138
            goto cleanup;
 
1139
        }
 
1140
    }
 
1141
    if (!run_dir) {
 
1142
        virReportOOMError();
 
1143
        goto cleanup;
 
1144
    }
 
1145
 
 
1146
    if (privileged)
 
1147
        old_umask = umask(022);
 
1148
    else
 
1149
        old_umask = umask(077);
 
1150
    VIR_DEBUG("Ensuring run dir '%s' exists", run_dir);
 
1151
    if (virFileMakePath(run_dir) < 0) {
 
1152
        char ebuf[1024];
 
1153
        VIR_ERROR(_("unable to create rundir %s: %s"), run_dir,
 
1154
                  virStrerror(errno, ebuf, sizeof(ebuf)));
 
1155
        ret = VIR_DAEMON_ERR_RUNDIR;
 
1156
        goto cleanup;
 
1157
    }
 
1158
    umask(old_umask);
 
1159
 
 
1160
    /* Try to claim the pidfile, exiting if we can't */
 
1161
    if ((pid_file_fd = virPidFileAcquirePath(pid_file, getpid())) < 0) {
 
1162
        ret = VIR_DAEMON_ERR_PIDFILE;
 
1163
        goto cleanup;
 
1164
    }
 
1165
 
 
1166
    if (virNetlinkStartup() < 0) {
 
1167
        ret = VIR_DAEMON_ERR_INIT;
 
1168
        goto cleanup;
 
1169
    }
 
1170
 
 
1171
    if (!(srv = virNetServerNew(config->min_workers,
 
1172
                                config->max_workers,
 
1173
                                config->prio_workers,
 
1174
                                config->max_clients,
 
1175
                                config->keepalive_interval,
 
1176
                                config->keepalive_count,
 
1177
                                !!config->keepalive_required,
 
1178
                                config->mdns_adv ? config->mdns_name : NULL,
 
1179
                                remoteClientInitHook))) {
 
1180
        ret = VIR_DAEMON_ERR_INIT;
 
1181
        goto cleanup;
 
1182
    }
 
1183
 
 
1184
    /* Beyond this point, nothing should rely on using
 
1185
     * getuid/geteuid() == 0, for privilege level checks.
 
1186
     */
 
1187
    VIR_DEBUG("Dropping privileges (if required)");
 
1188
    if (daemonSetupPrivs() < 0) {
 
1189
        ret = VIR_DAEMON_ERR_PRIVS;
 
1190
        goto cleanup;
 
1191
    }
 
1192
 
 
1193
    daemonInitialize();
 
1194
 
 
1195
    remoteProcs[REMOTE_PROC_AUTH_LIST].needAuth = false;
 
1196
    remoteProcs[REMOTE_PROC_AUTH_SASL_INIT].needAuth = false;
 
1197
    remoteProcs[REMOTE_PROC_AUTH_SASL_STEP].needAuth = false;
 
1198
    remoteProcs[REMOTE_PROC_AUTH_SASL_START].needAuth = false;
 
1199
    remoteProcs[REMOTE_PROC_AUTH_POLKIT].needAuth = false;
 
1200
    if (!(remoteProgram = virNetServerProgramNew(REMOTE_PROGRAM,
 
1201
                                                 REMOTE_PROTOCOL_VERSION,
 
1202
                                                 remoteProcs,
 
1203
                                                 remoteNProcs))) {
 
1204
        ret = VIR_DAEMON_ERR_INIT;
 
1205
        goto cleanup;
 
1206
    }
 
1207
    if (virNetServerAddProgram(srv, remoteProgram) < 0) {
 
1208
        ret = VIR_DAEMON_ERR_INIT;
 
1209
        goto cleanup;
 
1210
    }
 
1211
 
 
1212
    if (!(qemuProgram = virNetServerProgramNew(QEMU_PROGRAM,
 
1213
                                               QEMU_PROTOCOL_VERSION,
 
1214
                                               qemuProcs,
 
1215
                                               qemuNProcs))) {
 
1216
        ret = VIR_DAEMON_ERR_INIT;
 
1217
        goto cleanup;
 
1218
    }
 
1219
    if (virNetServerAddProgram(srv, qemuProgram) < 0) {
 
1220
        ret = VIR_DAEMON_ERR_INIT;
 
1221
        goto cleanup;
 
1222
    }
 
1223
 
 
1224
    if (timeout != -1) {
 
1225
        VIR_DEBUG("Registering shutdown timeout %d", timeout);
 
1226
        virNetServerAutoShutdown(srv,
 
1227
                                 timeout,
 
1228
                                 daemonShutdownCheck,
 
1229
                                 NULL);
 
1230
    }
 
1231
 
 
1232
    if ((daemonSetupSignals(srv)) < 0) {
 
1233
        ret = VIR_DAEMON_ERR_SIGNAL;
 
1234
        goto cleanup;
 
1235
    }
 
1236
 
 
1237
    if (config->audit_level) {
 
1238
        VIR_DEBUG("Attempting to configure auditing subsystem");
 
1239
        if (virAuditOpen() < 0) {
 
1240
            if (config->audit_level > 1) {
 
1241
                ret = VIR_DAEMON_ERR_AUDIT;
 
1242
                goto cleanup;
 
1243
            }
 
1244
            VIR_DEBUG("Proceeding without auditing");
 
1245
        }
 
1246
    }
 
1247
    virAuditLog(config->audit_logging);
 
1248
 
 
1249
    /* setup the hooks if any */
 
1250
    if (virHookInitialize() < 0) {
 
1251
        ret = VIR_DAEMON_ERR_HOOKS;
 
1252
        goto cleanup;
 
1253
    }
 
1254
 
 
1255
    /* Disable error func, now logging is setup */
 
1256
    virSetErrorFunc(NULL, daemonErrorHandler);
 
1257
    virSetErrorLogPriorityFunc(daemonErrorLogFilter);
 
1258
 
 
1259
    /*
 
1260
     * Call the daemon startup hook
 
1261
     * TODO: should we abort the daemon startup if the script returned
 
1262
     *       an error ?
 
1263
     */
 
1264
    virHookCall(VIR_HOOK_DRIVER_DAEMON, "-", VIR_HOOK_DAEMON_OP_START,
 
1265
                0, "start", NULL, NULL);
 
1266
 
 
1267
    if (daemonSetupNetworking(srv, config,
 
1268
                              sock_file, sock_file_ro,
 
1269
                              ipsock, privileged) < 0) {
 
1270
        ret = VIR_DAEMON_ERR_NETWORK;
 
1271
        goto cleanup;
 
1272
    }
 
1273
 
 
1274
    /* Tell parent of daemon that basic initialization is complete
 
1275
     * In particular we're ready to accept net connections & have
 
1276
     * written the pidfile
 
1277
     */
 
1278
    if (statuswrite != -1) {
 
1279
        char status = 0;
 
1280
        while (write(statuswrite, &status, 1) == -1 &&
 
1281
               errno == EINTR)
 
1282
            ;
 
1283
        VIR_FORCE_CLOSE(statuswrite);
 
1284
    }
 
1285
 
 
1286
    /* Initialize drivers & then start accepting new clients from network */
 
1287
    if (daemonStateInit(srv) < 0) {
 
1288
        ret = VIR_DAEMON_ERR_INIT;
 
1289
        goto cleanup;
 
1290
    }
 
1291
 
 
1292
    /* Register the netlink event service */
 
1293
    if (virNetlinkEventServiceStart() < 0) {
 
1294
        ret = VIR_DAEMON_ERR_NETWORK;
 
1295
        goto cleanup;
 
1296
    }
 
1297
 
 
1298
    /* Run event loop. */
 
1299
    virNetServerRun(srv);
 
1300
 
 
1301
    ret = 0;
 
1302
 
 
1303
    virHookCall(VIR_HOOK_DRIVER_DAEMON, "-", VIR_HOOK_DAEMON_OP_SHUTDOWN,
 
1304
                0, "shutdown", NULL, NULL);
 
1305
 
 
1306
cleanup:
 
1307
    virNetlinkEventServiceStop();
 
1308
    virNetServerProgramFree(remoteProgram);
 
1309
    virNetServerProgramFree(qemuProgram);
 
1310
    virNetServerClose(srv);
 
1311
    virNetServerFree(srv);
 
1312
    virNetlinkShutdown();
 
1313
    if (statuswrite != -1) {
 
1314
        if (ret != 0) {
 
1315
            /* Tell parent of daemon what failed */
 
1316
            char status = ret;
 
1317
            while (write(statuswrite, &status, 1) == -1 &&
 
1318
                   errno == EINTR)
 
1319
                ;
 
1320
        }
 
1321
        VIR_FORCE_CLOSE(statuswrite);
 
1322
    }
 
1323
    if (pid_file_fd != -1)
 
1324
        virPidFileReleasePath(pid_file, pid_file_fd);
 
1325
 
 
1326
    VIR_FREE(sock_file);
 
1327
    VIR_FREE(sock_file_ro);
 
1328
    VIR_FREE(pid_file);
 
1329
    VIR_FREE(remote_config_file);
 
1330
    VIR_FREE(run_dir);
 
1331
 
 
1332
    daemonConfigFree(config);
 
1333
    virLogShutdown();
 
1334
 
 
1335
    return ret;
 
1336
}