1 /* libguestfs - the guestfsd daemon
2 * Copyright (C) 2009-2010 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>
42 #include <arpa/inet.h>
43 #include <netinet/in.h>
52 #include "ignore-value.h"
57 static char *read_cmdline (void);
60 # define MAX(a,b) ((a)>(b)?(a):(b))
63 /* If root device is an ext2 filesystem, this is the major and minor.
64 * This is so we can ignore this device from the point of view of the
65 * user, eg. in guestfs_list_devices and many other places.
67 static dev_t root_device = 0;
71 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
72 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
73 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
74 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
76 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
77 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
79 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
85 daemon (int nochdir, int noclose)
88 "On Windows the daemon does not support forking into the "
89 "background.\nYou *must* run the daemon with the -f option.\n");
100 /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
101 r = gl_sockets_startup (SOCKETS_2_2);
102 return r == 0 ? 0 : -1;
112 /* Location to mount root device. */
113 const char *sysroot = "/sysroot"; /* No trailing slash. */
116 /* Not used explicitly, but required by the gnulib 'error' module. */
117 const char *program_name = "guestfsd";
123 "guestfsd [-f|--foreground] [-v|--verbose]\n");
127 main (int argc, char *argv[])
129 static const char *options = "fv?";
130 static const struct option long_options[] = {
131 { "foreground", 0, 0, 'f' },
132 { "help", 0, 0, '?' },
133 { "verbose", 0, 0, 'v' },
140 if (winsock_init () == -1)
141 error (EXIT_FAILURE, 0, "winsock initialization failed");
143 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
144 /* http://udrepper.livejournal.com/20948.html */
145 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
146 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
148 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
149 register_printf_function ('Q', print_shell_quote, print_arginfo);
150 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
152 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
157 if (stat ("/", &statbuf) == 0)
158 root_device = statbuf.st_dev;
161 c = getopt_long (argc, argv, options, long_options, NULL);
178 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
188 cmdline = read_cmdline ();
190 /* Set the verbose flag. */
192 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
194 printf ("verbose daemon enabled\n");
198 printf ("linux commmand line: %s\n", cmdline);
200 printf ("could not read linux command line\n");
204 /* Make sure SIGPIPE doesn't kill us. */
206 memset (&sa, 0, sizeof sa);
207 sa.sa_handler = SIG_IGN;
209 if (sigaction (SIGPIPE, &sa, NULL) == -1)
210 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
214 # define setenv(n,v,f) _putenv(n "=" v)
216 /* Set up a basic environment. After we are called by /init the
217 * environment is essentially empty.
218 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
220 * NOTE: if you change $PATH, you must also change 'prog_exists'
223 setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
224 setenv ("SHELL", "/bin/sh", 1);
225 setenv ("LC_ALL", "C", 1);
226 setenv ("TERM", "dumb", 1);
229 /* We document that umask defaults to 022 (it should be this anyway). */
232 /* This is the default for Windows anyway. It's not even clear if
233 * Windows ever uses this -- the MSDN documentation for the function
234 * contains obvious errors.
239 /* Connect to virtio-serial channel. */
240 int sock = open ("/dev/virtio-ports/org.libguestfs.channel.0", O_RDWR);
244 "Failed to connect to virtio-serial channel.\n"
246 "This is a fatal error and the appliance will now exit.\n"
248 "Usually this error is caused by either QEMU or the appliance\n"
249 "kernel not supporting the vmchannel method that the\n"
250 "libguestfs library chose to use. Please run\n"
251 "'libguestfs-test-tool' and provide the complete, unedited\n"
252 "output to the libguestfs developers, either in a bug report\n"
253 "or on the libguestfs redhat com mailing list.\n"
258 /* Send the magic length message which indicates that
259 * userspace is up inside the guest.
263 uint32_t len = GUESTFS_LAUNCH_FLAG;
264 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
265 xdr_u_int (&xdr, &len);
267 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
272 /* Fork into the background. */
274 if (daemon (0, 1) == -1) {
280 /* Enter the main loop, reading and performing actions. */
286 /* Read /proc/cmdline. */
290 int fd = open ("/proc/cmdline", O_RDONLY);
292 perror ("/proc/cmdline");
302 n = read (fd, buf, sizeof buf);
311 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
319 memcpy (&r[len], buf, n);
326 if (close (fd) == -1) {
335 /* Return true iff device is the root device (and therefore should be
336 * ignored from the point of view of user calls).
339 is_root_device (const char *device)
342 if (stat (device, &statbuf) == -1) {
346 if (statbuf.st_rdev == root_device)
351 /* Turn "/path" into "/sysroot/path".
353 * Caller must check for NULL and call reply_with_perror ("malloc")
354 * if it is. Caller must also free the string.
356 * See also the custom %R printf formatter which does shell quoting too.
359 sysroot_path (const char *path)
362 int len = strlen (path) + sysroot_len + 1;
368 snprintf (r, len, "%s%s", sysroot, path);
373 xwrite (int sock, const void *v_buf, size_t len)
376 const char *buf = v_buf;
379 r = write (sock, buf, len);
392 xread (int sock, void *v_buf, size_t len)
398 r = read (sock, buf, len);
404 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
415 add_string (char ***argv, int *size, int *alloc, const char *str)
420 if (*size >= *alloc) {
422 new_argv = realloc (*argv, *alloc * sizeof (char *));
423 if (new_argv == NULL) {
424 reply_with_perror ("realloc");
425 free_strings (*argv);
432 new_str = strdup (str);
433 if (new_str == NULL) {
434 reply_with_perror ("strdup");
435 free_strings (*argv);
440 (*argv)[*size] = new_str;
447 count_strings (char *const *argv)
451 for (argc = 0; argv[argc] != NULL; ++argc)
456 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
458 is_power_of_2 (unsigned long v)
460 return v && ((v & (v - 1)) == 0);
464 compare (const void *vp1, const void *vp2)
466 char * const *p1 = (char * const *) vp1;
467 char * const *p2 = (char * const *) vp2;
468 return strcmp (*p1, *p2);
472 sort_strings (char **argv, int len)
474 qsort (argv, len, sizeof (char *), compare);
478 free_strings (char **argv)
482 for (argc = 0; argv[argc] != NULL; ++argc)
488 free_stringslen (char **argv, int len)
492 for (i = 0; i < len; ++i)
497 /* Easy ways to run external commands. For full documentation, see
498 * 'commandrvf' below.
501 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
508 /* Collect the command line arguments into an array. */
510 argv = malloc (sizeof (char *) * i);
515 argv[0] = (char *) name;
518 va_start (args, name);
520 while ((s = va_arg (args, char *)) != NULL) {
521 const char **p = realloc (argv, sizeof (char *) * (++i));
535 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
537 /* NB: Mustn't free the strings which are on the stack. */
543 /* Same as 'command', but we allow the status code from the
544 * subcommand to be non-zero, and return that status code.
545 * We still return -1 if there was some other error.
548 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
555 /* Collect the command line arguments into an array. */
557 argv = malloc (sizeof (char *) * i);
562 argv[0] = (char *) name;
565 va_start (args, name);
567 while ((s = va_arg (args, char *)) != NULL) {
568 const char **p = realloc (argv, sizeof (char *) * (++i));
582 r = commandrvf (stdoutput, stderror, flags, argv);
584 /* NB: Mustn't free the strings which are on the stack. */
590 /* Same as 'command', but passing an argv. */
592 commandvf (char **stdoutput, char **stderror, int flags,
593 char const *const *argv)
597 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
604 /* This is a more sane version of 'system(3)' for running external
605 * commands. It uses fork/execvp, so we don't need to worry about
606 * quoting of parameters, and it allows us to capture any error
607 * messages in a buffer.
609 * If stdoutput is not NULL, then *stdoutput will return the stdout
612 * If stderror is not NULL, then *stderror will return the stderr
613 * of the command. If there is a final \n character, it is removed
614 * so you can use the error string directly in a call to
619 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
620 * that send error messages to stdout (hello, parted) but that don't
621 * have any useful stdout information, use this flag to capture the
622 * error messages in the *stderror buffer. If using this flag,
623 * you should pass stdoutput as NULL because nothing could ever be
624 * captured in that buffer.
626 * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
627 * commands on chrooted files correctly (see RHBZ#579608) specifying
628 * this flag causes another process to be forked which chroots into
629 * sysroot and just copies the input file to stdin of the specified
630 * command. The file descriptor is ORed with the flags, and that file
631 * descriptor is always closed by this function. See hexdump.c for an
635 commandrvf (char **stdoutput, char **stderror, int flags,
636 char const* const *argv)
638 int so_size = 0, se_size = 0;
639 int so_fd[2], se_fd[2];
640 int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
641 int stdin_fd[2] = { -1, -1 };
642 pid_t pid, stdin_pid = -1;
648 if (stdoutput) *stdoutput = NULL;
649 if (stderror) *stderror = NULL;
652 printf ("%s", argv[0]);
653 for (i = 1; argv[i] != NULL; ++i)
654 printf (" %s", argv[i]);
658 /* Note: abort is used in a few places along the error paths early
659 * in this function. This is because (a) cleaning up correctly is
660 * very complex at these places and (b) abort is used when a
661 * resource problems is indicated which would be due to much more
662 * serious issues - eg. memory or file descriptor leaks. We
663 * wouldn't expect fork(2) or pipe(2) to fail in normal
667 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
668 error (0, errno, "pipe");
672 if (flag_copy_stdin) {
673 if (pipe (stdin_fd) == -1) {
674 error (0, errno, "pipe");
681 error (0, errno, "fork");
685 if (pid == 0) { /* Child process running the command. */
687 if (flag_copy_stdin) {
688 dup2 (stdin_fd[0], 0);
692 /* Set stdin to /dev/null (ignore failure) */
693 open ("/dev/null", O_RDONLY);
697 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
705 execvp (argv[0], (void *) argv);
707 _exit (EXIT_FAILURE);
710 if (flag_copy_stdin) {
711 int fd = flags & COMMAND_FLAG_FD_MASK;
714 if (stdin_pid == -1) {
715 error (0, errno, "fork");
719 if (stdin_pid == 0) { /* Child process copying stdin. */
726 dup2 (stdin_fd[1], 1);
730 if (chroot (sysroot) == -1) {
732 _exit (EXIT_FAILURE);
737 while ((n = read (fd, buffer, sizeof buffer)) > 0) {
738 if (xwrite (1, buffer, n) == -1)
739 /* EPIPE error indicates the command process has exited
740 * early. If the command process fails that will be caught
741 * by the daemon, and if not, then it's not an error.
743 _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
748 _exit (EXIT_FAILURE);
751 if (close (fd) == -1) {
753 _exit (EXIT_FAILURE);
756 _exit (EXIT_SUCCESS);
764 /* Parent process. */
769 FD_SET (so_fd[0], &rset);
770 FD_SET (se_fd[0], &rset);
775 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
779 if (stdoutput) free (*stdoutput);
780 if (stderror) free (*stderror);
783 waitpid (pid, NULL, 0);
784 if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
788 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
789 r = read (so_fd[0], buf, sizeof buf);
794 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
796 if (r > 0 && stdoutput) {
798 p = realloc (*stdoutput, so_size);
804 memcpy (*stdoutput + so_size - r, buf, r);
808 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
809 r = read (se_fd[0], buf, sizeof buf);
814 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
818 ignore_value (write (2, buf, r));
822 p = realloc (*stderror, se_size);
828 memcpy (*stderror + se_size - r, buf, r);
837 /* Make sure the output buffers are \0-terminated. Also remove any
838 * trailing \n characters from the error buffer (not from stdout).
841 void *q = realloc (*stdoutput, so_size+1);
848 (*stdoutput)[so_size] = '\0';
851 void *q = realloc (*stderror, se_size+1);
858 (*stderror)[se_size] = '\0';
860 while (se_size >= 0 && (*stderror)[se_size] == '\n')
861 (*stderror)[se_size--] = '\0';
865 if (flag_copy_stdin) {
866 /* Check copy process didn't fail. */
867 if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
870 waitpid (pid, NULL, 0);
874 if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
875 fprintf (stderr, "failed copying from input file, see earlier messages\n");
877 waitpid (pid, NULL, 0);
882 /* Get the exit status of the command. */
883 if (waitpid (pid, &r, 0) != pid) {
889 return WEXITSTATUS (r);
894 /* Split an output string into a NULL-terminated list of lines.
895 * Typically this is used where we have run an external command
896 * which has printed out a list of things, and we want to return
899 * The corner cases here are quite tricky. Note in particular:
903 * "a\nb" -> ["a"; "b"]
904 * "a\nb\n" -> ["a"; "b"]
905 * "a\nb\n\n" -> ["a"; "b"; ""]
907 * The original string is written over and destroyed by this
908 * function (which is usually OK because it's the 'out' string
909 * from command()). You can free the original string, because
910 * add_string() strdups the strings.
913 split_lines (char *str)
916 int size = 0, alloc = 0;
924 /* Empty last line? */
928 pend = strchr (p, '\n');
934 if (add_string (&lines, &size, &alloc, p) == -1) {
942 if (add_string (&lines, &size, &alloc, NULL) == -1)
948 /* Skip leading and trailing whitespace, updating the original string
954 size_t len = strlen (str);
956 while (len > 0 && c_isspace (str[len-1])) {
962 while (*p && c_isspace (*p)) {
967 memmove (str, p, len+1);
970 /* printf helper function so we can use %Q ("quoted") and %R to print
971 * shell-quoted strings. See HACKING file for more details.
974 print_shell_quote (FILE *stream,
975 const struct printf_info *info ATTRIBUTE_UNUSED,
976 const void *const *args)
978 #define SAFE(c) (c_isalnum((c)) || \
979 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
981 const char *str = *((const char **) (args[0]));
983 for (i = len = 0; str[i]; ++i) {
988 putc (str[i], stream);
996 print_sysroot_shell_quote (FILE *stream,
997 const struct printf_info *info,
998 const void *const *args)
1000 fputs (sysroot, stream);
1001 return sysroot_len + print_shell_quote (stream, info, args);
1004 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1006 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1007 size_t n, int *argtypes, int *size)
1010 argtypes[0] = PA_STRING;
1011 size[0] = sizeof (const char *);
1016 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1018 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1021 argtypes[0] = PA_STRING;
1025 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1029 /* Perform device name translation. Don't call this directly -
1030 * use the RESOLVE_DEVICE macro.
1032 * See guestfs(3) for the algorithm.
1034 * We have to open the device and test for ENXIO, because
1035 * the device nodes themselves will exist in the appliance.
1038 device_name_translation (char *device)
1042 fd = open (device, O_RDONLY);
1049 if (errno != ENXIO && errno != ENOENT)
1052 /* If the name begins with "/dev/sd" then try the alternatives. */
1053 if (STRNEQLEN (device, "/dev/sd", 7))
1056 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1057 fd = open (device, O_RDONLY);
1061 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1062 fd = open (device, O_RDONLY);
1066 device[5] = 's'; /* Restore original device name. */
1070 /* Check program exists and is executable on $PATH. Actually, we
1071 * just assume PATH contains the default entries (see main() above).
1074 prog_exists (const char *prog)
1076 static const char * const dirs[] =
1077 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1081 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1082 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1083 if (access (buf, X_OK) == 0)
1089 /* LVM and other commands aren't synchronous, especially when udev is
1090 * involved. eg. You can create or remove some device, but the /dev
1091 * device node won't appear until some time later. This means that
1092 * you get an error if you run one command followed by another.
1094 * Use 'udevadm settle' after certain commands, but don't be too
1095 * fussed if it fails.
1097 * 'udevsettle' was the old name for this command (RHEL 5). This was
1098 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1099 * command was left as a symlink. Then in Fedora 13 the old symlink
1100 * remained but it stopped working (RHBZ#548121), so we have to be
1101 * careful not to assume that we can use 'udevsettle' if it exists.
1106 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1107 (void) command (NULL, NULL, "udevsettle", NULL);