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