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"
56 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
57 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
58 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
59 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
61 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
62 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
64 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
68 /* Location to mount root device. */
69 const char *sysroot = "/sysroot"; /* No trailing slash. */
76 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
80 main (int argc, char *argv[])
82 static const char *options = "fc:v?";
83 static const struct option long_options[] = {
84 { "channel", required_argument, 0, 'c' },
85 { "foreground", 0, 0, 'f' },
86 { "help", 0, 0, '?' },
87 { "verbose", 0, 0, 'v' },
93 char *vmchannel = NULL;
95 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
96 /* http://udrepper.livejournal.com/20948.html */
97 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
98 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
100 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
101 register_printf_function ('Q', print_shell_quote, print_arginfo);
102 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
104 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
109 c = getopt_long (argc, argv, options, long_options, NULL);
130 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
140 cmdline = read_cmdline ();
142 /* Set the verbose flag. */
144 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
146 printf ("verbose daemon enabled\n");
150 printf ("linux commmand line: %s\n", cmdline);
152 printf ("could not read linux command line\n");
155 /* Make sure SIGPIPE doesn't kill us. */
157 memset (&sa, 0, sizeof sa);
158 sa.sa_handler = SIG_IGN;
160 if (sigaction (SIGPIPE, &sa, NULL) == -1)
161 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
163 /* Set up a basic environment. After we are called by /init the
164 * environment is essentially empty.
165 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
167 setenv ("PATH", "/usr/bin:/bin", 1);
168 setenv ("SHELL", "/bin/sh", 1);
169 setenv ("LC_ALL", "C", 1);
171 /* We document that umask defaults to 022 (it should be this anyway). */
174 /* Get the vmchannel string.
177 * --channel/-c option on the command line
178 * guestfs_vmchannel=... from the kernel command line
179 * guestfs=... from the kernel command line
182 * At the moment we expect this to contain "tcp:ip:port" but in
183 * future it might contain a device name, eg. "/dev/vcon4" for
184 * virtio-console vmchannel.
186 if (vmchannel == NULL && cmdline) {
190 p = strstr (cmdline, "guestfs_vmchannel=");
192 len = strcspn (p + 18, " \t\n");
193 vmchannel = strndup (p + 18, len);
200 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
201 if (vmchannel == NULL) {
202 /* We will rewrite it part of the "guestfs=" string with
203 * "tcp:" hence p + 4 below. */
204 p = strstr (cmdline, "guestfs=");
206 len = strcspn (p + 4, " \t\n");
207 vmchannel = strndup (p + 4, len);
212 memcpy (vmchannel, "tcp:", 4);
217 /* Default vmchannel. */
218 if (vmchannel == NULL) {
219 vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
227 printf ("vmchannel: %s\n", vmchannel);
229 /* Connect to vmchannel. */
232 if (STREQLEN (vmchannel, "tcp:", 4)) {
233 /* Resolve the hostname. */
234 struct addrinfo *res, *rr;
235 struct addrinfo hints;
240 port = strchr (host, ':');
245 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
250 memset (&hints, 0, sizeof hints);
251 hints.ai_socktype = SOCK_STREAM;
252 hints.ai_flags = AI_ADDRCONFIG;
253 r = getaddrinfo (host, port, &hints, &res);
255 fprintf (stderr, "%s:%s: %s\n",
256 host, port, gai_strerror (r));
260 /* Connect to the given TCP socket. */
261 for (rr = res; rr != NULL; rr = rr->ai_next) {
262 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
264 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
275 "unknown vmchannel connection type: %s\n"
276 "expecting \"tcp:<ip>:<port>\"\n",
284 "Failed to connect to any vmchannel implementation.\n"
287 "This is a fatal error and the appliance will now exit.\n"
289 "Usually this error is caused by either QEMU or the appliance\n"
290 "kernel not supporting the vmchannel method that the\n"
291 "libguestfs library chose to use. Please run\n"
292 "'libguestfs-test-tool' and provide the complete, unedited\n"
293 "output to the libguestfs developers, either in a bug report\n"
294 "or on the libguestfs redhat com mailing list.\n"
300 /* Send the magic length message which indicates that
301 * userspace is up inside the guest.
305 uint32_t len = GUESTFS_LAUNCH_FLAG;
306 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
307 xdr_uint32_t (&xdr, &len);
309 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
314 /* Fork into the background. */
316 if (daemon (0, 1) == -1) {
322 /* Enter the main loop, reading and performing actions. */
328 /* Read /proc/cmdline. */
332 int fd = open ("/proc/cmdline", O_RDONLY);
334 perror ("/proc/cmdline");
344 n = read (fd, buf, sizeof buf);
353 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
361 memcpy (&r[len], buf, n);
368 if (close (fd) == -1) {
377 /* Turn "/path" into "/sysroot/path".
379 * Caller must check for NULL and call reply_with_perror ("malloc")
380 * if it is. Caller must also free the string.
382 * See also the custom %R printf formatter which does shell quoting too.
385 sysroot_path (const char *path)
388 int len = strlen (path) + sysroot_len + 1;
394 snprintf (r, len, "%s%s", sysroot, path);
399 xwrite (int sock, const void *v_buf, size_t len)
402 const char *buf = v_buf;
405 r = write (sock, buf, len);
418 xread (int sock, void *v_buf, size_t len)
424 r = read (sock, buf, len);
430 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
441 add_string (char ***argv, int *size, int *alloc, const char *str)
446 if (*size >= *alloc) {
448 new_argv = realloc (*argv, *alloc * sizeof (char *));
449 if (new_argv == NULL) {
450 reply_with_perror ("realloc");
451 free_strings (*argv);
458 new_str = strdup (str);
459 if (new_str == NULL) {
460 reply_with_perror ("strdup");
461 free_strings (*argv);
466 (*argv)[*size] = new_str;
473 count_strings (char *const *argv)
477 for (argc = 0; argv[argc] != NULL; ++argc)
483 compare (const void *vp1, const void *vp2)
485 char * const *p1 = (char * const *) vp1;
486 char * const *p2 = (char * const *) vp2;
487 return strcmp (*p1, *p2);
491 sort_strings (char **argv, int len)
493 qsort (argv, len, sizeof (char *), compare);
497 free_strings (char **argv)
501 for (argc = 0; argv[argc] != NULL; ++argc)
507 free_stringslen (char **argv, int len)
511 for (i = 0; i < len; ++i)
516 /* Easy ways to run external commands. For full documentation, see
517 * 'commandrvf' below.
520 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
527 /* Collect the command line arguments into an array. */
529 argv = malloc (sizeof (char *) * i);
534 argv[0] = (char *) name;
537 va_start (args, name);
539 while ((s = va_arg (args, char *)) != NULL) {
540 const char **p = realloc (argv, sizeof (char *) * (++i));
554 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
556 /* NB: Mustn't free the strings which are on the stack. */
562 /* Same as 'command', but we allow the status code from the
563 * subcommand to be non-zero, and return that status code.
564 * We still return -1 if there was some other error.
567 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
574 /* Collect the command line arguments into an array. */
576 argv = malloc (sizeof (char *) * i);
581 argv[0] = (char *) name;
584 va_start (args, name);
586 while ((s = va_arg (args, char *)) != NULL) {
587 const char **p = realloc (argv, sizeof (char *) * (++i));
601 r = commandrvf (stdoutput, stderror, flags, argv);
603 /* NB: Mustn't free the strings which are on the stack. */
609 /* Same as 'command', but passing an argv. */
611 commandvf (char **stdoutput, char **stderror, int flags,
612 char const *const *argv)
616 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
623 /* This is a more sane version of 'system(3)' for running external
624 * commands. It uses fork/execvp, so we don't need to worry about
625 * quoting of parameters, and it allows us to capture any error
626 * messages in a buffer.
628 * If stdoutput is not NULL, then *stdoutput will return the stdout
631 * If stderror is not NULL, then *stderror will return the stderr
632 * of the command. If there is a final \n character, it is removed
633 * so you can use the error string directly in a call to
638 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
639 * that send error messages to stdout (hello, parted) but that don't
640 * have any useful stdout information, use this flag to capture the
641 * error messages in the *stderror buffer. If using this flag,
642 * you should pass stdoutput as NULL because nothing could ever be
643 * captured in that buffer.
646 commandrvf (char **stdoutput, char **stderror, int flags,
647 char const* const *argv)
649 int so_size = 0, se_size = 0;
650 int so_fd[2], se_fd[2];
657 if (stdoutput) *stdoutput = NULL;
658 if (stderror) *stderror = NULL;
661 printf ("%s", argv[0]);
662 for (i = 1; argv[i] != NULL; ++i)
663 printf (" %s", argv[i]);
667 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
682 if (pid == 0) { /* Child process. */
684 open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
687 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
695 execvp (argv[0], (void *) argv);
700 /* Parent process. */
705 FD_SET (so_fd[0], &rset);
706 FD_SET (se_fd[0], &rset);
711 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
715 if (stdoutput) free (*stdoutput);
716 if (stderror) free (*stderror);
719 waitpid (pid, NULL, 0);
723 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
724 r = read (so_fd[0], buf, sizeof buf);
729 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
731 if (r > 0 && stdoutput) {
733 p = realloc (*stdoutput, so_size);
739 memcpy (*stdoutput + so_size - r, buf, r);
743 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
744 r = read (se_fd[0], buf, sizeof buf);
749 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
753 ignore_value (write (2, buf, r));
757 p = realloc (*stderror, se_size);
763 memcpy (*stderror + se_size - r, buf, r);
772 /* Make sure the output buffers are \0-terminated. Also remove any
773 * trailing \n characters from the error buffer (not from stdout).
776 void *q = realloc (*stdoutput, so_size+1);
783 (*stdoutput)[so_size] = '\0';
786 void *q = realloc (*stderror, se_size+1);
793 (*stderror)[se_size] = '\0';
795 while (se_size >= 0 && (*stderror)[se_size] == '\n')
796 (*stderror)[se_size--] = '\0';
800 /* Get the exit status of the command. */
801 if (waitpid (pid, &r, 0) != pid) {
807 return WEXITSTATUS (r);
812 /* Split an output string into a NULL-terminated list of lines.
813 * Typically this is used where we have run an external command
814 * which has printed out a list of things, and we want to return
817 * The corner cases here are quite tricky. Note in particular:
821 * "a\nb" -> ["a"; "b"]
822 * "a\nb\n" -> ["a"; "b"]
823 * "a\nb\n\n" -> ["a"; "b"; ""]
825 * The original string is written over and destroyed by this
826 * function (which is usually OK because it's the 'out' string
827 * from command()). You can free the original string, because
828 * add_string() strdups the strings.
831 split_lines (char *str)
834 int size = 0, alloc = 0;
842 /* Empty last line? */
846 pend = strchr (p, '\n');
852 if (add_string (&lines, &size, &alloc, p) == -1) {
860 if (add_string (&lines, &size, &alloc, NULL) == -1)
866 /* printf helper function so we can use %Q ("quoted") and %R to print
867 * shell-quoted strings. See HACKING file for more details.
870 print_shell_quote (FILE *stream,
871 const struct printf_info *info ATTRIBUTE_UNUSED,
872 const void *const *args)
874 #define SAFE(c) (c_isalnum((c)) || \
875 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
877 const char *str = *((const char **) (args[0]));
879 for (i = len = 0; str[i]; ++i) {
884 putc (str[i], stream);
892 print_sysroot_shell_quote (FILE *stream,
893 const struct printf_info *info,
894 const void *const *args)
896 fputs (sysroot, stream);
897 return sysroot_len + print_shell_quote (stream, info, args);
900 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
902 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
903 size_t n, int *argtypes, int *size)
906 argtypes[0] = PA_STRING;
907 size[0] = sizeof (const char *);
912 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
914 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
917 argtypes[0] = PA_STRING;
921 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
925 /* Perform device name translation. Don't call this directly -
926 * use the RESOLVE_DEVICE macro.
928 * See guestfs(3) for the algorithm.
930 * We have to open the device and test for ENXIO, because
931 * the device nodes themselves will exist in the appliance.
934 device_name_translation (char *device, const char *func)
938 fd = open (device, O_RDONLY);
944 if (errno != ENXIO && errno != ENOENT) {
946 reply_with_perror ("%s: %s", func, device);
950 /* If the name begins with "/dev/sd" then try the alternatives. */
951 if (STRNEQLEN (device, "/dev/sd", 7))
954 device[5] = 'h'; /* /dev/hd (old IDE driver) */
955 fd = open (device, O_RDONLY);
961 device[5] = 'v'; /* /dev/vd (for virtio devices) */
962 fd = open (device, O_RDONLY);
968 device[5] = 's'; /* Restore original device name. */
972 /* LVM and other commands aren't synchronous, especially when udev is
973 * involved. eg. You can create or remove some device, but the /dev
974 * device node won't appear until some time later. This means that
975 * you get an error if you run one command followed by another.
976 * Use 'udevadm settle' after certain commands, but don't be too
977 * fussed if it fails.
982 static int which_prog = 0;
984 if (which_prog == 0) {
985 if (access ("/sbin/udevsettle", X_OK) == 0)
987 else if (access ("/sbin/udevadm", X_OK) == 0)
993 switch (which_prog) {
995 command (NULL, NULL, "/sbin/udevadm", "settle", NULL);
998 command (NULL, NULL, "/sbin/udevsettle", NULL);