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) */
31 #include <rpc/types.h>
34 #include <sys/param.h>
35 #include <sys/types.h>
40 #include <sys/select.h>
48 #include "ignore-value.h"
52 static char *read_cmdline (void);
54 /* Also in guestfs.c */
55 #define GUESTFWD_ADDR "10.0.2.4"
56 #define GUESTFWD_PORT "6666"
58 /* This is only a hint. If not defined, ignore it. */
60 # define AI_ADDRCONFIG 0
64 # define MAX(a,b) ((a)>(b)?(a):(b))
69 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
70 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
71 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
72 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
74 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
75 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
77 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
83 daemon (int nochdir, int noclose)
86 "On Windows the daemon does not support forking into the "
87 "background.\nYou *must* run the daemon with the -f option.\n");
92 /* Location to mount root device. */
93 const char *sysroot = "/sysroot"; /* No trailing slash. */
100 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
104 main (int argc, char *argv[])
106 static const char *options = "fc:v?";
107 static const struct option long_options[] = {
108 { "channel", required_argument, 0, 'c' },
109 { "foreground", 0, 0, 'f' },
110 { "help", 0, 0, '?' },
111 { "verbose", 0, 0, 'v' },
117 char *vmchannel = NULL;
119 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
120 /* http://udrepper.livejournal.com/20948.html */
121 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
122 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
124 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
125 register_printf_function ('Q', print_shell_quote, print_arginfo);
126 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
128 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
133 c = getopt_long (argc, argv, options, long_options, NULL);
154 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
164 cmdline = read_cmdline ();
166 /* Set the verbose flag. */
168 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
170 printf ("verbose daemon enabled\n");
174 printf ("linux commmand line: %s\n", cmdline);
176 printf ("could not read linux command line\n");
180 /* Make sure SIGPIPE doesn't kill us. */
182 memset (&sa, 0, sizeof sa);
183 sa.sa_handler = SIG_IGN;
185 if (sigaction (SIGPIPE, &sa, NULL) == -1)
186 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
190 # define setenv(n,v,f) _putenv(n "=" v)
192 /* Set up a basic environment. After we are called by /init the
193 * environment is essentially empty.
194 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
196 setenv ("PATH", "/usr/bin:/bin", 1);
197 setenv ("SHELL", "/bin/sh", 1);
198 setenv ("LC_ALL", "C", 1);
201 /* We document that umask defaults to 022 (it should be this anyway). */
204 /* This is the default for Windows anyway. It's not even clear if
205 * Windows ever uses this -- the MSDN documentation for the function
206 * contains obvious errors.
211 /* Get the vmchannel string.
214 * --channel/-c option on the command line
215 * guestfs_vmchannel=... from the kernel command line
216 * guestfs=... from the kernel command line
219 * At the moment we expect this to contain "tcp:ip:port" but in
220 * future it might contain a device name, eg. "/dev/vcon4" for
221 * virtio-console vmchannel.
223 if (vmchannel == NULL && cmdline) {
227 p = strstr (cmdline, "guestfs_vmchannel=");
229 len = strcspn (p + 18, " \t\n");
230 vmchannel = strndup (p + 18, len);
237 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
238 if (vmchannel == NULL) {
239 /* We will rewrite it part of the "guestfs=" string with
240 * "tcp:" hence p + 4 below. */
241 p = strstr (cmdline, "guestfs=");
243 len = strcspn (p + 4, " \t\n");
244 vmchannel = strndup (p + 4, len);
249 memcpy (vmchannel, "tcp:", 4);
254 /* Default vmchannel. */
255 if (vmchannel == NULL) {
256 vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
264 printf ("vmchannel: %s\n", vmchannel);
266 /* Connect to vmchannel. */
269 if (STREQLEN (vmchannel, "tcp:", 4)) {
270 /* Resolve the hostname. */
271 struct addrinfo *res, *rr;
272 struct addrinfo hints;
277 port = strchr (host, ':');
282 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
287 memset (&hints, 0, sizeof hints);
288 hints.ai_socktype = SOCK_STREAM;
289 hints.ai_flags = AI_ADDRCONFIG;
290 r = getaddrinfo (host, port, &hints, &res);
292 fprintf (stderr, "%s:%s: %s\n",
293 host, port, gai_strerror (r));
297 /* Connect to the given TCP socket. */
298 for (rr = res; rr != NULL; rr = rr->ai_next) {
299 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
301 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
312 "unknown vmchannel connection type: %s\n"
313 "expecting \"tcp:<ip>:<port>\"\n",
321 "Failed to connect to any vmchannel implementation.\n"
324 "This is a fatal error and the appliance will now exit.\n"
326 "Usually this error is caused by either QEMU or the appliance\n"
327 "kernel not supporting the vmchannel method that the\n"
328 "libguestfs library chose to use. Please run\n"
329 "'libguestfs-test-tool' and provide the complete, unedited\n"
330 "output to the libguestfs developers, either in a bug report\n"
331 "or on the libguestfs redhat com mailing list.\n"
337 /* Send the magic length message which indicates that
338 * userspace is up inside the guest.
342 uint32_t len = GUESTFS_LAUNCH_FLAG;
343 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
344 xdr_u_int (&xdr, &len);
346 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
351 /* Fork into the background. */
353 if (daemon (0, 1) == -1) {
359 /* Enter the main loop, reading and performing actions. */
365 /* Read /proc/cmdline. */
369 int fd = open ("/proc/cmdline", O_RDONLY);
371 perror ("/proc/cmdline");
381 n = read (fd, buf, sizeof buf);
390 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
398 memcpy (&r[len], buf, n);
405 if (close (fd) == -1) {
414 /* Turn "/path" into "/sysroot/path".
416 * Caller must check for NULL and call reply_with_perror ("malloc")
417 * if it is. Caller must also free the string.
419 * See also the custom %R printf formatter which does shell quoting too.
422 sysroot_path (const char *path)
425 int len = strlen (path) + sysroot_len + 1;
431 snprintf (r, len, "%s%s", sysroot, path);
436 xwrite (int sock, const void *v_buf, size_t len)
439 const char *buf = v_buf;
442 r = write (sock, buf, len);
455 xread (int sock, void *v_buf, size_t len)
461 r = read (sock, buf, len);
467 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
478 add_string (char ***argv, int *size, int *alloc, const char *str)
483 if (*size >= *alloc) {
485 new_argv = realloc (*argv, *alloc * sizeof (char *));
486 if (new_argv == NULL) {
487 reply_with_perror ("realloc");
488 free_strings (*argv);
495 new_str = strdup (str);
496 if (new_str == NULL) {
497 reply_with_perror ("strdup");
498 free_strings (*argv);
503 (*argv)[*size] = new_str;
510 count_strings (char *const *argv)
514 for (argc = 0; argv[argc] != NULL; ++argc)
520 compare (const void *vp1, const void *vp2)
522 char * const *p1 = (char * const *) vp1;
523 char * const *p2 = (char * const *) vp2;
524 return strcmp (*p1, *p2);
528 sort_strings (char **argv, int len)
530 qsort (argv, len, sizeof (char *), compare);
534 free_strings (char **argv)
538 for (argc = 0; argv[argc] != NULL; ++argc)
544 free_stringslen (char **argv, int len)
548 for (i = 0; i < len; ++i)
553 /* Easy ways to run external commands. For full documentation, see
554 * 'commandrvf' below.
557 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
564 /* Collect the command line arguments into an array. */
566 argv = malloc (sizeof (char *) * i);
571 argv[0] = (char *) name;
574 va_start (args, name);
576 while ((s = va_arg (args, char *)) != NULL) {
577 const char **p = realloc (argv, sizeof (char *) * (++i));
591 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
593 /* NB: Mustn't free the strings which are on the stack. */
599 /* Same as 'command', but we allow the status code from the
600 * subcommand to be non-zero, and return that status code.
601 * We still return -1 if there was some other error.
604 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
611 /* Collect the command line arguments into an array. */
613 argv = malloc (sizeof (char *) * i);
618 argv[0] = (char *) name;
621 va_start (args, name);
623 while ((s = va_arg (args, char *)) != NULL) {
624 const char **p = realloc (argv, sizeof (char *) * (++i));
638 r = commandrvf (stdoutput, stderror, flags, argv);
640 /* NB: Mustn't free the strings which are on the stack. */
646 /* Same as 'command', but passing an argv. */
648 commandvf (char **stdoutput, char **stderror, int flags,
649 char const *const *argv)
653 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
660 /* This is a more sane version of 'system(3)' for running external
661 * commands. It uses fork/execvp, so we don't need to worry about
662 * quoting of parameters, and it allows us to capture any error
663 * messages in a buffer.
665 * If stdoutput is not NULL, then *stdoutput will return the stdout
668 * If stderror is not NULL, then *stderror will return the stderr
669 * of the command. If there is a final \n character, it is removed
670 * so you can use the error string directly in a call to
675 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
676 * that send error messages to stdout (hello, parted) but that don't
677 * have any useful stdout information, use this flag to capture the
678 * error messages in the *stderror buffer. If using this flag,
679 * you should pass stdoutput as NULL because nothing could ever be
680 * captured in that buffer.
683 commandrvf (char **stdoutput, char **stderror, int flags,
684 char const* const *argv)
686 int so_size = 0, se_size = 0;
687 int so_fd[2], se_fd[2];
694 if (stdoutput) *stdoutput = NULL;
695 if (stderror) *stderror = NULL;
698 printf ("%s", argv[0]);
699 for (i = 1; argv[i] != NULL; ++i)
700 printf (" %s", argv[i]);
704 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
719 if (pid == 0) { /* Child process. */
721 open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
724 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
732 execvp (argv[0], (void *) argv);
737 /* Parent process. */
742 FD_SET (so_fd[0], &rset);
743 FD_SET (se_fd[0], &rset);
748 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
752 if (stdoutput) free (*stdoutput);
753 if (stderror) free (*stderror);
756 waitpid (pid, NULL, 0);
760 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
761 r = read (so_fd[0], buf, sizeof buf);
766 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
768 if (r > 0 && stdoutput) {
770 p = realloc (*stdoutput, so_size);
776 memcpy (*stdoutput + so_size - r, buf, r);
780 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
781 r = read (se_fd[0], buf, sizeof buf);
786 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
790 ignore_value (write (2, buf, r));
794 p = realloc (*stderror, se_size);
800 memcpy (*stderror + se_size - r, buf, r);
809 /* Make sure the output buffers are \0-terminated. Also remove any
810 * trailing \n characters from the error buffer (not from stdout).
813 void *q = realloc (*stdoutput, so_size+1);
820 (*stdoutput)[so_size] = '\0';
823 void *q = realloc (*stderror, se_size+1);
830 (*stderror)[se_size] = '\0';
832 while (se_size >= 0 && (*stderror)[se_size] == '\n')
833 (*stderror)[se_size--] = '\0';
837 /* Get the exit status of the command. */
838 if (waitpid (pid, &r, 0) != pid) {
844 return WEXITSTATUS (r);
849 /* Split an output string into a NULL-terminated list of lines.
850 * Typically this is used where we have run an external command
851 * which has printed out a list of things, and we want to return
854 * The corner cases here are quite tricky. Note in particular:
858 * "a\nb" -> ["a"; "b"]
859 * "a\nb\n" -> ["a"; "b"]
860 * "a\nb\n\n" -> ["a"; "b"; ""]
862 * The original string is written over and destroyed by this
863 * function (which is usually OK because it's the 'out' string
864 * from command()). You can free the original string, because
865 * add_string() strdups the strings.
868 split_lines (char *str)
871 int size = 0, alloc = 0;
879 /* Empty last line? */
883 pend = strchr (p, '\n');
889 if (add_string (&lines, &size, &alloc, p) == -1) {
897 if (add_string (&lines, &size, &alloc, NULL) == -1)
903 /* printf helper function so we can use %Q ("quoted") and %R to print
904 * shell-quoted strings. See HACKING file for more details.
907 print_shell_quote (FILE *stream,
908 const struct printf_info *info ATTRIBUTE_UNUSED,
909 const void *const *args)
911 #define SAFE(c) (c_isalnum((c)) || \
912 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
914 const char *str = *((const char **) (args[0]));
916 for (i = len = 0; str[i]; ++i) {
921 putc (str[i], stream);
929 print_sysroot_shell_quote (FILE *stream,
930 const struct printf_info *info,
931 const void *const *args)
933 fputs (sysroot, stream);
934 return sysroot_len + print_shell_quote (stream, info, args);
937 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
939 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
940 size_t n, int *argtypes, int *size)
943 argtypes[0] = PA_STRING;
944 size[0] = sizeof (const char *);
949 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
951 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
954 argtypes[0] = PA_STRING;
958 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
962 /* Perform device name translation. Don't call this directly -
963 * use the RESOLVE_DEVICE macro.
965 * See guestfs(3) for the algorithm.
967 * We have to open the device and test for ENXIO, because
968 * the device nodes themselves will exist in the appliance.
971 device_name_translation (char *device, const char *func)
975 fd = open (device, O_RDONLY);
981 if (errno != ENXIO && errno != ENOENT) {
983 reply_with_perror ("%s: %s", func, device);
987 /* If the name begins with "/dev/sd" then try the alternatives. */
988 if (STRNEQLEN (device, "/dev/sd", 7))
991 device[5] = 'h'; /* /dev/hd (old IDE driver) */
992 fd = open (device, O_RDONLY);
998 device[5] = 'v'; /* /dev/vd (for virtio devices) */
999 fd = open (device, O_RDONLY);
1005 device[5] = 's'; /* Restore original device name. */
1009 /* LVM and other commands aren't synchronous, especially when udev is
1010 * involved. eg. You can create or remove some device, but the /dev
1011 * device node won't appear until some time later. This means that
1012 * you get an error if you run one command followed by another.
1013 * Use 'udevadm settle' after certain commands, but don't be too
1014 * fussed if it fails.
1019 static int which_prog = 0;
1021 if (which_prog == 0) {
1022 if (access ("/sbin/udevsettle", X_OK) == 0)
1024 else if (access ("/sbin/udevadm", X_OK) == 0)
1030 switch (which_prog) {
1032 command (NULL, NULL, "/sbin/udevadm", "settle", NULL);
1035 command (NULL, NULL, "/sbin/udevsettle", NULL);