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>
31 #include <sys/param.h>
32 #include <sys/select.h>
33 #include <sys/types.h>
43 static char *read_cmdline (void);
45 /* Also in guestfs.c */
46 #define GUESTFWD_ADDR "10.0.2.4"
47 #define GUESTFWD_PORT "6666"
51 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
52 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
53 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
54 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
56 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
57 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
59 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
63 /* Location to mount root device. */
64 const char *sysroot = "/sysroot"; /* No trailing slash. */
71 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
75 main (int argc, char *argv[])
77 static const char *options = "fc:v?";
78 static const struct option long_options[] = {
79 { "channel", required_argument, 0, 'c' },
80 { "foreground", 0, 0, 'f' },
81 { "help", 0, 0, '?' },
82 { "verbose", 0, 0, 'v' },
88 char *vmchannel = NULL;
90 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
91 /* http://udrepper.livejournal.com/20948.html */
92 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
93 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
95 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
96 register_printf_function ('Q', print_shell_quote, print_arginfo);
97 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
99 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
104 c = getopt_long (argc, argv, options, long_options, NULL);
125 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
135 cmdline = read_cmdline ();
137 /* Set the verbose flag. */
139 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
141 printf ("verbose daemon enabled\n");
145 printf ("linux commmand line: %s\n", cmdline);
147 printf ("could not read linux command line\n");
150 /* Make sure SIGPIPE doesn't kill us. */
152 memset (&sa, 0, sizeof sa);
153 sa.sa_handler = SIG_IGN;
155 if (sigaction (SIGPIPE, &sa, NULL) == -1)
156 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
158 /* Set up a basic environment. After we are called by /init the
159 * environment is essentially empty.
160 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
162 setenv ("PATH", "/usr/bin:/bin", 1);
163 setenv ("SHELL", "/bin/sh", 1);
164 setenv ("LC_ALL", "C", 1);
166 /* We document that umask defaults to 022 (it should be this anyway). */
169 /* Get the vmchannel string.
172 * --channel/-c option on the command line
173 * guestfs_vmchannel=... from the kernel command line
174 * guestfs=... from the kernel command line
177 * At the moment we expect this to contain "tcp:ip:port" but in
178 * future it might contain a device name, eg. "/dev/vcon4" for
179 * virtio-console vmchannel.
181 if (vmchannel == NULL && cmdline) {
185 p = strstr (cmdline, "guestfs_vmchannel=");
187 len = strcspn (p + 18, " \t\n");
188 vmchannel = strndup (p + 18, len);
195 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
196 if (vmchannel == NULL) {
197 /* We will rewrite it part of the "guestfs=" string with
198 * "tcp:" hence p + 4 below. */
199 p = strstr (cmdline, "guestfs=");
201 len = strcspn (p + 4, " \t\n");
202 vmchannel = strndup (p + 4, len);
207 memcpy (vmchannel, "tcp:", 4);
212 /* Default vmchannel. */
213 if (vmchannel == NULL) {
214 vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
222 printf ("vmchannel: %s\n", vmchannel);
224 /* Connect to vmchannel. */
227 if (strncmp (vmchannel, "tcp:", 4) == 0) {
228 /* Resolve the hostname. */
229 struct addrinfo *res, *rr;
230 struct addrinfo hints;
235 port = strchr (host, ':');
240 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
245 memset (&hints, 0, sizeof hints);
246 hints.ai_socktype = SOCK_STREAM;
247 hints.ai_flags = AI_ADDRCONFIG;
248 r = getaddrinfo (host, port, &hints, &res);
250 fprintf (stderr, "%s:%s: %s\n",
251 host, port, gai_strerror (r));
255 /* Connect to the given TCP socket. */
256 for (rr = res; rr != NULL; rr = rr->ai_next) {
257 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
259 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
270 "unknown vmchannel connection type: %s\n"
271 "expecting \"tcp:<ip>:<port>\"\n",
279 "Failed to connect to any vmchannel implementation.\n"
282 "This is a fatal error and the appliance will now exit.\n"
284 "Usually this error is caused by either QEMU or the appliance\n"
285 "kernel not supporting the vmchannel method that the\n"
286 "libguestfs library chose to use. Please run\n"
287 "'libguestfs-test-tool' and provide the complete, unedited\n"
288 "output to the libguestfs developers, either in a bug report\n"
289 "or on the libguestfs redhat com mailing list.\n"
295 /* Send the magic length message which indicates that
296 * userspace is up inside the guest.
300 uint32_t len = GUESTFS_LAUNCH_FLAG;
301 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
302 xdr_uint32_t (&xdr, &len);
304 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
309 /* Fork into the background. */
311 if (daemon (0, 1) == -1) {
317 /* Enter the main loop, reading and performing actions. */
323 /* Read /proc/cmdline. */
327 int fd = open ("/proc/cmdline", O_RDONLY);
329 perror ("/proc/cmdline");
339 n = read (fd, buf, sizeof buf);
348 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
356 memcpy (&r[len], buf, n);
363 if (close (fd) == -1) {
372 /* Turn "/path" into "/sysroot/path".
374 * Caller must check for NULL and call reply_with_perror ("malloc")
375 * if it is. Caller must also free the string.
377 * See also the custom %R printf formatter which does shell quoting too.
380 sysroot_path (const char *path)
383 int len = strlen (path) + sysroot_len + 1;
389 snprintf (r, len, "%s%s", sysroot, path);
394 xwrite (int sock, const void *v_buf, size_t len)
397 const char *buf = v_buf;
400 r = write (sock, buf, len);
413 xread (int sock, void *v_buf, size_t len)
419 r = read (sock, buf, len);
425 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
436 add_string (char ***argv, int *size, int *alloc, const char *str)
441 if (*size >= *alloc) {
443 new_argv = realloc (*argv, *alloc * sizeof (char *));
444 if (new_argv == NULL) {
445 reply_with_perror ("realloc");
446 free_strings (*argv);
453 new_str = strdup (str);
454 if (new_str == NULL) {
455 reply_with_perror ("strdup");
456 free_strings (*argv);
461 (*argv)[*size] = new_str;
468 count_strings (char *const *argv)
472 for (argc = 0; argv[argc] != NULL; ++argc)
478 compare (const void *vp1, const void *vp2)
480 char * const *p1 = (char * const *) vp1;
481 char * const *p2 = (char * const *) vp2;
482 return strcmp (*p1, *p2);
486 sort_strings (char **argv, int len)
488 qsort (argv, len, sizeof (char *), compare);
492 free_strings (char **argv)
496 for (argc = 0; argv[argc] != NULL; ++argc)
502 free_stringslen (char **argv, int len)
506 for (i = 0; i < len; ++i)
511 /* Easy ways to run external commands. For full documentation, see
512 * 'commandrvf' below.
515 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
522 /* Collect the command line arguments into an array. */
524 argv = malloc (sizeof (char *) * i);
529 argv[0] = (char *) name;
532 va_start (args, name);
534 while ((s = va_arg (args, char *)) != NULL) {
535 const char **p = realloc (argv, sizeof (char *) * (++i));
549 r = commandvf (stdoutput, stderror, flags, (char **) argv);
551 /* NB: Mustn't free the strings which are on the stack. */
557 /* Same as 'command', but we allow the status code from the
558 * subcommand to be non-zero, and return that status code.
559 * We still return -1 if there was some other error.
562 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
569 /* Collect the command line arguments into an array. */
571 argv = malloc (sizeof (char *) * i);
576 argv[0] = (char *) name;
579 va_start (args, name);
581 while ((s = va_arg (args, char *)) != NULL) {
582 const char **p = realloc (argv, sizeof (char *) * (++i));
596 r = commandrvf (stdoutput, stderror, flags, argv);
598 /* NB: Mustn't free the strings which are on the stack. */
604 /* Same as 'command', but passing an argv. */
606 commandvf (char **stdoutput, char **stderror, int flags, char *const *argv)
610 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
617 /* This is a more sane version of 'system(3)' for running external
618 * commands. It uses fork/execvp, so we don't need to worry about
619 * quoting of parameters, and it allows us to capture any error
620 * messages in a buffer.
622 * If stdoutput is not NULL, then *stdoutput will return the stdout
625 * If stderror is not NULL, then *stderror will return the stderr
626 * of the command. If there is a final \n character, it is removed
627 * so you can use the error string directly in a call to
632 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
633 * that send error messages to stdout (hello, parted) but that don't
634 * have any useful stdout information, use this flag to capture the
635 * error messages in the *stderror buffer. If using this flag,
636 * you should pass stdoutput as NULL because nothing could ever be
637 * captured in that buffer.
640 commandrvf (char **stdoutput, char **stderror, int flags,
641 char const* const *argv)
643 int so_size = 0, se_size = 0;
644 int so_fd[2], se_fd[2];
651 if (stdoutput) *stdoutput = NULL;
652 if (stderror) *stderror = NULL;
655 printf ("%s", argv[0]);
656 for (i = 1; argv[i] != NULL; ++i)
657 printf (" %s", argv[i]);
661 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
676 if (pid == 0) { /* Child process. */
678 open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
681 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
689 execvp (argv[0], (void *) argv);
694 /* Parent process. */
699 FD_SET (so_fd[0], &rset);
700 FD_SET (se_fd[0], &rset);
705 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
709 if (stdoutput) free (*stdoutput);
710 if (stderror) free (*stderror);
713 waitpid (pid, NULL, 0);
717 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
718 r = read (so_fd[0], buf, sizeof buf);
723 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
725 if (r > 0 && stdoutput) {
727 p = realloc (*stdoutput, so_size);
733 memcpy (*stdoutput + so_size - r, buf, r);
737 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
738 r = read (se_fd[0], buf, sizeof buf);
743 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
745 if (r > 0 && stderror) {
747 p = realloc (*stderror, se_size);
753 memcpy (*stderror + se_size - r, buf, r);
761 /* Make sure the output buffers are \0-terminated. Also remove any
762 * trailing \n characters from the error buffer (not from stdout).
765 void *q = realloc (*stdoutput, so_size+1);
772 (*stdoutput)[so_size] = '\0';
775 void *q = realloc (*stderror, se_size+1);
782 (*stderror)[se_size] = '\0';
784 while (se_size >= 0 && (*stderror)[se_size] == '\n')
785 (*stderror)[se_size--] = '\0';
789 /* Get the exit status of the command. */
790 if (waitpid (pid, &r, 0) != pid) {
796 return WEXITSTATUS (r);
801 /* Split an output string into a NULL-terminated list of lines.
802 * Typically this is used where we have run an external command
803 * which has printed out a list of things, and we want to return
806 * The corner cases here are quite tricky. Note in particular:
810 * "a\nb" -> ["a"; "b"]
811 * "a\nb\n" -> ["a"; "b"]
812 * "a\nb\n\n" -> ["a"; "b"; ""]
814 * The original string is written over and destroyed by this
815 * function (which is usually OK because it's the 'out' string
816 * from command()). You can free the original string, because
817 * add_string() strdups the strings.
820 split_lines (char *str)
823 int size = 0, alloc = 0;
826 if (strcmp (str, "") == 0)
831 /* Empty last line? */
835 pend = strchr (p, '\n');
841 if (add_string (&lines, &size, &alloc, p) == -1) {
849 if (add_string (&lines, &size, &alloc, NULL) == -1)
855 /* printf helper function so we can use %Q ("quoted") and %R to print
856 * shell-quoted strings. See HACKING file for more details.
859 print_shell_quote (FILE *stream,
860 const struct printf_info *info ATTRIBUTE_UNUSED,
861 const void *const *args)
863 #define SAFE(c) (c_isalnum((c)) || \
864 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
866 const char *str = *((const char **) (args[0]));
868 for (i = len = 0; str[i]; ++i) {
873 putc (str[i], stream);
881 print_sysroot_shell_quote (FILE *stream,
882 const struct printf_info *info,
883 const void *const *args)
885 fputs (sysroot, stream);
886 return sysroot_len + print_shell_quote (stream, info, args);
889 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
891 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
892 size_t n, int *argtypes, int *size)
895 argtypes[0] = PA_STRING;
896 size[0] = sizeof (const char *);
901 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
903 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
906 argtypes[0] = PA_STRING;
910 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
914 /* Perform device name translation. Don't call this directly -
915 * use the RESOLVE_DEVICE macro.
917 * See guestfs(3) for the algorithm.
919 * We have to open the device and test for ENXIO, because
920 * the device nodes themselves will exist in the appliance.
923 device_name_translation (char *device, const char *func)
927 fd = open (device, O_RDONLY);
933 if (errno != ENXIO && errno != ENOENT) {
935 reply_with_perror ("%s: %s", func, device);
939 /* If the name begins with "/dev/sd" then try the alternatives. */
940 if (strncmp (device, "/dev/sd", 7) != 0)
943 device[5] = 'h'; /* /dev/hd (old IDE driver) */
944 fd = open (device, O_RDONLY);
950 device[5] = 'v'; /* /dev/vd (for virtio devices) */
951 fd = open (device, O_RDONLY);
957 device[5] = 's'; /* Restore original device name. */
961 /* LVM and other commands aren't synchronous, especially when udev is
962 * involved. eg. You can create or remove some device, but the /dev
963 * device node won't appear until some time later. This means that
964 * you get an error if you run one command followed by another.
965 * Use 'udevadm settle' after certain commands, but don't be too
966 * fussed if it fails.
971 command (NULL, NULL, "/sbin/udevadm", "settle", NULL);