1 /* libguestfs - the guestfsd daemon
2 * Copyright (C) 2009 Red Hat Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #define _BSD_SOURCE /* for daemon(3) */
27 #include <rpc/types.h>
30 #include <sys/param.h>
31 #include <sys/types.h>
36 #include <sys/select.h>
44 #include "ignore-value.h"
48 static char *read_cmdline (void);
50 /* Also in guestfs.c */
51 #define GUESTFWD_ADDR "10.0.2.4"
52 #define GUESTFWD_PORT "6666"
54 /* This is only a hint. If not defined, ignore it. */
56 #define AI_ADDRCONFIG 0
61 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
62 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
63 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
64 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
66 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
67 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
69 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
73 /* Location to mount root device. */
74 const char *sysroot = "/sysroot"; /* No trailing slash. */
81 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
85 main (int argc, char *argv[])
87 static const char *options = "fc:v?";
88 static const struct option long_options[] = {
89 { "channel", required_argument, 0, 'c' },
90 { "foreground", 0, 0, 'f' },
91 { "help", 0, 0, '?' },
92 { "verbose", 0, 0, 'v' },
98 char *vmchannel = NULL;
100 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
101 /* http://udrepper.livejournal.com/20948.html */
102 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
103 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
105 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
106 register_printf_function ('Q', print_shell_quote, print_arginfo);
107 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
109 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
114 c = getopt_long (argc, argv, options, long_options, NULL);
135 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
145 cmdline = read_cmdline ();
147 /* Set the verbose flag. */
149 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
151 printf ("verbose daemon enabled\n");
155 printf ("linux commmand line: %s\n", cmdline);
157 printf ("could not read linux command line\n");
161 /* Make sure SIGPIPE doesn't kill us. */
163 memset (&sa, 0, sizeof sa);
164 sa.sa_handler = SIG_IGN;
166 if (sigaction (SIGPIPE, &sa, NULL) == -1)
167 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
170 /* Set up a basic environment. After we are called by /init the
171 * environment is essentially empty.
172 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
174 setenv ("PATH", "/usr/bin:/bin", 1);
175 setenv ("SHELL", "/bin/sh", 1);
176 setenv ("LC_ALL", "C", 1);
178 /* We document that umask defaults to 022 (it should be this anyway). */
181 /* Get the vmchannel string.
184 * --channel/-c option on the command line
185 * guestfs_vmchannel=... from the kernel command line
186 * guestfs=... from the kernel command line
189 * At the moment we expect this to contain "tcp:ip:port" but in
190 * future it might contain a device name, eg. "/dev/vcon4" for
191 * virtio-console vmchannel.
193 if (vmchannel == NULL && cmdline) {
197 p = strstr (cmdline, "guestfs_vmchannel=");
199 len = strcspn (p + 18, " \t\n");
200 vmchannel = strndup (p + 18, len);
207 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
208 if (vmchannel == NULL) {
209 /* We will rewrite it part of the "guestfs=" string with
210 * "tcp:" hence p + 4 below. */
211 p = strstr (cmdline, "guestfs=");
213 len = strcspn (p + 4, " \t\n");
214 vmchannel = strndup (p + 4, len);
219 memcpy (vmchannel, "tcp:", 4);
224 /* Default vmchannel. */
225 if (vmchannel == NULL) {
226 vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
234 printf ("vmchannel: %s\n", vmchannel);
236 /* Connect to vmchannel. */
239 if (STREQLEN (vmchannel, "tcp:", 4)) {
240 /* Resolve the hostname. */
241 struct addrinfo *res, *rr;
242 struct addrinfo hints;
247 port = strchr (host, ':');
252 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
257 memset (&hints, 0, sizeof hints);
258 hints.ai_socktype = SOCK_STREAM;
259 hints.ai_flags = AI_ADDRCONFIG;
260 r = getaddrinfo (host, port, &hints, &res);
262 fprintf (stderr, "%s:%s: %s\n",
263 host, port, gai_strerror (r));
267 /* Connect to the given TCP socket. */
268 for (rr = res; rr != NULL; rr = rr->ai_next) {
269 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
271 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
282 "unknown vmchannel connection type: %s\n"
283 "expecting \"tcp:<ip>:<port>\"\n",
291 "Failed to connect to any vmchannel implementation.\n"
294 "This is a fatal error and the appliance will now exit.\n"
296 "Usually this error is caused by either QEMU or the appliance\n"
297 "kernel not supporting the vmchannel method that the\n"
298 "libguestfs library chose to use. Please run\n"
299 "'libguestfs-test-tool' and provide the complete, unedited\n"
300 "output to the libguestfs developers, either in a bug report\n"
301 "or on the libguestfs redhat com mailing list.\n"
307 /* Send the magic length message which indicates that
308 * userspace is up inside the guest.
312 uint32_t len = GUESTFS_LAUNCH_FLAG;
313 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
314 xdr_u_int (&xdr, &len);
316 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
321 /* Fork into the background. */
323 if (daemon (0, 1) == -1) {
329 /* Enter the main loop, reading and performing actions. */
335 /* Read /proc/cmdline. */
339 int fd = open ("/proc/cmdline", O_RDONLY);
341 perror ("/proc/cmdline");
351 n = read (fd, buf, sizeof buf);
360 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
368 memcpy (&r[len], buf, n);
375 if (close (fd) == -1) {
384 /* Turn "/path" into "/sysroot/path".
386 * Caller must check for NULL and call reply_with_perror ("malloc")
387 * if it is. Caller must also free the string.
389 * See also the custom %R printf formatter which does shell quoting too.
392 sysroot_path (const char *path)
395 int len = strlen (path) + sysroot_len + 1;
401 snprintf (r, len, "%s%s", sysroot, path);
406 xwrite (int sock, const void *v_buf, size_t len)
409 const char *buf = v_buf;
412 r = write (sock, buf, len);
425 xread (int sock, void *v_buf, size_t len)
431 r = read (sock, buf, len);
437 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
448 add_string (char ***argv, int *size, int *alloc, const char *str)
453 if (*size >= *alloc) {
455 new_argv = realloc (*argv, *alloc * sizeof (char *));
456 if (new_argv == NULL) {
457 reply_with_perror ("realloc");
458 free_strings (*argv);
465 new_str = strdup (str);
466 if (new_str == NULL) {
467 reply_with_perror ("strdup");
468 free_strings (*argv);
473 (*argv)[*size] = new_str;
480 count_strings (char *const *argv)
484 for (argc = 0; argv[argc] != NULL; ++argc)
490 compare (const void *vp1, const void *vp2)
492 char * const *p1 = (char * const *) vp1;
493 char * const *p2 = (char * const *) vp2;
494 return strcmp (*p1, *p2);
498 sort_strings (char **argv, int len)
500 qsort (argv, len, sizeof (char *), compare);
504 free_strings (char **argv)
508 for (argc = 0; argv[argc] != NULL; ++argc)
514 free_stringslen (char **argv, int len)
518 for (i = 0; i < len; ++i)
523 /* Easy ways to run external commands. For full documentation, see
524 * 'commandrvf' below.
527 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
534 /* Collect the command line arguments into an array. */
536 argv = malloc (sizeof (char *) * i);
541 argv[0] = (char *) name;
544 va_start (args, name);
546 while ((s = va_arg (args, char *)) != NULL) {
547 const char **p = realloc (argv, sizeof (char *) * (++i));
561 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
563 /* NB: Mustn't free the strings which are on the stack. */
569 /* Same as 'command', but we allow the status code from the
570 * subcommand to be non-zero, and return that status code.
571 * We still return -1 if there was some other error.
574 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
581 /* Collect the command line arguments into an array. */
583 argv = malloc (sizeof (char *) * i);
588 argv[0] = (char *) name;
591 va_start (args, name);
593 while ((s = va_arg (args, char *)) != NULL) {
594 const char **p = realloc (argv, sizeof (char *) * (++i));
608 r = commandrvf (stdoutput, stderror, flags, argv);
610 /* NB: Mustn't free the strings which are on the stack. */
616 /* Same as 'command', but passing an argv. */
618 commandvf (char **stdoutput, char **stderror, int flags,
619 char const *const *argv)
623 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
630 /* This is a more sane version of 'system(3)' for running external
631 * commands. It uses fork/execvp, so we don't need to worry about
632 * quoting of parameters, and it allows us to capture any error
633 * messages in a buffer.
635 * If stdoutput is not NULL, then *stdoutput will return the stdout
638 * If stderror is not NULL, then *stderror will return the stderr
639 * of the command. If there is a final \n character, it is removed
640 * so you can use the error string directly in a call to
645 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
646 * that send error messages to stdout (hello, parted) but that don't
647 * have any useful stdout information, use this flag to capture the
648 * error messages in the *stderror buffer. If using this flag,
649 * you should pass stdoutput as NULL because nothing could ever be
650 * captured in that buffer.
653 commandrvf (char **stdoutput, char **stderror, int flags,
654 char const* const *argv)
656 int so_size = 0, se_size = 0;
657 int so_fd[2], se_fd[2];
664 if (stdoutput) *stdoutput = NULL;
665 if (stderror) *stderror = NULL;
668 printf ("%s", argv[0]);
669 for (i = 1; argv[i] != NULL; ++i)
670 printf (" %s", argv[i]);
674 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
689 if (pid == 0) { /* Child process. */
691 open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
694 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
702 execvp (argv[0], (void *) argv);
707 /* Parent process. */
712 FD_SET (so_fd[0], &rset);
713 FD_SET (se_fd[0], &rset);
718 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
722 if (stdoutput) free (*stdoutput);
723 if (stderror) free (*stderror);
726 waitpid (pid, NULL, 0);
730 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
731 r = read (so_fd[0], buf, sizeof buf);
736 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
738 if (r > 0 && stdoutput) {
740 p = realloc (*stdoutput, so_size);
746 memcpy (*stdoutput + so_size - r, buf, r);
750 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
751 r = read (se_fd[0], buf, sizeof buf);
756 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
760 ignore_value (write (2, buf, r));
764 p = realloc (*stderror, se_size);
770 memcpy (*stderror + se_size - r, buf, r);
779 /* Make sure the output buffers are \0-terminated. Also remove any
780 * trailing \n characters from the error buffer (not from stdout).
783 void *q = realloc (*stdoutput, so_size+1);
790 (*stdoutput)[so_size] = '\0';
793 void *q = realloc (*stderror, se_size+1);
800 (*stderror)[se_size] = '\0';
802 while (se_size >= 0 && (*stderror)[se_size] == '\n')
803 (*stderror)[se_size--] = '\0';
807 /* Get the exit status of the command. */
808 if (waitpid (pid, &r, 0) != pid) {
814 return WEXITSTATUS (r);
819 /* Split an output string into a NULL-terminated list of lines.
820 * Typically this is used where we have run an external command
821 * which has printed out a list of things, and we want to return
824 * The corner cases here are quite tricky. Note in particular:
828 * "a\nb" -> ["a"; "b"]
829 * "a\nb\n" -> ["a"; "b"]
830 * "a\nb\n\n" -> ["a"; "b"; ""]
832 * The original string is written over and destroyed by this
833 * function (which is usually OK because it's the 'out' string
834 * from command()). You can free the original string, because
835 * add_string() strdups the strings.
838 split_lines (char *str)
841 int size = 0, alloc = 0;
849 /* Empty last line? */
853 pend = strchr (p, '\n');
859 if (add_string (&lines, &size, &alloc, p) == -1) {
867 if (add_string (&lines, &size, &alloc, NULL) == -1)
873 /* printf helper function so we can use %Q ("quoted") and %R to print
874 * shell-quoted strings. See HACKING file for more details.
877 print_shell_quote (FILE *stream,
878 const struct printf_info *info ATTRIBUTE_UNUSED,
879 const void *const *args)
881 #define SAFE(c) (c_isalnum((c)) || \
882 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
884 const char *str = *((const char **) (args[0]));
886 for (i = len = 0; str[i]; ++i) {
891 putc (str[i], stream);
899 print_sysroot_shell_quote (FILE *stream,
900 const struct printf_info *info,
901 const void *const *args)
903 fputs (sysroot, stream);
904 return sysroot_len + print_shell_quote (stream, info, args);
907 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
909 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
910 size_t n, int *argtypes, int *size)
913 argtypes[0] = PA_STRING;
914 size[0] = sizeof (const char *);
919 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
921 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
924 argtypes[0] = PA_STRING;
928 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
932 /* Perform device name translation. Don't call this directly -
933 * use the RESOLVE_DEVICE macro.
935 * See guestfs(3) for the algorithm.
937 * We have to open the device and test for ENXIO, because
938 * the device nodes themselves will exist in the appliance.
941 device_name_translation (char *device, const char *func)
945 fd = open (device, O_RDONLY);
951 if (errno != ENXIO && errno != ENOENT) {
953 reply_with_perror ("%s: %s", func, device);
957 /* If the name begins with "/dev/sd" then try the alternatives. */
958 if (STRNEQLEN (device, "/dev/sd", 7))
961 device[5] = 'h'; /* /dev/hd (old IDE driver) */
962 fd = open (device, O_RDONLY);
968 device[5] = 'v'; /* /dev/vd (for virtio devices) */
969 fd = open (device, O_RDONLY);
975 device[5] = 's'; /* Restore original device name. */
979 /* LVM and other commands aren't synchronous, especially when udev is
980 * involved. eg. You can create or remove some device, but the /dev
981 * device node won't appear until some time later. This means that
982 * you get an error if you run one command followed by another.
983 * Use 'udevadm settle' after certain commands, but don't be too
984 * fussed if it fails.
989 static int which_prog = 0;
991 if (which_prog == 0) {
992 if (access ("/sbin/udevsettle", X_OK) == 0)
994 else if (access ("/sbin/udevadm", X_OK) == 0)
1000 switch (which_prog) {
1002 command (NULL, NULL, "/sbin/udevadm", "settle", NULL);
1005 command (NULL, NULL, "/sbin/udevsettle", NULL);