xref: /openbmc/qemu/qga/commands-posix.c (revision fac933ca) 
1 /*
2  * QEMU Guest Agent POSIX-specific command implementations
3  *
4  * Copyright IBM Corp. 2011
5  *
6  * Authors:
7  *  Michael Roth      <mdroth@linux.vnet.ibm.com>
8  *  Michal Privoznik  <mprivozn@redhat.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 <sys/ioctl.h>
16 #include <sys/utsname.h>
17 #include <sys/wait.h>
18 #include <dirent.h>
19 #include "qga-qapi-commands.h"
20 #include "qapi/error.h"
21 #include "qapi/qmp/qerror.h"
22 #include "qemu/host-utils.h"
23 #include "qemu/sockets.h"
24 #include "qemu/base64.h"
25 #include "qemu/cutils.h"
26 #include "commands-common.h"
27 #include "cutils.h"
28 
29 #ifdef HAVE_UTMPX
30 #include <utmpx.h>
31 #endif
32 
33 #ifdef HAVE_GETIFADDRS
34 #include <arpa/inet.h>
35 #include <sys/socket.h>
36 #include <net/if.h>
37 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(CONFIG_SOLARIS)
38 #include <net/if_arp.h>
39 #include <netinet/if_ether.h>
40 #if !defined(ETHER_ADDR_LEN) && defined(ETHERADDRL)
41 #define ETHER_ADDR_LEN ETHERADDRL
42 #endif
43 #else
44 #include <net/ethernet.h>
45 #endif
46 #ifdef CONFIG_SOLARIS
47 #include <sys/sockio.h>
48 #endif
49 #endif
50 
ga_wait_child(pid_t pid,int * status,Error ** errp)51 static bool ga_wait_child(pid_t pid, int *status, Error **errp)
52 {
53     pid_t rpid;
54 
55     *status = 0;
56 
57     rpid = RETRY_ON_EINTR(waitpid(pid, status, 0));
58 
59     if (rpid == -1) {
60         error_setg_errno(errp, errno, "failed to wait for child (pid: %d)",
61                          pid);
62         return false;
63     }
64 
65     g_assert(rpid == pid);
66     return true;
67 }
68 
ga_pipe_read_str(int fd[2],char ** str)69 static ssize_t ga_pipe_read_str(int fd[2], char **str)
70 {
71     ssize_t n, len = 0;
72     char buf[1024];
73 
74     close(fd[1]);
75     fd[1] = -1;
76     while ((n = read(fd[0], buf, sizeof(buf))) != 0) {
77         if (n < 0) {
78             if (errno == EINTR) {
79                 continue;
80             } else {
81                 len = -errno;
82                 break;
83             }
84         }
85         *str = g_realloc(*str, len + n + 1);
86         memcpy(*str + len, buf, n);
87         len += n;
88         (*str)[len] = '\0';
89     }
90     close(fd[0]);
91     fd[0] = -1;
92 
93     return len;
94 }
95 
96 /*
97  * Helper to run command with input/output redirection,
98  * sending string to stdin and taking error message from
99  * stdout/err.
100  */
ga_run_command(const char * argv[],const char * in_str,const char * action,Error ** errp)101 static int ga_run_command(const char *argv[], const char *in_str,
102                           const char *action, Error **errp)
103 {
104     pid_t pid;
105     int status;
106     int retcode = -1;
107     int infd[2] = { -1, -1 };
108     int outfd[2] = { -1, -1 };
109     char *str = NULL;
110     ssize_t len = 0;
111 
112     if ((in_str && !g_unix_open_pipe(infd, FD_CLOEXEC, NULL)) ||
113         !g_unix_open_pipe(outfd, FD_CLOEXEC, NULL)) {
114         error_setg(errp, "cannot create pipe FDs");
115         goto out;
116     }
117 
118     pid = fork();
119     if (pid == 0) {
120         char *cherr = NULL;
121 
122         setsid();
123 
124         if (in_str) {
125             /* Redirect stdin to infd. */
126             close(infd[1]);
127             dup2(infd[0], 0);
128             close(infd[0]);
129         } else {
130             reopen_fd_to_null(0);
131         }
132 
133         /* Redirect stdout/stderr to outfd. */
134         close(outfd[0]);
135         dup2(outfd[1], 1);
136         dup2(outfd[1], 2);
137         close(outfd[1]);
138 
139         execvp(argv[0], (char *const *)argv);
140 
141         /* Write the cause of failed exec to pipe for the parent to read it. */
142         cherr = g_strdup_printf("failed to exec '%s'", argv[0]);
143         perror(cherr);
144         g_free(cherr);
145         _exit(EXIT_FAILURE);
146     } else if (pid < 0) {
147         error_setg_errno(errp, errno, "failed to create child process");
148         goto out;
149     }
150 
151     if (in_str) {
152         close(infd[0]);
153         infd[0] = -1;
154         if (qemu_write_full(infd[1], in_str, strlen(in_str)) !=
155                 strlen(in_str)) {
156             error_setg_errno(errp, errno, "%s: cannot write to stdin pipe",
157                              action);
158             goto out;
159         }
160         close(infd[1]);
161         infd[1] = -1;
162     }
163 
164     len = ga_pipe_read_str(outfd, &str);
165     if (len < 0) {
166         error_setg_errno(errp, -len, "%s: cannot read from stdout/stderr pipe",
167                          action);
168         goto out;
169     }
170 
171     if (!ga_wait_child(pid, &status, errp)) {
172         goto out;
173     }
174 
175     if (!WIFEXITED(status)) {
176         if (len) {
177             error_setg(errp, "child process has terminated abnormally: %s",
178                        str);
179         } else {
180             error_setg(errp, "child process has terminated abnormally");
181         }
182         goto out;
183     }
184 
185     retcode = WEXITSTATUS(status);
186 
187     if (WEXITSTATUS(status)) {
188         if (len) {
189             error_setg(errp, "child process has failed to %s: %s",
190                        action, str);
191         } else {
192             error_setg(errp, "child process has failed to %s: exit status %d",
193                        action, WEXITSTATUS(status));
194         }
195         goto out;
196     }
197 
198 out:
199     g_free(str);
200 
201     if (infd[0] != -1) {
202         close(infd[0]);
203     }
204     if (infd[1] != -1) {
205         close(infd[1]);
206     }
207     if (outfd[0] != -1) {
208         close(outfd[0]);
209     }
210     if (outfd[1] != -1) {
211         close(outfd[1]);
212     }
213 
214     return retcode;
215 }
216 
qmp_guest_shutdown(const char * mode,Error ** errp)217 void qmp_guest_shutdown(const char *mode, Error **errp)
218 {
219     const char *shutdown_flag;
220     Error *local_err = NULL;
221 
222 #ifdef CONFIG_SOLARIS
223     const char *powerdown_flag = "-i5";
224     const char *halt_flag = "-i0";
225     const char *reboot_flag = "-i6";
226 #elif defined(CONFIG_BSD)
227     const char *powerdown_flag = "-p";
228     const char *halt_flag = "-h";
229     const char *reboot_flag = "-r";
230 #else
231     const char *powerdown_flag = "-P";
232     const char *halt_flag = "-H";
233     const char *reboot_flag = "-r";
234 #endif
235 
236     slog("guest-shutdown called, mode: %s", mode);
237     if (!mode || strcmp(mode, "powerdown") == 0) {
238         shutdown_flag = powerdown_flag;
239     } else if (strcmp(mode, "halt") == 0) {
240         shutdown_flag = halt_flag;
241     } else if (strcmp(mode, "reboot") == 0) {
242         shutdown_flag = reboot_flag;
243     } else {
244         error_setg(errp,
245                    "mode is invalid (valid values are: halt|powerdown|reboot");
246         return;
247     }
248 
249     const char *argv[] = {"/sbin/shutdown",
250 #ifdef CONFIG_SOLARIS
251                           shutdown_flag, "-g0", "-y",
252 #elif defined(CONFIG_BSD)
253                           shutdown_flag, "+0",
254 #else
255                           "-h", shutdown_flag, "+0",
256 #endif
257                           "hypervisor initiated shutdown", (char *) NULL};
258 
259     ga_run_command(argv, NULL, "shutdown", &local_err);
260     if (local_err) {
261         error_propagate(errp, local_err);
262         return;
263     }
264 
265     /* succeeded */
266 }
267 
qmp_guest_set_time(bool has_time,int64_t time_ns,Error ** errp)268 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
269 {
270     int ret;
271     Error *local_err = NULL;
272     struct timeval tv;
273     const char *argv[] = {"/sbin/hwclock", has_time ? "-w" : "-s", NULL};
274 
275     /* If user has passed a time, validate and set it. */
276     if (has_time) {
277         GDate date = { 0, };
278 
279         /* year-2038 will overflow in case time_t is 32bit */
280         if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) {
281             error_setg(errp, "Time %" PRId64 " is too large", time_ns);
282             return;
283         }
284 
285         tv.tv_sec = time_ns / 1000000000;
286         tv.tv_usec = (time_ns % 1000000000) / 1000;
287         g_date_set_time_t(&date, tv.tv_sec);
288         if (date.year < 1970 || date.year >= 2070) {
289             error_setg_errno(errp, errno, "Invalid time");
290             return;
291         }
292 
293         ret = settimeofday(&tv, NULL);
294         if (ret < 0) {
295             error_setg_errno(errp, errno, "Failed to set time to guest");
296             return;
297         }
298     }
299 
300     /* Now, if user has passed a time to set and the system time is set, we
301      * just need to synchronize the hardware clock. However, if no time was
302      * passed, user is requesting the opposite: set the system time from the
303      * hardware clock (RTC). */
304     ga_run_command(argv, NULL, "set hardware clock to system time",
305                    &local_err);
306     if (local_err) {
307         error_propagate(errp, local_err);
308         return;
309     }
310 }
311 
312 typedef enum {
313     RW_STATE_NEW,
314     RW_STATE_READING,
315     RW_STATE_WRITING,
316 } RwState;
317 
318 struct GuestFileHandle {
319     uint64_t id;
320     FILE *fh;
321     RwState state;
322     QTAILQ_ENTRY(GuestFileHandle) next;
323 };
324 
325 static struct {
326     QTAILQ_HEAD(, GuestFileHandle) filehandles;
327 } guest_file_state = {
328     .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles),
329 };
330 
guest_file_handle_add(FILE * fh,Error ** errp)331 static int64_t guest_file_handle_add(FILE *fh, Error **errp)
332 {
333     GuestFileHandle *gfh;
334     int64_t handle;
335 
336     handle = ga_get_fd_handle(ga_state, errp);
337     if (handle < 0) {
338         return -1;
339     }
340 
341     gfh = g_new0(GuestFileHandle, 1);
342     gfh->id = handle;
343     gfh->fh = fh;
344     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
345 
346     return handle;
347 }
348 
guest_file_handle_find(int64_t id,Error ** errp)349 GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
350 {
351     GuestFileHandle *gfh;
352 
353     QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
354     {
355         if (gfh->id == id) {
356             return gfh;
357         }
358     }
359 
360     error_setg(errp, "handle '%" PRId64 "' has not been found", id);
361     return NULL;
362 }
363 
364 typedef const char * const ccpc;
365 
366 #ifndef O_BINARY
367 #define O_BINARY 0
368 #endif
369 
370 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */
371 static const struct {
372     ccpc *forms;
373     int oflag_base;
374 } guest_file_open_modes[] = {
375     { (ccpc[]){ "r",          NULL }, O_RDONLY                                 },
376     { (ccpc[]){ "rb",         NULL }, O_RDONLY                      | O_BINARY },
377     { (ccpc[]){ "w",          NULL }, O_WRONLY | O_CREAT | O_TRUNC             },
378     { (ccpc[]){ "wb",         NULL }, O_WRONLY | O_CREAT | O_TRUNC  | O_BINARY },
379     { (ccpc[]){ "a",          NULL }, O_WRONLY | O_CREAT | O_APPEND            },
380     { (ccpc[]){ "ab",         NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY },
381     { (ccpc[]){ "r+",         NULL }, O_RDWR                                   },
382     { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR                        | O_BINARY },
383     { (ccpc[]){ "w+",         NULL }, O_RDWR   | O_CREAT | O_TRUNC             },
384     { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR   | O_CREAT | O_TRUNC  | O_BINARY },
385     { (ccpc[]){ "a+",         NULL }, O_RDWR   | O_CREAT | O_APPEND            },
386     { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR   | O_CREAT | O_APPEND | O_BINARY }
387 };
388 
389 static int
find_open_flag(const char * mode_str,Error ** errp)390 find_open_flag(const char *mode_str, Error **errp)
391 {
392     unsigned mode;
393 
394     for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
395         ccpc *form;
396 
397         form = guest_file_open_modes[mode].forms;
398         while (*form != NULL && strcmp(*form, mode_str) != 0) {
399             ++form;
400         }
401         if (*form != NULL) {
402             break;
403         }
404     }
405 
406     if (mode == ARRAY_SIZE(guest_file_open_modes)) {
407         error_setg(errp, "invalid file open mode '%s'", mode_str);
408         return -1;
409     }
410     return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK;
411 }
412 
413 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \
414                                S_IRGRP | S_IWGRP | \
415                                S_IROTH | S_IWOTH)
416 
417 static FILE *
safe_open_or_create(const char * path,const char * mode,Error ** errp)418 safe_open_or_create(const char *path, const char *mode, Error **errp)
419 {
420     int oflag;
421     int fd = -1;
422     FILE *f = NULL;
423 
424     oflag = find_open_flag(mode, errp);
425     if (oflag < 0) {
426         goto end;
427     }
428 
429     /* If the caller wants / allows creation of a new file, we implement it
430      * with a two step process: open() + (open() / fchmod()).
431      *
432      * First we insist on creating the file exclusively as a new file. If
433      * that succeeds, we're free to set any file-mode bits on it. (The
434      * motivation is that we want to set those file-mode bits independently
435      * of the current umask.)
436      *
437      * If the exclusive creation fails because the file already exists
438      * (EEXIST is not possible for any other reason), we just attempt to
439      * open the file, but in this case we won't be allowed to change the
440      * file-mode bits on the preexistent file.
441      *
442      * The pathname should never disappear between the two open()s in
443      * practice. If it happens, then someone very likely tried to race us.
444      * In this case just go ahead and report the ENOENT from the second
445      * open() to the caller.
446      *
447      * If the caller wants to open a preexistent file, then the first
448      * open() is decisive and its third argument is ignored, and the second
449      * open() and the fchmod() are never called.
450      */
451     fd = qga_open_cloexec(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0);
452     if (fd == -1 && errno == EEXIST) {
453         oflag &= ~(unsigned)O_CREAT;
454         fd = qga_open_cloexec(path, oflag, 0);
455     }
456     if (fd == -1) {
457         error_setg_errno(errp, errno,
458                          "failed to open file '%s' (mode: '%s')",
459                          path, mode);
460         goto end;
461     }
462 
463     if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) {
464         error_setg_errno(errp, errno, "failed to set permission "
465                          "0%03o on new file '%s' (mode: '%s')",
466                          (unsigned)DEFAULT_NEW_FILE_MODE, path, mode);
467         goto end;
468     }
469 
470     f = fdopen(fd, mode);
471     if (f == NULL) {
472         error_setg_errno(errp, errno, "failed to associate stdio stream with "
473                          "file descriptor %d, file '%s' (mode: '%s')",
474                          fd, path, mode);
475     }
476 
477 end:
478     if (f == NULL && fd != -1) {
479         close(fd);
480         if (oflag & O_CREAT) {
481             unlink(path);
482         }
483     }
484     return f;
485 }
486 
qmp_guest_file_open(const char * path,const char * mode,Error ** errp)487 int64_t qmp_guest_file_open(const char *path, const char *mode,
488                             Error **errp)
489 {
490     FILE *fh;
491     Error *local_err = NULL;
492     int64_t handle;
493 
494     if (!mode) {
495         mode = "r";
496     }
497     slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
498     fh = safe_open_or_create(path, mode, &local_err);
499     if (local_err != NULL) {
500         error_propagate(errp, local_err);
501         return -1;
502     }
503 
504     /* set fd non-blocking to avoid common use cases (like reading from a
505      * named pipe) from hanging the agent
506      */
507     if (!g_unix_set_fd_nonblocking(fileno(fh), true, NULL)) {
508         fclose(fh);
509         error_setg_errno(errp, errno, "Failed to set FD nonblocking");
510         return -1;
511     }
512 
513     handle = guest_file_handle_add(fh, errp);
514     if (handle < 0) {
515         fclose(fh);
516         return -1;
517     }
518 
519     slog("guest-file-open, handle: %" PRId64, handle);
520     return handle;
521 }
522 
qmp_guest_file_close(int64_t handle,Error ** errp)523 void qmp_guest_file_close(int64_t handle, Error **errp)
524 {
525     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
526     int ret;
527 
528     slog("guest-file-close called, handle: %" PRId64, handle);
529     if (!gfh) {
530         return;
531     }
532 
533     ret = fclose(gfh->fh);
534     if (ret == EOF) {
535         error_setg_errno(errp, errno, "failed to close handle");
536         return;
537     }
538 
539     QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
540     g_free(gfh);
541 }
542 
guest_file_read_unsafe(GuestFileHandle * gfh,int64_t count,Error ** errp)543 GuestFileRead *guest_file_read_unsafe(GuestFileHandle *gfh,
544                                       int64_t count, Error **errp)
545 {
546     GuestFileRead *read_data = NULL;
547     guchar *buf;
548     FILE *fh = gfh->fh;
549     size_t read_count;
550 
551     /* explicitly flush when switching from writing to reading */
552     if (gfh->state == RW_STATE_WRITING) {
553         int ret = fflush(fh);
554         if (ret == EOF) {
555             error_setg_errno(errp, errno, "failed to flush file");
556             return NULL;
557         }
558         gfh->state = RW_STATE_NEW;
559     }
560 
561     buf = g_malloc0(count + 1);
562     read_count = fread(buf, 1, count, fh);
563     if (ferror(fh)) {
564         error_setg_errno(errp, errno, "failed to read file");
565     } else {
566         buf[read_count] = 0;
567         read_data = g_new0(GuestFileRead, 1);
568         read_data->count = read_count;
569         read_data->eof = feof(fh);
570         if (read_count) {
571             read_data->buf_b64 = g_base64_encode(buf, read_count);
572         }
573         gfh->state = RW_STATE_READING;
574     }
575     g_free(buf);
576     clearerr(fh);
577 
578     return read_data;
579 }
580 
qmp_guest_file_write(int64_t handle,const char * buf_b64,bool has_count,int64_t count,Error ** errp)581 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
582                                      bool has_count, int64_t count,
583                                      Error **errp)
584 {
585     GuestFileWrite *write_data = NULL;
586     guchar *buf;
587     gsize buf_len;
588     int write_count;
589     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
590     FILE *fh;
591 
592     if (!gfh) {
593         return NULL;
594     }
595 
596     fh = gfh->fh;
597 
598     if (gfh->state == RW_STATE_READING) {
599         int ret = fseek(fh, 0, SEEK_CUR);
600         if (ret == -1) {
601             error_setg_errno(errp, errno, "failed to seek file");
602             return NULL;
603         }
604         gfh->state = RW_STATE_NEW;
605     }
606 
607     buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
608     if (!buf) {
609         return NULL;
610     }
611 
612     if (!has_count) {
613         count = buf_len;
614     } else if (count < 0 || count > buf_len) {
615         error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
616                    count);
617         g_free(buf);
618         return NULL;
619     }
620 
621     write_count = fwrite(buf, 1, count, fh);
622     if (ferror(fh)) {
623         error_setg_errno(errp, errno, "failed to write to file");
624         slog("guest-file-write failed, handle: %" PRId64, handle);
625     } else {
626         write_data = g_new0(GuestFileWrite, 1);
627         write_data->count = write_count;
628         write_data->eof = feof(fh);
629         gfh->state = RW_STATE_WRITING;
630     }
631     g_free(buf);
632     clearerr(fh);
633 
634     return write_data;
635 }
636 
qmp_guest_file_seek(int64_t handle,int64_t offset,GuestFileWhence * whence_code,Error ** errp)637 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
638                                           GuestFileWhence *whence_code,
639                                           Error **errp)
640 {
641     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
642     GuestFileSeek *seek_data = NULL;
643     FILE *fh;
644     int ret;
645     int whence;
646     Error *err = NULL;
647 
648     if (!gfh) {
649         return NULL;
650     }
651 
652     /* We stupidly exposed 'whence':'int' in our qapi */
653     whence = ga_parse_whence(whence_code, &err);
654     if (err) {
655         error_propagate(errp, err);
656         return NULL;
657     }
658 
659     fh = gfh->fh;
660     ret = fseek(fh, offset, whence);
661     if (ret == -1) {
662         error_setg_errno(errp, errno, "failed to seek file");
663         if (errno == ESPIPE) {
664             /* file is non-seekable, stdio shouldn't be buffering anyways */
665             gfh->state = RW_STATE_NEW;
666         }
667     } else {
668         seek_data = g_new0(GuestFileSeek, 1);
669         seek_data->position = ftell(fh);
670         seek_data->eof = feof(fh);
671         gfh->state = RW_STATE_NEW;
672     }
673     clearerr(fh);
674 
675     return seek_data;
676 }
677 
qmp_guest_file_flush(int64_t handle,Error ** errp)678 void qmp_guest_file_flush(int64_t handle, Error **errp)
679 {
680     GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
681     FILE *fh;
682     int ret;
683 
684     if (!gfh) {
685         return;
686     }
687 
688     fh = gfh->fh;
689     ret = fflush(fh);
690     if (ret == EOF) {
691         error_setg_errno(errp, errno, "failed to flush file");
692     } else {
693         gfh->state = RW_STATE_NEW;
694     }
695 }
696 
697 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
free_fs_mount_list(FsMountList * mounts)698 void free_fs_mount_list(FsMountList *mounts)
699 {
700      FsMount *mount, *temp;
701 
702      if (!mounts) {
703          return;
704      }
705 
706      QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
707          QTAILQ_REMOVE(mounts, mount, next);
708          g_free(mount->dirname);
709          g_free(mount->devtype);
710          g_free(mount);
711      }
712 }
713 #endif
714 
715 #if defined(CONFIG_FSFREEZE)
716 typedef enum {
717     FSFREEZE_HOOK_THAW = 0,
718     FSFREEZE_HOOK_FREEZE,
719 } FsfreezeHookArg;
720 
721 static const char *fsfreeze_hook_arg_string[] = {
722     "thaw",
723     "freeze",
724 };
725 
execute_fsfreeze_hook(FsfreezeHookArg arg,Error ** errp)726 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp)
727 {
728     const char *hook;
729     const char *arg_str = fsfreeze_hook_arg_string[arg];
730     Error *local_err = NULL;
731 
732     hook = ga_fsfreeze_hook(ga_state);
733     if (!hook) {
734         return;
735     }
736 
737     const char *argv[] = {hook, arg_str, NULL};
738 
739     slog("executing fsfreeze hook with arg '%s'", arg_str);
740     ga_run_command(argv, NULL, "execute fsfreeze hook", &local_err);
741     if (local_err) {
742         error_propagate(errp, local_err);
743         return;
744     }
745 }
746 
747 /*
748  * Return status of freeze/thaw
749  */
qmp_guest_fsfreeze_status(Error ** errp)750 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
751 {
752     if (ga_is_frozen(ga_state)) {
753         return GUEST_FSFREEZE_STATUS_FROZEN;
754     }
755 
756     return GUEST_FSFREEZE_STATUS_THAWED;
757 }
758 
qmp_guest_fsfreeze_freeze(Error ** errp)759 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
760 {
761     return qmp_guest_fsfreeze_freeze_list(false, NULL, errp);
762 }
763 
qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,strList * mountpoints,Error ** errp)764 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
765                                        strList *mountpoints,
766                                        Error **errp)
767 {
768     int ret;
769     FsMountList mounts;
770     Error *local_err = NULL;
771 
772     slog("guest-fsfreeze called");
773 
774     execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err);
775     if (local_err) {
776         error_propagate(errp, local_err);
777         return -1;
778     }
779 
780     QTAILQ_INIT(&mounts);
781     if (!build_fs_mount_list(&mounts, &local_err)) {
782         error_propagate(errp, local_err);
783         return -1;
784     }
785 
786     /* cannot risk guest agent blocking itself on a write in this state */
787     ga_set_frozen(ga_state);
788 
789     ret = qmp_guest_fsfreeze_do_freeze_list(has_mountpoints, mountpoints,
790                                             mounts, errp);
791 
792     free_fs_mount_list(&mounts);
793     /* We may not issue any FIFREEZE here.
794      * Just unset ga_state here and ready for the next call.
795      */
796     if (ret == 0) {
797         ga_unset_frozen(ga_state);
798     } else if (ret < 0) {
799         qmp_guest_fsfreeze_thaw(NULL);
800     }
801     return ret;
802 }
803 
qmp_guest_fsfreeze_thaw(Error ** errp)804 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
805 {
806     int ret;
807 
808     ret = qmp_guest_fsfreeze_do_thaw(errp);
809     if (ret >= 0) {
810         ga_unset_frozen(ga_state);
811         execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp);
812     } else {
813         ret = 0;
814     }
815 
816     return ret;
817 }
818 
guest_fsfreeze_cleanup(void)819 static void guest_fsfreeze_cleanup(void)
820 {
821     Error *err = NULL;
822 
823     if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
824         qmp_guest_fsfreeze_thaw(&err);
825         if (err) {
826             slog("failed to clean up frozen filesystems: %s",
827                  error_get_pretty(err));
828             error_free(err);
829         }
830     }
831 }
832 #endif
833 
834 #if defined(__linux__) || defined(__FreeBSD__)
qmp_guest_set_user_password(const char * username,const char * password,bool crypted,Error ** errp)835 void qmp_guest_set_user_password(const char *username,
836                                  const char *password,
837                                  bool crypted,
838                                  Error **errp)
839 {
840     Error *local_err = NULL;
841     g_autofree char *rawpasswddata = NULL;
842     size_t rawpasswdlen;
843 
844     rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
845     if (!rawpasswddata) {
846         return;
847     }
848     rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
849     rawpasswddata[rawpasswdlen] = '\0';
850 
851     if (strchr(rawpasswddata, '\n')) {
852         error_setg(errp, "forbidden characters in raw password");
853         return;
854     }
855 
856     if (strchr(username, '\n') ||
857         strchr(username, ':')) {
858         error_setg(errp, "forbidden characters in username");
859         return;
860     }
861 
862 #ifdef __FreeBSD__
863     g_autofree char *chpasswddata = g_strdup(rawpasswddata);
864     const char *crypt_flag = crypted ? "-H" : "-h";
865     const char *argv[] = {"pw", "usermod", "-n", username,
866                           crypt_flag, "0", NULL};
867 #else
868     g_autofree char *chpasswddata = g_strdup_printf("%s:%s\n", username,
869                                                     rawpasswddata);
870     const char *crypt_flag = crypted ? "-e" : NULL;
871     const char *argv[] = {"chpasswd", crypt_flag, NULL};
872 #endif
873 
874     ga_run_command(argv, chpasswddata, "set user password", &local_err);
875     if (local_err) {
876         error_propagate(errp, local_err);
877         return;
878     }
879 }
880 #endif /* __linux__ || __FreeBSD__ */
881 
882 #ifdef HAVE_GETIFADDRS
883 static GuestNetworkInterface *
guest_find_interface(GuestNetworkInterfaceList * head,const char * name)884 guest_find_interface(GuestNetworkInterfaceList *head,
885                      const char *name)
886 {
887     for (; head; head = head->next) {
888         if (strcmp(head->value->name, name) == 0) {
889             return head->value;
890         }
891     }
892 
893     return NULL;
894 }
895 
guest_get_network_stats(const char * name,GuestNetworkInterfaceStat * stats)896 static int guest_get_network_stats(const char *name,
897                        GuestNetworkInterfaceStat *stats)
898 {
899 #ifdef CONFIG_LINUX
900     int name_len;
901     char const *devinfo = "/proc/net/dev";
902     FILE *fp;
903     char *line = NULL, *colon;
904     size_t n = 0;
905     fp = fopen(devinfo, "r");
906     if (!fp) {
907         g_debug("failed to open network stats %s: %s", devinfo,
908                 g_strerror(errno));
909         return -1;
910     }
911     name_len = strlen(name);
912     while (getline(&line, &n, fp) != -1) {
913         long long dummy;
914         long long rx_bytes;
915         long long rx_packets;
916         long long rx_errs;
917         long long rx_dropped;
918         long long tx_bytes;
919         long long tx_packets;
920         long long tx_errs;
921         long long tx_dropped;
922         char *trim_line;
923         trim_line = g_strchug(line);
924         if (trim_line[0] == '\0') {
925             continue;
926         }
927         colon = strchr(trim_line, ':');
928         if (!colon) {
929             continue;
930         }
931         if (colon - name_len  == trim_line &&
932            strncmp(trim_line, name, name_len) == 0) {
933             if (sscanf(colon + 1,
934                 "%lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld",
935                   &rx_bytes, &rx_packets, &rx_errs, &rx_dropped,
936                   &dummy, &dummy, &dummy, &dummy,
937                   &tx_bytes, &tx_packets, &tx_errs, &tx_dropped,
938                   &dummy, &dummy, &dummy, &dummy) != 16) {
939                 continue;
940             }
941             stats->rx_bytes = rx_bytes;
942             stats->rx_packets = rx_packets;
943             stats->rx_errs = rx_errs;
944             stats->rx_dropped = rx_dropped;
945             stats->tx_bytes = tx_bytes;
946             stats->tx_packets = tx_packets;
947             stats->tx_errs = tx_errs;
948             stats->tx_dropped = tx_dropped;
949             fclose(fp);
950             g_free(line);
951             return 0;
952         }
953     }
954     fclose(fp);
955     g_free(line);
956     g_debug("/proc/net/dev: Interface '%s' not found", name);
957 #else /* !CONFIG_LINUX */
958     g_debug("Network stats reporting available only for Linux");
959 #endif /* !CONFIG_LINUX */
960     return -1;
961 }
962 
963 #ifndef CONFIG_BSD
964 /*
965  * Fill "buf" with MAC address by ifaddrs. Pointer buf must point to a
966  * buffer with ETHER_ADDR_LEN length at least.
967  *
968  * Returns false in case of an error, otherwise true. "obtained" argument
969  * is true if a MAC address was obtained successful, otherwise false.
970  */
guest_get_hw_addr(struct ifaddrs * ifa,unsigned char * buf,bool * obtained,Error ** errp)971 bool guest_get_hw_addr(struct ifaddrs *ifa, unsigned char *buf,
972                        bool *obtained, Error **errp)
973 {
974     struct ifreq ifr;
975     int sock;
976 
977     *obtained = false;
978 
979     /* we haven't obtained HW address yet */
980     sock = socket(PF_INET, SOCK_STREAM, 0);
981     if (sock == -1) {
982         error_setg_errno(errp, errno, "failed to create socket");
983         return false;
984     }
985 
986     memset(&ifr, 0, sizeof(ifr));
987     pstrcpy(ifr.ifr_name, IF_NAMESIZE, ifa->ifa_name);
988     if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
989         /*
990          * We can't get the hw addr of this interface, but that's not a
991          * fatal error.
992          */
993         if (errno == EADDRNOTAVAIL) {
994             /* The interface doesn't have a hw addr (e.g. loopback). */
995             g_debug("failed to get MAC address of %s: %s",
996                     ifa->ifa_name, strerror(errno));
997         } else{
998             g_warning("failed to get MAC address of %s: %s",
999                       ifa->ifa_name, strerror(errno));
1000         }
1001     } else {
1002 #ifdef CONFIG_SOLARIS
1003         memcpy(buf, &ifr.ifr_addr.sa_data, ETHER_ADDR_LEN);
1004 #else
1005         memcpy(buf, &ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN);
1006 #endif
1007         *obtained = true;
1008     }
1009     close(sock);
1010     return true;
1011 }
1012 #endif /* CONFIG_BSD */
1013 
1014 /*
1015  * Build information about guest interfaces
1016  */
qmp_guest_network_get_interfaces(Error ** errp)1017 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1018 {
1019     GuestNetworkInterfaceList *head = NULL, **tail = &head;
1020     struct ifaddrs *ifap, *ifa;
1021 
1022     if (getifaddrs(&ifap) < 0) {
1023         error_setg_errno(errp, errno, "getifaddrs failed");
1024         goto error;
1025     }
1026 
1027     for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1028         GuestNetworkInterface *info;
1029         GuestIpAddressList **address_tail;
1030         GuestIpAddress *address_item = NULL;
1031         GuestNetworkInterfaceStat *interface_stat = NULL;
1032         char addr4[INET_ADDRSTRLEN];
1033         char addr6[INET6_ADDRSTRLEN];
1034         unsigned char mac_addr[ETHER_ADDR_LEN];
1035         bool obtained;
1036         void *p;
1037 
1038         g_debug("Processing %s interface", ifa->ifa_name);
1039 
1040         info = guest_find_interface(head, ifa->ifa_name);
1041 
1042         if (!info) {
1043             info = g_malloc0(sizeof(*info));
1044             info->name = g_strdup(ifa->ifa_name);
1045 
1046             QAPI_LIST_APPEND(tail, info);
1047         }
1048 
1049         if (!info->hardware_address) {
1050             if (!guest_get_hw_addr(ifa, mac_addr, &obtained, errp)) {
1051                 goto error;
1052             }
1053             if (obtained) {
1054                 info->hardware_address =
1055                     g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1056                                     (int) mac_addr[0], (int) mac_addr[1],
1057                                     (int) mac_addr[2], (int) mac_addr[3],
1058                                     (int) mac_addr[4], (int) mac_addr[5]);
1059             }
1060         }
1061 
1062         if (ifa->ifa_addr &&
1063             ifa->ifa_addr->sa_family == AF_INET) {
1064             /* interface with IPv4 address */
1065             p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
1066             if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
1067                 error_setg_errno(errp, errno, "inet_ntop failed");
1068                 goto error;
1069             }
1070 
1071             address_item = g_malloc0(sizeof(*address_item));
1072             address_item->ip_address = g_strdup(addr4);
1073             address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1074 
1075             if (ifa->ifa_netmask) {
1076                 /* Count the number of set bits in netmask.
1077                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1078                 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
1079                 address_item->prefix = ctpop32(((uint32_t *) p)[0]);
1080             }
1081         } else if (ifa->ifa_addr &&
1082                    ifa->ifa_addr->sa_family == AF_INET6) {
1083             /* interface with IPv6 address */
1084             p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
1085             if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
1086                 error_setg_errno(errp, errno, "inet_ntop failed");
1087                 goto error;
1088             }
1089 
1090             address_item = g_malloc0(sizeof(*address_item));
1091             address_item->ip_address = g_strdup(addr6);
1092             address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1093 
1094             if (ifa->ifa_netmask) {
1095                 /* Count the number of set bits in netmask.
1096                  * This is safe as '1' and '0' cannot be shuffled in netmask. */
1097                 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
1098                 address_item->prefix =
1099                     ctpop32(((uint32_t *) p)[0]) +
1100                     ctpop32(((uint32_t *) p)[1]) +
1101                     ctpop32(((uint32_t *) p)[2]) +
1102                     ctpop32(((uint32_t *) p)[3]);
1103             }
1104         }
1105 
1106         if (!address_item) {
1107             continue;
1108         }
1109 
1110         address_tail = &info->ip_addresses;
1111         while (*address_tail) {
1112             address_tail = &(*address_tail)->next;
1113         }
1114         QAPI_LIST_APPEND(address_tail, address_item);
1115 
1116         info->has_ip_addresses = true;
1117 
1118         if (!info->statistics) {
1119             interface_stat = g_malloc0(sizeof(*interface_stat));
1120             if (guest_get_network_stats(info->name, interface_stat) == -1) {
1121                 g_free(interface_stat);
1122             } else {
1123                 info->statistics = interface_stat;
1124             }
1125         }
1126     }
1127 
1128     freeifaddrs(ifap);
1129     return head;
1130 
1131 error:
1132     freeifaddrs(ifap);
1133     qapi_free_GuestNetworkInterfaceList(head);
1134     return NULL;
1135 }
1136 
1137 #endif /* HAVE_GETIFADDRS */
1138 
1139 /* register init/cleanup routines for stateful command groups */
ga_command_state_init(GAState * s,GACommandState * cs)1140 void ga_command_state_init(GAState *s, GACommandState *cs)
1141 {
1142 #if defined(CONFIG_FSFREEZE)
1143     ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
1144 #endif
1145 }
1146 
1147 #ifdef HAVE_UTMPX
1148 
1149 #define QGA_MICRO_SECOND_TO_SECOND 1000000
1150 
ga_get_login_time(struct utmpx * user_info)1151 static double ga_get_login_time(struct utmpx *user_info)
1152 {
1153     double seconds = (double)user_info->ut_tv.tv_sec;
1154     double useconds = (double)user_info->ut_tv.tv_usec;
1155     useconds /= QGA_MICRO_SECOND_TO_SECOND;
1156     return seconds + useconds;
1157 }
1158 
qmp_guest_get_users(Error ** errp)1159 GuestUserList *qmp_guest_get_users(Error **errp)
1160 {
1161     GHashTable *cache = NULL;
1162     GuestUserList *head = NULL, **tail = &head;
1163     struct utmpx *user_info = NULL;
1164     gpointer value = NULL;
1165     GuestUser *user = NULL;
1166     double login_time = 0;
1167 
1168     cache = g_hash_table_new(g_str_hash, g_str_equal);
1169     setutxent();
1170 
1171     for (;;) {
1172         user_info = getutxent();
1173         if (user_info == NULL) {
1174             break;
1175         } else if (user_info->ut_type != USER_PROCESS) {
1176             continue;
1177         } else if (g_hash_table_contains(cache, user_info->ut_user)) {
1178             value = g_hash_table_lookup(cache, user_info->ut_user);
1179             user = (GuestUser *)value;
1180             login_time = ga_get_login_time(user_info);
1181             /* We're ensuring the earliest login time to be sent */
1182             if (login_time < user->login_time) {
1183                 user->login_time = login_time;
1184             }
1185             continue;
1186         }
1187 
1188         user = g_new0(GuestUser, 1);
1189         user->user = g_strdup(user_info->ut_user);
1190         user->login_time = ga_get_login_time(user_info);
1191 
1192         g_hash_table_insert(cache, user->user, user);
1193 
1194         QAPI_LIST_APPEND(tail, user);
1195     }
1196     endutxent();
1197     g_hash_table_destroy(cache);
1198     return head;
1199 }
1200 
1201 #endif /* HAVE_UTMPX */
1202 
1203 /* Replace escaped special characters with their real values. The replacement
1204  * is done in place -- returned value is in the original string.
1205  */
ga_osrelease_replace_special(gchar * value)1206 static void ga_osrelease_replace_special(gchar *value)
1207 {
1208     gchar *p, *p2, quote;
1209 
1210     /* Trim the string at first space or semicolon if it is not enclosed in
1211      * single or double quotes. */
1212     if ((value[0] != '"') || (value[0] == '\'')) {
1213         p = strchr(value, ' ');
1214         if (p != NULL) {
1215             *p = 0;
1216         }
1217         p = strchr(value, ';');
1218         if (p != NULL) {
1219             *p = 0;
1220         }
1221         return;
1222     }
1223 
1224     quote = value[0];
1225     p2 = value;
1226     p = value + 1;
1227     while (*p != 0) {
1228         if (*p == '\\') {
1229             p++;
1230             switch (*p) {
1231             case '$':
1232             case '\'':
1233             case '"':
1234             case '\\':
1235             case '`':
1236                 break;
1237             default:
1238                 /* Keep literal backslash followed by whatever is there */
1239                 p--;
1240                 break;
1241             }
1242         } else if (*p == quote) {
1243             *p2 = 0;
1244             break;
1245         }
1246         *(p2++) = *(p++);
1247     }
1248 }
1249 
ga_parse_osrelease(const char * fname)1250 static GKeyFile *ga_parse_osrelease(const char *fname)
1251 {
1252     gchar *content = NULL;
1253     gchar *content2 = NULL;
1254     GError *err = NULL;
1255     GKeyFile *keys = g_key_file_new();
1256     const char *group = "[os-release]\n";
1257 
1258     if (!g_file_get_contents(fname, &content, NULL, &err)) {
1259         slog("failed to read '%s', error: %s", fname, err->message);
1260         goto fail;
1261     }
1262 
1263     if (!g_utf8_validate(content, -1, NULL)) {
1264         slog("file is not utf-8 encoded: %s", fname);
1265         goto fail;
1266     }
1267     content2 = g_strdup_printf("%s%s", group, content);
1268 
1269     if (!g_key_file_load_from_data(keys, content2, -1, G_KEY_FILE_NONE,
1270                                    &err)) {
1271         slog("failed to parse file '%s', error: %s", fname, err->message);
1272         goto fail;
1273     }
1274 
1275     g_free(content);
1276     g_free(content2);
1277     return keys;
1278 
1279 fail:
1280     g_error_free(err);
1281     g_free(content);
1282     g_free(content2);
1283     g_key_file_free(keys);
1284     return NULL;
1285 }
1286 
qmp_guest_get_osinfo(Error ** errp)1287 GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
1288 {
1289     GuestOSInfo *info = NULL;
1290     struct utsname kinfo;
1291     GKeyFile *osrelease = NULL;
1292     const char *qga_os_release = g_getenv("QGA_OS_RELEASE");
1293 
1294     info = g_new0(GuestOSInfo, 1);
1295 
1296     if (uname(&kinfo) != 0) {
1297         error_setg_errno(errp, errno, "uname failed");
1298     } else {
1299         info->kernel_version = g_strdup(kinfo.version);
1300         info->kernel_release = g_strdup(kinfo.release);
1301         info->machine = g_strdup(kinfo.machine);
1302     }
1303 
1304     if (qga_os_release != NULL) {
1305         osrelease = ga_parse_osrelease(qga_os_release);
1306     } else {
1307         osrelease = ga_parse_osrelease("/etc/os-release");
1308         if (osrelease == NULL) {
1309             osrelease = ga_parse_osrelease("/usr/lib/os-release");
1310         }
1311     }
1312 
1313     if (osrelease != NULL) {
1314         char *value;
1315 
1316 #define GET_FIELD(field, osfield) do { \
1317     value = g_key_file_get_value(osrelease, "os-release", osfield, NULL); \
1318     if (value != NULL) { \
1319         ga_osrelease_replace_special(value); \
1320         info->field = value; \
1321     } \
1322 } while (0)
1323         GET_FIELD(id, "ID");
1324         GET_FIELD(name, "NAME");
1325         GET_FIELD(pretty_name, "PRETTY_NAME");
1326         GET_FIELD(version, "VERSION");
1327         GET_FIELD(version_id, "VERSION_ID");
1328         GET_FIELD(variant, "VARIANT");
1329         GET_FIELD(variant_id, "VARIANT_ID");
1330 #undef GET_FIELD
1331 
1332         g_key_file_free(osrelease);
1333     }
1334 
1335     return info;
1336 }
1337 
1338 #ifndef HOST_NAME_MAX
1339 # ifdef _POSIX_HOST_NAME_MAX
1340 #  define HOST_NAME_MAX _POSIX_HOST_NAME_MAX
1341 # else
1342 #  define HOST_NAME_MAX 255
1343 # endif
1344 #endif
1345 
qga_get_host_name(Error ** errp)1346 char *qga_get_host_name(Error **errp)
1347 {
1348     long len = -1;
1349     g_autofree char *hostname = NULL;
1350 
1351 #ifdef _SC_HOST_NAME_MAX
1352     len = sysconf(_SC_HOST_NAME_MAX);
1353 #endif /* _SC_HOST_NAME_MAX */
1354 
1355     if (len < 0) {
1356         len = HOST_NAME_MAX;
1357     }
1358 
1359     /* Unfortunately, gethostname() below does not guarantee a
1360      * NULL terminated string. Therefore, allocate one byte more
1361      * to be sure. */
1362     hostname = g_new0(char, len + 1);
1363 
1364     if (gethostname(hostname, len) < 0) {
1365         error_setg_errno(errp, errno,
1366                          "cannot get hostname");
1367         return NULL;
1368     }
1369 
1370     return g_steal_pointer(&hostname);
1371 }
1372