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