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