qga/main.c

   1 /*
   2  * QEMU Guest Agent
   3  *
   4  * Copyright IBM Corp. 2011
   5  *
   6  * Authors:
   7  *  Adam Litke        <aglitke@linux.vnet.ibm.com>
   8  *  Michael Roth      <mdroth@linux.vnet.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  */
  13 #include "qemu/osdep.h"
  14 #include <getopt.h>
  15 #include <glib/gstdio.h>
  16 #ifndef _WIN32
  17 #include <syslog.h>
  18 #include <sys/wait.h>
  19 #endif
  20 #include "qapi/qmp/json-streamer.h"
  21 #include "qapi/qmp/json-parser.h"
  22 #include "qapi/qmp/qjson.h"
  23 #include "qga/guest-agent-core.h"
  24 #include "qemu/module.h"
  25 #include "qapi/qmp/qerror.h"
  26 #include "qapi/qmp/dispatch.h"
  27 #include "qga/channel.h"
  28 #include "qemu/bswap.h"
  29 #include "qemu/help_option.h"
  30 #include "qemu/sockets.h"
  31 #include "qemu/systemd.h"
  32 #ifdef _WIN32
  33 #include "qga/service-win32.h"
  34 #include "qga/vss-win32.h"
  35 #endif
  36 #ifdef __linux__
  37 #include <linux/fs.h>
  38 #ifdef FIFREEZE
  39 #define CONFIG_FSFREEZE
  40 #endif
  41 #endif
  42
  43 #ifndef _WIN32
  44 #define QGA_VIRTIO_PATH_DEFAULT "/dev/virtio-ports/org.qemu.guest_agent.0"
  45 #define QGA_STATE_RELATIVE_DIR  "run"
  46 #define QGA_SERIAL_PATH_DEFAULT "/dev/ttyS0"
  47 #else
  48 #define QGA_VIRTIO_PATH_DEFAULT "\\\\.\\Global\\org.qemu.guest_agent.0"
  49 #define QGA_STATE_RELATIVE_DIR  "qemu-ga"
  50 #define QGA_SERIAL_PATH_DEFAULT "COM1"
  51 #endif
  52 #ifdef CONFIG_FSFREEZE
  53 #define QGA_FSFREEZE_HOOK_DEFAULT CONFIG_QEMU_CONFDIR "/fsfreeze-hook"
  54 #endif
  55 #define QGA_SENTINEL_BYTE 0xFF
  56 #define QGA_CONF_DEFAULT CONFIG_QEMU_CONFDIR G_DIR_SEPARATOR_S "qemu-ga.conf"
  57
  58 static struct {
  59     const char *state_dir;
  60     const char *pidfile;
  61 } dfl_pathnames;
  62
  63 typedef struct GAPersistentState {
  64 #define QGA_PSTATE_DEFAULT_FD_COUNTER 1000
  65     int64_t fd_counter;
  66 } GAPersistentState;
  67
  68 struct GAState {
  69     JSONMessageParser parser;
  70     GMainLoop *main_loop;
  71     GAChannel *channel;
  72     bool virtio; /* fastpath to check for virtio to deal with poll() quirks */
  73     GACommandState *command_state;
  74     GLogLevelFlags log_level;
  75     FILE *log_file;
  76     bool logging_enabled;
  77 #ifdef _WIN32
  78     GAService service;
  79 #endif
  80     bool delimit_response;
  81     bool frozen;
  82     GList *blacklist;
  83     char *state_filepath_isfrozen;
  84     struct {
  85         const char *log_filepath;
  86         const char *pid_filepath;
  87     } deferred_options;
  88 #ifdef CONFIG_FSFREEZE
  89     const char *fsfreeze_hook;
  90 #endif
  91     gchar *pstate_filepath;
  92     GAPersistentState pstate;
  93 };
  94
  95 struct GAState *ga_state;
  96 QmpCommandList ga_commands;
  97
  98 /* commands that are safe to issue while filesystems are frozen */
  99 static const char *ga_freeze_whitelist[] = {
 100     "guest-ping",
 101     "guest-info",
 102     "guest-sync",
 103     "guest-sync-delimited",
 104     "guest-fsfreeze-status",
 105     "guest-fsfreeze-thaw",
 106     NULL
 107 };
 108
 109 #ifdef _WIN32
 110 DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data,
 111                                   LPVOID ctx);
 112 VOID WINAPI service_main(DWORD argc, TCHAR *argv[]);
 113 #endif
 114
 115 static void
 116 init_dfl_pathnames(void)
 117 {
 118     g_assert(dfl_pathnames.state_dir == NULL);
 119     g_assert(dfl_pathnames.pidfile == NULL);
 120     dfl_pathnames.state_dir = qemu_get_local_state_pathname(
 121       QGA_STATE_RELATIVE_DIR);
 122     dfl_pathnames.pidfile   = qemu_get_local_state_pathname(
 123       QGA_STATE_RELATIVE_DIR G_DIR_SEPARATOR_S "qemu-ga.pid");
 124 }
 125
 126 static void quit_handler(int sig)
 127 {
 128     /* if we're frozen, don't exit unless we're absolutely forced to,
 129      * because it's basically impossible for graceful exit to complete
 130      * unless all log/pid files are on unfreezable filesystems. there's
 131      * also a very likely chance killing the agent before unfreezing
 132      * the filesystems is a mistake (or will be viewed as one later).
 133      * On Windows the freeze interval is limited to 10 seconds, so
 134      * we should quit, but first we should wait for the timeout, thaw
 135      * the filesystem and quit.
 136      */
 137     if (ga_is_frozen(ga_state)) {
 138 #ifdef _WIN32
 139         int i = 0;
 140         Error *err = NULL;
 141         HANDLE hEventTimeout;
 142
 143         g_debug("Thawing filesystems before exiting");
 144
 145         hEventTimeout = OpenEvent(EVENT_ALL_ACCESS, FALSE, EVENT_NAME_TIMEOUT);
 146         if (hEventTimeout) {
 147             WaitForSingleObject(hEventTimeout, 0);
 148             CloseHandle(hEventTimeout);
 149         }
 150         qga_vss_fsfreeze(&i, false, &err);
 151         if (err) {
 152             g_debug("Error unfreezing filesystems prior to exiting: %s",
 153                 error_get_pretty(err));
 154             error_free(err);
 155         }
 156 #else
 157         return;
 158 #endif
 159     }
 160     g_debug("received signal num %d, quitting", sig);
 161
 162     if (g_main_loop_is_running(ga_state->main_loop)) {
 163         g_main_loop_quit(ga_state->main_loop);
 164     }
 165 }
 166
 167 #ifndef _WIN32
 168 static gboolean register_signal_handlers(void)
 169 {
 170     struct sigaction sigact;
 171     int ret;
 172
 173     memset(&sigact, 0, sizeof(struct sigaction));
 174     sigact.sa_handler = quit_handler;
 175
 176     ret = sigaction(SIGINT, &sigact, NULL);
 177     if (ret == -1) {
 178         g_error("error configuring signal handler: %s", strerror(errno));
 179     }
 180     ret = sigaction(SIGTERM, &sigact, NULL);
 181     if (ret == -1) {
 182         g_error("error configuring signal handler: %s", strerror(errno));
 183     }
 184
 185     sigact.sa_handler = SIG_IGN;
 186     if (sigaction(SIGPIPE, &sigact, NULL) != 0) {
 187         g_error("error configuring SIGPIPE signal handler: %s",
 188                 strerror(errno));
 189     }
 190
 191     return true;
 192 }
 193
 194 /* TODO: use this in place of all post-fork() fclose(std*) callers */
 195 void reopen_fd_to_null(int fd)
 196 {
 197     int nullfd;
 198
 199     nullfd = open("/dev/null", O_RDWR);
 200     if (nullfd < 0) {
 201         return;
 202     }
 203
 204     dup2(nullfd, fd);
 205
 206     if (nullfd != fd) {
 207         close(nullfd);
 208     }
 209 }
 210 #endif
 211
 212 static void usage(const char *cmd)
 213 {
 214     printf(
 215 "Usage: %s [-m <method> -p <path>] [<options>]\n"
 216 "QEMU Guest Agent %s\n"
 217 "\n"
 218 "  -m, --method      transport method: one of unix-listen, virtio-serial,\n"
 219 "                    isa-serial, or vsock-listen (virtio-serial is the default)\n"
 220 "  -p, --path        device/socket path (the default for virtio-serial is:\n"
 221 "                    %s,\n"
 222 "                    the default for isa-serial is:\n"
 223 "                    %s)\n"
 224 "  -l, --logfile     set logfile path, logs to stderr by default\n"
 225 "  -f, --pidfile     specify pidfile (default is %s)\n"
 226 #ifdef CONFIG_FSFREEZE
 227 "  -F, --fsfreeze-hook\n"
 228 "                    enable fsfreeze hook. Accepts an optional argument that\n"
 229 "                    specifies script to run on freeze/thaw. Script will be\n"
 230 "                    called with 'freeze'/'thaw' arguments accordingly.\n"
 231 "                    (default is %s)\n"
 232 "                    If using -F with an argument, do not follow -F with a\n"
 233 "                    space.\n"
 234 "                    (for example: -F/var/run/fsfreezehook.sh)\n"
 235 #endif
 236 "  -t, --statedir    specify dir to store state information (absolute paths\n"
 237 "                    only, default is %s)\n"
 238 "  -v, --verbose     log extra debugging information\n"
 239 "  -V, --version     print version information and exit\n"
 240 "  -d, --daemonize   become a daemon\n"
 241 #ifdef _WIN32
 242 "  -s, --service     service commands: install, uninstall, vss-install, vss-uninstall\n"
 243 #endif
 244 "  -b, --blacklist   comma-separated list of RPCs to disable (no spaces, \"?\"\n"
 245 "                    to list available RPCs)\n"
 246 "  -D, --dump-conf   dump a qemu-ga config file based on current config\n"
 247 "                    options / command-line parameters to stdout\n"
 248 "  -h, --help        display this help and exit\n"
 249 "\n"
 250 "Report bugs to <mdroth@linux.vnet.ibm.com>\n"
 251     , cmd, QEMU_VERSION, QGA_VIRTIO_PATH_DEFAULT, QGA_SERIAL_PATH_DEFAULT,
 252     dfl_pathnames.pidfile,
 253 #ifdef CONFIG_FSFREEZE
 254     QGA_FSFREEZE_HOOK_DEFAULT,
 255 #endif
 256     dfl_pathnames.state_dir);
 257 }
 258
 259 static const char *ga_log_level_str(GLogLevelFlags level)
 260 {
 261     switch (level & G_LOG_LEVEL_MASK) {
 262         case G_LOG_LEVEL_ERROR:
 263             return "error";
 264         case G_LOG_LEVEL_CRITICAL:
 265             return "critical";
 266         case G_LOG_LEVEL_WARNING:
 267             return "warning";
 268         case G_LOG_LEVEL_MESSAGE:
 269             return "message";
 270         case G_LOG_LEVEL_INFO:
 271             return "info";
 272         case G_LOG_LEVEL_DEBUG:
 273             return "debug";
 274         default:
 275             return "user";
 276     }
 277 }
 278
 279 bool ga_logging_enabled(GAState *s)
 280 {
 281     return s->logging_enabled;
 282 }
 283
 284 void ga_disable_logging(GAState *s)
 285 {
 286     s->logging_enabled = false;
 287 }
 288
 289 void ga_enable_logging(GAState *s)
 290 {
 291     s->logging_enabled = true;
 292 }
 293
 294 static void ga_log(const gchar *domain, GLogLevelFlags level,
 295                    const gchar *msg, gpointer opaque)
 296 {
 297     GAState *s = opaque;
 298     GTimeVal time;
 299     const char *level_str = ga_log_level_str(level);
 300
 301     if (!ga_logging_enabled(s)) {
 302         return;
 303     }
 304
 305     level &= G_LOG_LEVEL_MASK;
 306 #ifndef _WIN32
 307     if (g_strcmp0(domain, "syslog") == 0) {
 308         syslog(LOG_INFO, "%s: %s", level_str, msg);
 309     } else if (level & s->log_level) {
 310 #else
 311     if (level & s->log_level) {
 312 #endif
 313         g_get_current_time(&time);
 314         fprintf(s->log_file,
 315                 "%lu.%lu: %s: %s\n", time.tv_sec, time.tv_usec, level_str, msg);
 316         fflush(s->log_file);
 317     }
 318 }
 319
 320 void ga_set_response_delimited(GAState *s)
 321 {
 322     s->delimit_response = true;
 323 }
 324
 325 static FILE *ga_open_logfile(const char *logfile)
 326 {
 327     FILE *f;
 328
 329     f = fopen(logfile, "a");
 330     if (!f) {
 331         return NULL;
 332     }
 333
 334     qemu_set_cloexec(fileno(f));
 335     return f;
 336 }
 337
 338 #ifndef _WIN32
 339 static bool ga_open_pidfile(const char *pidfile)
 340 {
 341     int pidfd;
 342     char pidstr[32];
 343
 344     pidfd = qemu_open(pidfile, O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR);
 345     if (pidfd == -1 || lockf(pidfd, F_TLOCK, 0)) {
 346         g_critical("Cannot lock pid file, %s", strerror(errno));
 347         if (pidfd != -1) {
 348             close(pidfd);
 349         }
 350         return false;
 351     }
 352
 353     if (ftruncate(pidfd, 0)) {
 354         g_critical("Failed to truncate pid file");
 355         goto fail;
 356     }
 357     snprintf(pidstr, sizeof(pidstr), "%d\n", getpid());
 358     if (write(pidfd, pidstr, strlen(pidstr)) != strlen(pidstr)) {
 359         g_critical("Failed to write pid file");
 360         goto fail;
 361     }
 362
 363     /* keep pidfile open & locked forever */
 364     return true;
 365
 366 fail:
 367     unlink(pidfile);
 368     close(pidfd);
 369     return false;
 370 }
 371 #else /* _WIN32 */
 372 static bool ga_open_pidfile(const char *pidfile)
 373 {
 374     return true;
 375 }
 376 #endif
 377
 378 static gint ga_strcmp(gconstpointer str1, gconstpointer str2)
 379 {
 380     return strcmp(str1, str2);
 381 }
 382
 383 /* disable commands that aren't safe for fsfreeze */
 384 static void ga_disable_non_whitelisted(QmpCommand *cmd, void *opaque)
 385 {
 386     bool whitelisted = false;
 387     int i = 0;
 388     const char *name = qmp_command_name(cmd);
 389
 390     while (ga_freeze_whitelist[i] != NULL) {
 391         if (strcmp(name, ga_freeze_whitelist[i]) == 0) {
 392             whitelisted = true;
 393         }
 394         i++;
 395     }
 396     if (!whitelisted) {
 397         g_debug("disabling command: %s", name);
 398         qmp_disable_command(&ga_commands, name);
 399     }
 400 }
 401
 402 /* [re-]enable all commands, except those explicitly blacklisted by user */
 403 static void ga_enable_non_blacklisted(QmpCommand *cmd, void *opaque)
 404 {
 405     GList *blacklist = opaque;
 406     const char *name = qmp_command_name(cmd);
 407
 408     if (g_list_find_custom(blacklist, name, ga_strcmp) == NULL &&
 409         !qmp_command_is_enabled(cmd)) {
 410         g_debug("enabling command: %s", name);
 411         qmp_enable_command(&ga_commands, name);
 412     }
 413 }
 414
 415 static bool ga_create_file(const char *path)
 416 {
 417     int fd = open(path, O_CREAT | O_WRONLY, S_IWUSR | S_IRUSR);
 418     if (fd == -1) {
 419         g_warning("unable to open/create file %s: %s", path, strerror(errno));
 420         return false;
 421     }
 422     close(fd);
 423     return true;
 424 }
 425
 426 static bool ga_delete_file(const char *path)
 427 {
 428     int ret = unlink(path);
 429     if (ret == -1) {
 430         g_warning("unable to delete file: %s: %s", path, strerror(errno));
 431         return false;
 432     }
 433
 434     return true;
 435 }
 436
 437 bool ga_is_frozen(GAState *s)
 438 {
 439     return s->frozen;
 440 }
 441
 442 void ga_set_frozen(GAState *s)
 443 {
 444     if (ga_is_frozen(s)) {
 445         return;
 446     }
 447     /* disable all non-whitelisted (for frozen state) commands */
 448     qmp_for_each_command(&ga_commands, ga_disable_non_whitelisted, NULL);
 449     g_warning("disabling logging due to filesystem freeze");
 450     ga_disable_logging(s);
 451     s->frozen = true;
 452     if (!ga_create_file(s->state_filepath_isfrozen)) {
 453         g_warning("unable to create %s, fsfreeze may not function properly",
 454                   s->state_filepath_isfrozen);
 455     }
 456 }
 457
 458 void ga_unset_frozen(GAState *s)
 459 {
 460     if (!ga_is_frozen(s)) {
 461         return;
 462     }
 463
 464     /* if we delayed creation/opening of pid/log files due to being
 465      * in a frozen state at start up, do it now
 466      */
 467     if (s->deferred_options.log_filepath) {
 468         s->log_file = ga_open_logfile(s->deferred_options.log_filepath);
 469         if (!s->log_file) {
 470             s->log_file = stderr;
 471         }
 472         s->deferred_options.log_filepath = NULL;
 473     }
 474     ga_enable_logging(s);
 475     g_warning("logging re-enabled due to filesystem unfreeze");
 476     if (s->deferred_options.pid_filepath) {
 477         if (!ga_open_pidfile(s->deferred_options.pid_filepath)) {
 478             g_warning("failed to create/open pid file");
 479         }
 480         s->deferred_options.pid_filepath = NULL;
 481     }
 482
 483     /* enable all disabled, non-blacklisted commands */
 484     qmp_for_each_command(&ga_commands, ga_enable_non_blacklisted, s->blacklist);
 485     s->frozen = false;
 486     if (!ga_delete_file(s->state_filepath_isfrozen)) {
 487         g_warning("unable to delete %s, fsfreeze may not function properly",
 488                   s->state_filepath_isfrozen);
 489     }
 490 }
 491
 492 #ifdef CONFIG_FSFREEZE
 493 const char *ga_fsfreeze_hook(GAState *s)
 494 {
 495     return s->fsfreeze_hook;
 496 }
 497 #endif
 498
 499 static void become_daemon(const char *pidfile)
 500 {
 501 #ifndef _WIN32
 502     pid_t pid, sid;
 503
 504     pid = fork();
 505     if (pid < 0) {
 506         exit(EXIT_FAILURE);
 507     }
 508     if (pid > 0) {
 509         exit(EXIT_SUCCESS);
 510     }
 511
 512     if (pidfile) {
 513         if (!ga_open_pidfile(pidfile)) {
 514             g_critical("failed to create pidfile");
 515             exit(EXIT_FAILURE);
 516         }
 517     }
 518
 519     umask(S_IRWXG | S_IRWXO);
 520     sid = setsid();
 521     if (sid < 0) {
 522         goto fail;
 523     }
 524     if ((chdir("/")) < 0) {
 525         goto fail;
 526     }
 527
 528     reopen_fd_to_null(STDIN_FILENO);
 529     reopen_fd_to_null(STDOUT_FILENO);
 530     reopen_fd_to_null(STDERR_FILENO);
 531     return;
 532
 533 fail:
 534     if (pidfile) {
 535         unlink(pidfile);
 536     }
 537     g_critical("failed to daemonize");
 538     exit(EXIT_FAILURE);
 539 #endif
 540 }
 541
 542 static int send_response(GAState *s, QObject *payload)
 543 {
 544     const char *buf;
 545     QString *payload_qstr, *response_qstr;
 546     GIOStatus status;
 547
 548     g_assert(payload && s->channel);
 549
 550     payload_qstr = qobject_to_json(payload);
 551     if (!payload_qstr) {
 552         return -EINVAL;
 553     }
 554
 555     if (s->delimit_response) {
 556         s->delimit_response = false;
 557         response_qstr = qstring_new();
 558         qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE);
 559         qstring_append(response_qstr, qstring_get_str(payload_qstr));
 560         QDECREF(payload_qstr);
 561     } else {
 562         response_qstr = payload_qstr;
 563     }
 564
 565     qstring_append_chr(response_qstr, '\n');
 566     buf = qstring_get_str(response_qstr);
 567     status = ga_channel_write_all(s->channel, buf, strlen(buf));
 568     QDECREF(response_qstr);
 569     if (status != G_IO_STATUS_NORMAL) {
 570         return -EIO;
 571     }
 572
 573     return 0;
 574 }
 575
 576 static void process_command(GAState *s, QDict *req)
 577 {
 578     QObject *rsp = NULL;
 579     int ret;
 580
 581     g_assert(req);
 582     g_debug("processing command");
 583     rsp = qmp_dispatch(&ga_commands, QOBJECT(req));
 584     if (rsp) {
 585         ret = send_response(s, rsp);
 586         if (ret < 0) {
 587             g_warning("error sending response: %s", strerror(-ret));
 588         }
 589         qobject_decref(rsp);
 590     }
 591 }
 592
 593 /* handle requests/control events coming in over the channel */
 594 static void process_event(JSONMessageParser *parser, GQueue *tokens)
 595 {
 596     GAState *s = container_of(parser, GAState, parser);
 597     QDict *qdict;
 598     Error *err = NULL;
 599     int ret;
 600
 601     g_assert(s && parser);
 602
 603     g_debug("process_event: called");
 604     qdict = qobject_to_qdict(json_parser_parse_err(tokens, NULL, &err));
 605     if (err || !qdict) {
 606         QDECREF(qdict);
 607         qdict = qdict_new();
 608         if (!err) {
 609             g_warning("failed to parse event: unknown error");
 610             error_setg(&err, QERR_JSON_PARSING);
 611         } else {
 612             g_warning("failed to parse event: %s", error_get_pretty(err));
 613         }
 614         qdict_put_obj(qdict, "error", qmp_build_error_object(err));
 615         error_free(err);
 616     }
 617
 618     /* handle host->guest commands */
 619     if (qdict_haskey(qdict, "execute")) {
 620         process_command(s, qdict);
 621     } else {
 622         if (!qdict_haskey(qdict, "error")) {
 623             QDECREF(qdict);
 624             qdict = qdict_new();
 625             g_warning("unrecognized payload format");
 626             error_setg(&err, QERR_UNSUPPORTED);
 627             qdict_put_obj(qdict, "error", qmp_build_error_object(err));
 628             error_free(err);
 629         }
 630         ret = send_response(s, QOBJECT(qdict));
 631         if (ret < 0) {
 632             g_warning("error sending error response: %s", strerror(-ret));
 633         }
 634     }
 635
 636     QDECREF(qdict);
 637 }
 638
 639 /* false return signals GAChannel to close the current client connection */
 640 static gboolean channel_event_cb(GIOCondition condition, gpointer data)
 641 {
 642     GAState *s = data;
 643     gchar buf[QGA_READ_COUNT_DEFAULT+1];
 644     gsize count;
 645     GIOStatus status = ga_channel_read(s->channel, buf, QGA_READ_COUNT_DEFAULT, &count);
 646     switch (status) {
 647     case G_IO_STATUS_ERROR:
 648         g_warning("error reading channel");
 649         return false;
 650     case G_IO_STATUS_NORMAL:
 651         buf[count] = 0;
 652         g_debug("read data, count: %d, data: %s", (int)count, buf);
 653         json_message_parser_feed(&s->parser, (char *)buf, (int)count);
 654         break;
 655     case G_IO_STATUS_EOF:
 656         g_debug("received EOF");
 657         if (!s->virtio) {
 658             return false;
 659         }
 660         /* fall through */
 661     case G_IO_STATUS_AGAIN:
 662         /* virtio causes us to spin here when no process is attached to
 663          * host-side chardev. sleep a bit to mitigate this
 664          */
 665         if (s->virtio) {
 666             usleep(100*1000);
 667         }
 668         return true;
 669     default:
 670         g_warning("unknown channel read status, closing");
 671         return false;
 672     }
 673     return true;
 674 }
 675
 676 static gboolean channel_init(GAState *s, const gchar *method, const gchar *path,
 677                              int listen_fd)
 678 {
 679     GAChannelMethod channel_method;
 680
 681     if (strcmp(method, "virtio-serial") == 0) {
 682         s->virtio = true; /* virtio requires special handling in some cases */
 683         channel_method = GA_CHANNEL_VIRTIO_SERIAL;
 684     } else if (strcmp(method, "isa-serial") == 0) {
 685         channel_method = GA_CHANNEL_ISA_SERIAL;
 686     } else if (strcmp(method, "unix-listen") == 0) {
 687         channel_method = GA_CHANNEL_UNIX_LISTEN;
 688     } else if (strcmp(method, "vsock-listen") == 0) {
 689         channel_method = GA_CHANNEL_VSOCK_LISTEN;
 690     } else {
 691         g_critical("unsupported channel method/type: %s", method);
 692         return false;
 693     }
 694
 695     s->channel = ga_channel_new(channel_method, path, listen_fd,
 696                                 channel_event_cb, s);
 697     if (!s->channel) {
 698         g_critical("failed to create guest agent channel");
 699         return false;
 700     }
 701
 702     return true;
 703 }
 704
 705 #ifdef _WIN32
 706 DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data,
 707                                   LPVOID ctx)
 708 {
 709     DWORD ret = NO_ERROR;
 710     GAService *service = &ga_state->service;
 711
 712     switch (ctrl)
 713     {
 714         case SERVICE_CONTROL_STOP:
 715         case SERVICE_CONTROL_SHUTDOWN:
 716             quit_handler(SIGTERM);
 717             service->status.dwCurrentState = SERVICE_STOP_PENDING;
 718             SetServiceStatus(service->status_handle, &service->status);
 719             break;
 720
 721         default:
 722             ret = ERROR_CALL_NOT_IMPLEMENTED;
 723     }
 724     return ret;
 725 }
 726
 727 VOID WINAPI service_main(DWORD argc, TCHAR *argv[])
 728 {
 729     GAService *service = &ga_state->service;
 730
 731     service->status_handle = RegisterServiceCtrlHandlerEx(QGA_SERVICE_NAME,
 732         service_ctrl_handler, NULL);
 733
 734     if (service->status_handle == 0) {
 735         g_critical("Failed to register extended requests function!\n");
 736         return;
 737     }
 738
 739     service->status.dwServiceType = SERVICE_WIN32;
 740     service->status.dwCurrentState = SERVICE_RUNNING;
 741     service->status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
 742     service->status.dwWin32ExitCode = NO_ERROR;
 743     service->status.dwServiceSpecificExitCode = NO_ERROR;
 744     service->status.dwCheckPoint = 0;
 745     service->status.dwWaitHint = 0;
 746     SetServiceStatus(service->status_handle, &service->status);
 747
 748     g_main_loop_run(ga_state->main_loop);
 749
 750     service->status.dwCurrentState = SERVICE_STOPPED;
 751     SetServiceStatus(service->status_handle, &service->status);
 752 }
 753 #endif
 754
 755 static void set_persistent_state_defaults(GAPersistentState *pstate)
 756 {
 757     g_assert(pstate);
 758     pstate->fd_counter = QGA_PSTATE_DEFAULT_FD_COUNTER;
 759 }
 760
 761 static void persistent_state_from_keyfile(GAPersistentState *pstate,
 762                                           GKeyFile *keyfile)
 763 {
 764     g_assert(pstate);
 765     g_assert(keyfile);
 766     /* if any fields are missing, either because the file was tampered with
 767      * by agents of chaos, or because the field wasn't present at the time the
 768      * file was created, the best we can ever do is start over with the default
 769      * values. so load them now, and ignore any errors in accessing key-value
 770      * pairs
 771      */
 772     set_persistent_state_defaults(pstate);
 773
 774     if (g_key_file_has_key(keyfile, "global", "fd_counter", NULL)) {
 775         pstate->fd_counter =
 776             g_key_file_get_integer(keyfile, "global", "fd_counter", NULL);
 777     }
 778 }
 779
 780 static void persistent_state_to_keyfile(const GAPersistentState *pstate,
 781                                         GKeyFile *keyfile)
 782 {
 783     g_assert(pstate);
 784     g_assert(keyfile);
 785
 786     g_key_file_set_integer(keyfile, "global", "fd_counter", pstate->fd_counter);
 787 }
 788
 789 static gboolean write_persistent_state(const GAPersistentState *pstate,
 790                                        const gchar *path)
 791 {
 792     GKeyFile *keyfile = g_key_file_new();
 793     GError *gerr = NULL;
 794     gboolean ret = true;
 795     gchar *data = NULL;
 796     gsize data_len;
 797
 798     g_assert(pstate);
 799
 800     persistent_state_to_keyfile(pstate, keyfile);
 801     data = g_key_file_to_data(keyfile, &data_len, &gerr);
 802     if (gerr) {
 803         g_critical("failed to convert persistent state to string: %s",
 804                    gerr->message);
 805         ret = false;
 806         goto out;
 807     }
 808
 809     g_file_set_contents(path, data, data_len, &gerr);
 810     if (gerr) {
 811         g_critical("failed to write persistent state to %s: %s",
 812                     path, gerr->message);
 813         ret = false;
 814         goto out;
 815     }
 816
 817 out:
 818     if (gerr) {
 819         g_error_free(gerr);
 820     }
 821     if (keyfile) {
 822         g_key_file_free(keyfile);
 823     }
 824     g_free(data);
 825     return ret;
 826 }
 827
 828 static gboolean read_persistent_state(GAPersistentState *pstate,
 829                                       const gchar *path, gboolean frozen)
 830 {
 831     GKeyFile *keyfile = NULL;
 832     GError *gerr = NULL;
 833     struct stat st;
 834     gboolean ret = true;
 835
 836     g_assert(pstate);
 837
 838     if (stat(path, &st) == -1) {
 839         /* it's okay if state file doesn't exist, but any other error
 840          * indicates a permissions issue or some other misconfiguration
 841          * that we likely won't be able to recover from.
 842          */
 843         if (errno != ENOENT) {
 844             g_critical("unable to access state file at path %s: %s",
 845                        path, strerror(errno));
 846             ret = false;
 847             goto out;
 848         }
 849
 850         /* file doesn't exist. initialize state to default values and
 851          * attempt to save now. (we could wait till later when we have
 852          * modified state we need to commit, but if there's a problem,
 853          * such as a missing parent directory, we want to catch it now)
 854          *
 855          * there is a potential scenario where someone either managed to
 856          * update the agent from a version that didn't use a key store
 857          * while qemu-ga thought the filesystem was frozen, or
 858          * deleted the key store prior to issuing a fsfreeze, prior
 859          * to restarting the agent. in this case we go ahead and defer
 860          * initial creation till we actually have modified state to
 861          * write, otherwise fail to recover from freeze.
 862          */
 863         set_persistent_state_defaults(pstate);
 864         if (!frozen) {
 865             ret = write_persistent_state(pstate, path);
 866             if (!ret) {
 867                 g_critical("unable to create state file at path %s", path);
 868                 ret = false;
 869                 goto out;
 870             }
 871         }
 872         ret = true;
 873         goto out;
 874     }
 875
 876     keyfile = g_key_file_new();
 877     g_key_file_load_from_file(keyfile, path, 0, &gerr);
 878     if (gerr) {
 879         g_critical("error loading persistent state from path: %s, %s",
 880                    path, gerr->message);
 881         ret = false;
 882         goto out;
 883     }
 884
 885     persistent_state_from_keyfile(pstate, keyfile);
 886
 887 out:
 888     if (keyfile) {
 889         g_key_file_free(keyfile);
 890     }
 891     if (gerr) {
 892         g_error_free(gerr);
 893     }
 894
 895     return ret;
 896 }
 897
 898 int64_t ga_get_fd_handle(GAState *s, Error **errp)
 899 {
 900     int64_t handle;
 901
 902     g_assert(s->pstate_filepath);
 903     /* we blacklist commands and avoid operations that potentially require
 904      * writing to disk when we're in a frozen state. this includes opening
 905      * new files, so we should never get here in that situation
 906      */
 907     g_assert(!ga_is_frozen(s));
 908
 909     handle = s->pstate.fd_counter++;
 910
 911     /* This should never happen on a reasonable timeframe, as guest-file-open
 912      * would have to be issued 2^63 times */
 913     if (s->pstate.fd_counter == INT64_MAX) {
 914         abort();
 915     }
 916
 917     if (!write_persistent_state(&s->pstate, s->pstate_filepath)) {
 918         error_setg(errp, "failed to commit persistent state to disk");
 919         return -1;
 920     }
 921
 922     return handle;
 923 }
 924
 925 static void ga_print_cmd(QmpCommand *cmd, void *opaque)
 926 {
 927     printf("%s\n", qmp_command_name(cmd));
 928 }
 929
 930 static GList *split_list(const gchar *str, const gchar *delim)
 931 {
 932     GList *list = NULL;
 933     int i;
 934     gchar **strv;
 935
 936     strv = g_strsplit(str, delim, -1);
 937     for (i = 0; strv[i]; i++) {
 938         list = g_list_prepend(list, strv[i]);
 939     }
 940     g_free(strv);
 941
 942     return list;
 943 }
 944
 945 typedef struct GAConfig {
 946     char *channel_path;
 947     char *method;
 948     char *log_filepath;
 949     char *pid_filepath;
 950 #ifdef CONFIG_FSFREEZE
 951     char *fsfreeze_hook;
 952 #endif
 953     char *state_dir;
 954 #ifdef _WIN32
 955     const char *service;
 956 #endif
 957     gchar *bliststr; /* blacklist may point to this string */
 958     GList *blacklist;
 959     int daemonize;
 960     GLogLevelFlags log_level;
 961     int dumpconf;
 962 } GAConfig;
 963
 964 static void config_load(GAConfig *config)
 965 {
 966     GError *gerr = NULL;
 967     GKeyFile *keyfile;
 968     const char *conf = g_getenv("QGA_CONF") ?: QGA_CONF_DEFAULT;
 969
 970     /* read system config */
 971     keyfile = g_key_file_new();
 972     if (!g_key_file_load_from_file(keyfile, conf, 0, &gerr)) {
 973         goto end;
 974     }
 975     if (g_key_file_has_key(keyfile, "general", "daemon", NULL)) {
 976         config->daemonize =
 977             g_key_file_get_boolean(keyfile, "general", "daemon", &gerr);
 978     }
 979     if (g_key_file_has_key(keyfile, "general", "method", NULL)) {
 980         config->method =
 981             g_key_file_get_string(keyfile, "general", "method", &gerr);
 982     }
 983     if (g_key_file_has_key(keyfile, "general", "path", NULL)) {
 984         config->channel_path =
 985             g_key_file_get_string(keyfile, "general", "path", &gerr);
 986     }
 987     if (g_key_file_has_key(keyfile, "general", "logfile", NULL)) {
 988         config->log_filepath =
 989             g_key_file_get_string(keyfile, "general", "logfile", &gerr);
 990     }
 991     if (g_key_file_has_key(keyfile, "general", "pidfile", NULL)) {
 992         config->pid_filepath =
 993             g_key_file_get_string(keyfile, "general", "pidfile", &gerr);
 994     }
 995 #ifdef CONFIG_FSFREEZE
 996     if (g_key_file_has_key(keyfile, "general", "fsfreeze-hook", NULL)) {
 997         config->fsfreeze_hook =
 998             g_key_file_get_string(keyfile,
 999                                   "general", "fsfreeze-hook", &gerr);
1000     }
1001 #endif
1002     if (g_key_file_has_key(keyfile, "general", "statedir", NULL)) {
1003         config->state_dir =
1004             g_key_file_get_string(keyfile, "general", "statedir", &gerr);
1005     }
1006     if (g_key_file_has_key(keyfile, "general", "verbose", NULL) &&
1007         g_key_file_get_boolean(keyfile, "general", "verbose", &gerr)) {
1008         /* enable all log levels */
1009         config->log_level = G_LOG_LEVEL_MASK;
1010     }
1011     if (g_key_file_has_key(keyfile, "general", "blacklist", NULL)) {
1012         config->bliststr =
1013             g_key_file_get_string(keyfile, "general", "blacklist", &gerr);
1014         config->blacklist = g_list_concat(config->blacklist,
1015                                           split_list(config->bliststr, ","));
1016     }
1017
1018 end:
1019     g_key_file_free(keyfile);
1020     if (gerr &&
1021         !(gerr->domain == G_FILE_ERROR && gerr->code == G_FILE_ERROR_NOENT)) {
1022         g_critical("error loading configuration from path: %s, %s",
1023                    QGA_CONF_DEFAULT, gerr->message);
1024         exit(EXIT_FAILURE);
1025     }
1026     g_clear_error(&gerr);
1027 }
1028
1029 static gchar *list_join(GList *list, const gchar separator)
1030 {
1031     GString *str = g_string_new("");
1032
1033     while (list) {
1034         str = g_string_append(str, (gchar *)list->data);
1035         list = g_list_next(list);
1036         if (list) {
1037             str = g_string_append_c(str, separator);
1038         }
1039     }
1040
1041     return g_string_free(str, FALSE);
1042 }
1043
1044 static void config_dump(GAConfig *config)
1045 {
1046     GError *error = NULL;
1047     GKeyFile *keyfile;
1048     gchar *tmp;
1049
1050     keyfile = g_key_file_new();
1051     g_assert(keyfile);
1052
1053     g_key_file_set_boolean(keyfile, "general", "daemon", config->daemonize);
1054     g_key_file_set_string(keyfile, "general", "method", config->method);
1055     if (config->channel_path) {
1056         g_key_file_set_string(keyfile, "general", "path", config->channel_path);
1057     }
1058     if (config->log_filepath) {
1059         g_key_file_set_string(keyfile, "general", "logfile",
1060                               config->log_filepath);
1061     }
1062     g_key_file_set_string(keyfile, "general", "pidfile", config->pid_filepath);
1063 #ifdef CONFIG_FSFREEZE
1064     if (config->fsfreeze_hook) {
1065         g_key_file_set_string(keyfile, "general", "fsfreeze-hook",
1066                               config->fsfreeze_hook);
1067     }
1068 #endif
1069     g_key_file_set_string(keyfile, "general", "statedir", config->state_dir);
1070     g_key_file_set_boolean(keyfile, "general", "verbose",
1071                            config->log_level == G_LOG_LEVEL_MASK);
1072     tmp = list_join(config->blacklist, ',');
1073     g_key_file_set_string(keyfile, "general", "blacklist", tmp);
1074     g_free(tmp);
1075
1076     tmp = g_key_file_to_data(keyfile, NULL, &error);
1077     printf("%s", tmp);
1078
1079     g_free(tmp);
1080     g_key_file_free(keyfile);
1081 }
1082
1083 static void config_parse(GAConfig *config, int argc, char **argv)
1084 {
1085     const char *sopt = "hVvdm:p:l:f:F::b:s:t:D";
1086     int opt_ind = 0, ch;
1087     const struct option lopt[] = {
1088         { "help", 0, NULL, 'h' },
1089         { "version", 0, NULL, 'V' },
1090         { "dump-conf", 0, NULL, 'D' },
1091         { "logfile", 1, NULL, 'l' },
1092         { "pidfile", 1, NULL, 'f' },
1093 #ifdef CONFIG_FSFREEZE
1094         { "fsfreeze-hook", 2, NULL, 'F' },
1095 #endif
1096         { "verbose", 0, NULL, 'v' },
1097         { "method", 1, NULL, 'm' },
1098         { "path", 1, NULL, 'p' },
1099         { "daemonize", 0, NULL, 'd' },
1100         { "blacklist", 1, NULL, 'b' },
1101 #ifdef _WIN32
1102         { "service", 1, NULL, 's' },
1103 #endif
1104         { "statedir", 1, NULL, 't' },
1105         { NULL, 0, NULL, 0 }
1106     };
1107
1108     while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
1109         switch (ch) {
1110         case 'm':
1111             g_free(config->method);
1112             config->method = g_strdup(optarg);
1113             break;
1114         case 'p':
1115             g_free(config->channel_path);
1116             config->channel_path = g_strdup(optarg);
1117             break;
1118         case 'l':
1119             g_free(config->log_filepath);
1120             config->log_filepath = g_strdup(optarg);
1121             break;
1122         case 'f':
1123             g_free(config->pid_filepath);
1124             config->pid_filepath = g_strdup(optarg);
1125             break;
1126 #ifdef CONFIG_FSFREEZE
1127         case 'F':
1128             g_free(config->fsfreeze_hook);
1129             config->fsfreeze_hook = g_strdup(optarg ?: QGA_FSFREEZE_HOOK_DEFAULT);
1130             break;
1131 #endif
1132         case 't':
1133             g_free(config->state_dir);
1134             config->state_dir = g_strdup(optarg);
1135             break;
1136         case 'v':
1137             /* enable all log levels */
1138             config->log_level = G_LOG_LEVEL_MASK;
1139             break;
1140         case 'V':
1141             printf("QEMU Guest Agent %s\n", QEMU_VERSION);
1142             exit(EXIT_SUCCESS);
1143         case 'd':
1144             config->daemonize = 1;
1145             break;
1146         case 'D':
1147             config->dumpconf = 1;
1148             break;
1149         case 'b': {
1150             if (is_help_option(optarg)) {
1151                 qmp_for_each_command(&ga_commands, ga_print_cmd, NULL);
1152                 exit(EXIT_SUCCESS);
1153             }
1154             config->blacklist = g_list_concat(config->blacklist,
1155                                              split_list(optarg, ","));
1156             break;
1157         }
1158 #ifdef _WIN32
1159         case 's':
1160             config->service = optarg;
1161             if (strcmp(config->service, "install") == 0) {
1162                 if (ga_install_vss_provider()) {
1163                     exit(EXIT_FAILURE);
1164                 }
1165                 if (ga_install_service(config->channel_path,
1166                                        config->log_filepath, config->state_dir)) {
1167                     exit(EXIT_FAILURE);
1168                 }
1169                 exit(EXIT_SUCCESS);
1170             } else if (strcmp(config->service, "uninstall") == 0) {
1171                 ga_uninstall_vss_provider();
1172                 exit(ga_uninstall_service());
1173             } else if (strcmp(config->service, "vss-install") == 0) {
1174                 if (ga_install_vss_provider()) {
1175                     exit(EXIT_FAILURE);
1176                 }
1177                 exit(EXIT_SUCCESS);
1178             } else if (strcmp(config->service, "vss-uninstall") == 0) {
1179                 ga_uninstall_vss_provider();
1180                 exit(EXIT_SUCCESS);
1181             } else {
1182                 printf("Unknown service command.\n");
1183                 exit(EXIT_FAILURE);
1184             }
1185             break;
1186 #endif
1187         case 'h':
1188             usage(argv[0]);
1189             exit(EXIT_SUCCESS);
1190         case '?':
1191             g_print("Unknown option, try '%s --help' for more information.\n",
1192                     argv[0]);
1193             exit(EXIT_FAILURE);
1194         }
1195     }
1196 }
1197
1198 static void config_free(GAConfig *config)
1199 {
1200     g_free(config->method);
1201     g_free(config->log_filepath);
1202     g_free(config->pid_filepath);
1203     g_free(config->state_dir);
1204     g_free(config->channel_path);
1205     g_free(config->bliststr);
1206 #ifdef CONFIG_FSFREEZE
1207     g_free(config->fsfreeze_hook);
1208 #endif
1209     g_list_free_full(config->blacklist, g_free);
1210     g_free(config);
1211 }
1212
1213 static bool check_is_frozen(GAState *s)
1214 {
1215 #ifndef _WIN32
1216     /* check if a previous instance of qemu-ga exited with filesystems' state
1217      * marked as frozen. this could be a stale value (a non-qemu-ga process
1218      * or reboot may have since unfrozen them), but better to require an
1219      * uneeded unfreeze than to risk hanging on start-up
1220      */
1221     struct stat st;
1222     if (stat(s->state_filepath_isfrozen, &st) == -1) {
1223         /* it's okay if the file doesn't exist, but if we can't access for
1224          * some other reason, such as permissions, there's a configuration
1225          * that needs to be addressed. so just bail now before we get into
1226          * more trouble later
1227          */
1228         if (errno != ENOENT) {
1229             g_critical("unable to access state file at path %s: %s",
1230                        s->state_filepath_isfrozen, strerror(errno));
1231             return EXIT_FAILURE;
1232         }
1233     } else {
1234         g_warning("previous instance appears to have exited with frozen"
1235                   " filesystems. deferring logging/pidfile creation and"
1236                   " disabling non-fsfreeze-safe commands until"
1237                   " guest-fsfreeze-thaw is issued, or filesystems are"
1238                   " manually unfrozen and the file %s is removed",
1239                   s->state_filepath_isfrozen);
1240         return true;
1241     }
1242 #endif
1243     return false;
1244 }
1245
1246 static int run_agent(GAState *s, GAConfig *config, int socket_activation)
1247 {
1248     ga_state = s;
1249
1250     g_log_set_default_handler(ga_log, s);
1251     g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
1252     ga_enable_logging(s);
1253
1254 #ifdef _WIN32
1255     /* On win32 the state directory is application specific (be it the default
1256      * or a user override). We got past the command line parsing; let's create
1257      * the directory (with any intermediate directories). If we run into an
1258      * error later on, we won't try to clean up the directory, it is considered
1259      * persistent.
1260      */
1261     if (g_mkdir_with_parents(config->state_dir, S_IRWXU) == -1) {
1262         g_critical("unable to create (an ancestor of) the state directory"
1263                    " '%s': %s", config->state_dir, strerror(errno));
1264         return EXIT_FAILURE;
1265     }
1266 #endif
1267
1268     if (ga_is_frozen(s)) {
1269         if (config->daemonize) {
1270             /* delay opening/locking of pidfile till filesystems are unfrozen */
1271             s->deferred_options.pid_filepath = config->pid_filepath;
1272             become_daemon(NULL);
1273         }
1274         if (config->log_filepath) {
1275             /* delay opening the log file till filesystems are unfrozen */
1276             s->deferred_options.log_filepath = config->log_filepath;
1277         }
1278         ga_disable_logging(s);
1279         qmp_for_each_command(&ga_commands, ga_disable_non_whitelisted, NULL);
1280     } else {
1281         if (config->daemonize) {
1282             become_daemon(config->pid_filepath);
1283         }
1284         if (config->log_filepath) {
1285             FILE *log_file = ga_open_logfile(config->log_filepath);
1286             if (!log_file) {
1287                 g_critical("unable to open specified log file: %s",
1288                            strerror(errno));
1289                 return EXIT_FAILURE;
1290             }
1291             s->log_file = log_file;
1292         }
1293     }
1294
1295     /* load persistent state from disk */
1296     if (!read_persistent_state(&s->pstate,
1297                                s->pstate_filepath,
1298                                ga_is_frozen(s))) {
1299         g_critical("failed to load persistent state");
1300         return EXIT_FAILURE;
1301     }
1302
1303     config->blacklist = ga_command_blacklist_init(config->blacklist);
1304     if (config->blacklist) {
1305         GList *l = config->blacklist;
1306         s->blacklist = config->blacklist;
1307         do {
1308             g_debug("disabling command: %s", (char *)l->data);
1309             qmp_disable_command(&ga_commands, l->data);
1310             l = g_list_next(l);
1311         } while (l);
1312     }
1313     s->command_state = ga_command_state_new();
1314     ga_command_state_init(s, s->command_state);
1315     ga_command_state_init_all(s->command_state);
1316     json_message_parser_init(&s->parser, process_event);
1317     ga_state = s;
1318 #ifndef _WIN32
1319     if (!register_signal_handlers()) {
1320         g_critical("failed to register signal handlers");
1321         return EXIT_FAILURE;
1322     }
1323 #endif
1324
1325     s->main_loop = g_main_loop_new(NULL, false);
1326
1327     if (!channel_init(ga_state, config->method, config->channel_path,
1328                       socket_activation ? FIRST_SOCKET_ACTIVATION_FD : -1)) {
1329         g_critical("failed to initialize guest agent channel");
1330         return EXIT_FAILURE;
1331     }
1332 #ifndef _WIN32
1333     g_main_loop_run(ga_state->main_loop);
1334 #else
1335     if (config->daemonize) {
1336         SERVICE_TABLE_ENTRY service_table[] = {
1337             { (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } };
1338         StartServiceCtrlDispatcher(service_table);
1339     } else {
1340         g_main_loop_run(ga_state->main_loop);
1341     }
1342 #endif
1343
1344     return EXIT_SUCCESS;
1345 }
1346
1347 int main(int argc, char **argv)
1348 {
1349     int ret = EXIT_SUCCESS;
1350     GAState *s = g_new0(GAState, 1);
1351     GAConfig *config = g_new0(GAConfig, 1);
1352     int socket_activation;
1353
1354     config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
1355
1356     qga_qmp_init_marshal(&ga_commands);
1357
1358     init_dfl_pathnames();
1359     config_load(config);
1360     config_parse(config, argc, argv);
1361
1362     if (config->pid_filepath == NULL) {
1363         config->pid_filepath = g_strdup(dfl_pathnames.pidfile);
1364     }
1365
1366     if (config->state_dir == NULL) {
1367         config->state_dir = g_strdup(dfl_pathnames.state_dir);
1368     }
1369
1370     if (config->method == NULL) {
1371         config->method = g_strdup("virtio-serial");
1372     }
1373
1374     socket_activation = check_socket_activation();
1375     if (socket_activation > 1) {
1376         g_critical("qemu-ga only supports listening on one socket");
1377         ret = EXIT_FAILURE;
1378         goto end;
1379     }
1380     if (socket_activation) {
1381         SocketAddress *addr;
1382
1383         g_free(config->method);
1384         g_free(config->channel_path);
1385         config->method = NULL;
1386         config->channel_path = NULL;
1387
1388         addr = socket_local_address(FIRST_SOCKET_ACTIVATION_FD, NULL);
1389         if (addr) {
1390             if (addr->type == SOCKET_ADDRESS_TYPE_UNIX) {
1391                 config->method = g_strdup("unix-listen");
1392             } else if (addr->type == SOCKET_ADDRESS_TYPE_VSOCK) {
1393                 config->method = g_strdup("vsock-listen");
1394             }
1395
1396             qapi_free_SocketAddress(addr);
1397         }
1398
1399         if (!config->method) {
1400             g_critical("unsupported listen fd type");
1401             ret = EXIT_FAILURE;
1402             goto end;
1403         }
1404     } else if (config->channel_path == NULL) {
1405         if (strcmp(config->method, "virtio-serial") == 0) {
1406             /* try the default path for the virtio-serial port */
1407             config->channel_path = g_strdup(QGA_VIRTIO_PATH_DEFAULT);
1408         } else if (strcmp(config->method, "isa-serial") == 0) {
1409             /* try the default path for the serial port - COM1 */
1410             config->channel_path = g_strdup(QGA_SERIAL_PATH_DEFAULT);
1411         } else {
1412             g_critical("must specify a path for this channel");
1413             ret = EXIT_FAILURE;
1414             goto end;
1415         }
1416     }
1417
1418     s->log_level = config->log_level;
1419     s->log_file = stderr;
1420 #ifdef CONFIG_FSFREEZE
1421     s->fsfreeze_hook = config->fsfreeze_hook;
1422 #endif
1423     s->pstate_filepath = g_strdup_printf("%s/qga.state", config->state_dir);
1424     s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
1425                                                  config->state_dir);
1426     s->frozen = check_is_frozen(s);
1427
1428     if (config->dumpconf) {
1429         config_dump(config);
1430         goto end;
1431     }
1432
1433     ret = run_agent(s, config, socket_activation);
1434
1435 end:
1436     if (s->command_state) {
1437         ga_command_state_cleanup_all(s->command_state);
1438         ga_command_state_free(s->command_state);
1439         json_message_parser_destroy(&s->parser);
1440     }
1441     if (s->channel) {
1442         ga_channel_free(s->channel);
1443     }
1444     g_free(s->pstate_filepath);
1445     g_free(s->state_filepath_isfrozen);
1446
1447     if (config->daemonize) {
1448         unlink(config->pid_filepath);
1449     }
1450
1451     config_free(config);
1452     if (s->main_loop) {
1453         g_main_loop_unref(s->main_loop);
1454     }
1455     g_free(s);
1456
1457     return ret;
1458 }