1 /* libguestfs - the guestfsd daemon
2 * Copyright (C) 2009-2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
29 #include <rpc/types.h>
32 #include <sys/param.h>
33 #include <sys/types.h>
38 #include <sys/select.h>
40 #include <arpa/inet.h>
41 #include <netinet/in.h>
50 #include "ignore-value.h"
55 static char *read_cmdline (void);
58 # define MAX(a,b) ((a)>(b)?(a):(b))
61 /* Not the end of the world if this open flag is not defined. */
66 /* If root device is an ext2 filesystem, this is the major and minor.
67 * This is so we can ignore this device from the point of view of the
68 * user, eg. in guestfs_list_devices and many other places.
70 static dev_t root_device = 0;
74 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
75 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
76 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
77 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
79 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
80 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
82 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
92 /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
93 r = gl_sockets_startup (SOCKETS_2_2);
94 return r == 0 ? 0 : -1;
104 /* Location to mount root device. */
105 const char *sysroot = "/sysroot"; /* No trailing slash. */
106 size_t sysroot_len = 8;
108 /* If set (the default), do 'umount-all' when performing autosync. */
109 int autosync_umount = 1;
111 /* Not used explicitly, but required by the gnulib 'error' module. */
112 const char *program_name = "guestfsd";
114 /* Name of the virtio-serial channel. */
115 #define VIRTIO_SERIAL_CHANNEL "/dev/virtio-ports/org.libguestfs.channel.0"
121 "guestfsd [-r] [-v|--verbose]\n");
125 main (int argc, char *argv[])
127 static const char *options = "rv?";
128 static const struct option long_options[] = {
129 { "help", 0, 0, '?' },
130 { "verbose", 0, 0, 'v' },
136 ignore_value (chdir ("/"));
138 if (winsock_init () == -1)
139 error (EXIT_FAILURE, 0, "winsock initialization failed");
141 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
142 /* http://udrepper.livejournal.com/20948.html */
143 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
144 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
146 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
147 register_printf_function ('Q', print_shell_quote, print_arginfo);
148 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
150 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
155 if (stat ("/", &statbuf) == 0)
156 root_device = statbuf.st_dev;
159 c = getopt_long (argc, argv, options, long_options, NULL);
163 /* The -r flag is used when running standalone. It changes
164 * several aspects of the daemon.
181 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
191 cmdline = read_cmdline ();
193 /* Set the verbose flag. */
195 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
197 printf ("verbose daemon enabled\n");
201 printf ("linux commmand line: %s\n", cmdline);
203 printf ("could not read linux command line\n");
207 /* Make sure SIGPIPE doesn't kill us. */
209 memset (&sa, 0, sizeof sa);
210 sa.sa_handler = SIG_IGN;
212 if (sigaction (SIGPIPE, &sa, NULL) == -1)
213 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
217 # define setenv(n,v,f) _putenv(n "=" v)
219 /* Set up a basic environment. After we are called by /init the
220 * environment is essentially empty.
221 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
223 * NOTE: if you change $PATH, you must also change 'prog_exists'
226 setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
227 setenv ("SHELL", "/bin/sh", 1);
228 setenv ("LC_ALL", "C", 1);
229 setenv ("TERM", "dumb", 1);
232 /* We document that umask defaults to 022 (it should be this anyway). */
235 /* This is the default for Windows anyway. It's not even clear if
236 * Windows ever uses this -- the MSDN documentation for the function
237 * contains obvious errors.
242 /* Make a private copy of /etc/lvm so we can change the config (see
243 * daemon/lvm-filter.c).
247 /* Connect to virtio-serial channel. */
248 int sock = open (VIRTIO_SERIAL_CHANNEL, O_RDWR | O_CLOEXEC);
252 "Failed to connect to virtio-serial channel.\n"
254 "This is a fatal error and the appliance will now exit.\n"
256 "Usually this error is caused by either QEMU or the appliance\n"
257 "kernel not supporting the vmchannel method that the\n"
258 "libguestfs library chose to use. Please run\n"
259 "'libguestfs-test-tool' and provide the complete, unedited\n"
260 "output to the libguestfs developers, either in a bug report\n"
261 "or on the libguestfs redhat com mailing list.\n"
263 perror (VIRTIO_SERIAL_CHANNEL);
267 /* Send the magic length message which indicates that
268 * userspace is up inside the guest.
272 uint32_t len = GUESTFS_LAUNCH_FLAG;
273 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
274 xdr_u_int (&xdr, &len);
276 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1) {
283 /* Enter the main loop, reading and performing actions. */
289 /* Read /proc/cmdline. */
293 int fd = open ("/proc/cmdline", O_RDONLY);
295 perror ("/proc/cmdline");
305 n = read (fd, buf, sizeof buf);
314 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
322 memcpy (&r[len], buf, n);
329 if (close (fd) == -1) {
338 /* Return true iff device is the root device (and therefore should be
339 * ignored from the point of view of user calls).
342 is_root_device (const char *device)
345 if (stat (device, &statbuf) == -1) {
349 if (statbuf.st_rdev == root_device)
354 /* Turn "/path" into "/sysroot/path".
356 * Caller must check for NULL and call reply_with_perror ("malloc")
357 * if it is. Caller must also free the string.
359 * See also the custom %R printf formatter which does shell quoting too.
362 sysroot_path (const char *path)
365 int len = strlen (path) + sysroot_len + 1;
371 snprintf (r, len, "%s%s", sysroot, path);
376 xwrite (int sock, const void *v_buf, size_t len)
379 const char *buf = v_buf;
382 r = write (sock, buf, len);
395 xread (int sock, void *v_buf, size_t len)
401 r = read (sock, buf, len);
407 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
418 add_string (char ***argv, int *size, int *alloc, const char *str)
423 if (*size >= *alloc) {
425 new_argv = realloc (*argv, *alloc * sizeof (char *));
426 if (new_argv == NULL) {
427 reply_with_perror ("realloc");
428 free_strings (*argv);
435 new_str = strdup (str);
436 if (new_str == NULL) {
437 reply_with_perror ("strdup");
438 free_strings (*argv);
444 (*argv)[*size] = new_str;
451 count_strings (char *const *argv)
455 for (argc = 0; argv[argc] != NULL; ++argc)
460 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
462 is_power_of_2 (unsigned long v)
464 return v && ((v & (v - 1)) == 0);
468 compare (const void *vp1, const void *vp2)
470 char * const *p1 = (char * const *) vp1;
471 char * const *p2 = (char * const *) vp2;
472 return strcmp (*p1, *p2);
476 sort_strings (char **argv, int len)
478 qsort (argv, len, sizeof (char *), compare);
482 free_strings (char **argv)
486 for (argc = 0; argv[argc] != NULL; ++argc)
492 free_stringslen (char **argv, int len)
496 for (i = 0; i < len; ++i)
501 /* Easy ways to run external commands. For full documentation, see
502 * 'commandrvf' below.
505 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
512 /* Collect the command line arguments into an array. */
514 argv = malloc (sizeof (char *) * i);
519 argv[0] = (char *) name;
522 va_start (args, name);
524 while ((s = va_arg (args, char *)) != NULL) {
525 const char **p = realloc (argv, sizeof (char *) * (++i));
539 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
541 /* NB: Mustn't free the strings which are on the stack. */
547 /* Same as 'command', but we allow the status code from the
548 * subcommand to be non-zero, and return that status code.
549 * We still return -1 if there was some other error.
552 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
559 /* Collect the command line arguments into an array. */
561 argv = malloc (sizeof (char *) * i);
566 argv[0] = (char *) name;
569 va_start (args, name);
571 while ((s = va_arg (args, char *)) != NULL) {
572 const char **p = realloc (argv, sizeof (char *) * (++i));
586 r = commandrvf (stdoutput, stderror, flags, argv);
588 /* NB: Mustn't free the strings which are on the stack. */
594 /* Same as 'command', but passing an argv. */
596 commandvf (char **stdoutput, char **stderror, int flags,
597 char const *const *argv)
601 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
608 /* This is a more sane version of 'system(3)' for running external
609 * commands. It uses fork/execvp, so we don't need to worry about
610 * quoting of parameters, and it allows us to capture any error
611 * messages in a buffer.
613 * If stdoutput is not NULL, then *stdoutput will return the stdout
616 * If stderror is not NULL, then *stderror will return the stderr
617 * of the command. If there is a final \n character, it is removed
618 * so you can use the error string directly in a call to
623 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
624 * that send error messages to stdout (hello, parted) but that don't
625 * have any useful stdout information, use this flag to capture the
626 * error messages in the *stderror buffer. If using this flag,
627 * you should pass stdoutput as NULL because nothing could ever be
628 * captured in that buffer.
630 * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
631 * commands on chrooted files correctly (see RHBZ#579608) specifying
632 * this flag causes another process to be forked which chroots into
633 * sysroot and just copies the input file to stdin of the specified
634 * command. The file descriptor is ORed with the flags, and that file
635 * descriptor is always closed by this function. See hexdump.c for an
639 commandrvf (char **stdoutput, char **stderror, int flags,
640 char const* const *argv)
642 int so_size = 0, se_size = 0;
643 int so_fd[2], se_fd[2];
644 int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
645 int stdin_fd[2] = { -1, -1 };
646 pid_t pid, stdin_pid = -1;
652 if (stdoutput) *stdoutput = NULL;
653 if (stderror) *stderror = NULL;
656 printf ("%s", argv[0]);
657 for (i = 1; argv[i] != NULL; ++i)
658 printf (" %s", argv[i]);
662 /* Note: abort is used in a few places along the error paths early
663 * in this function. This is because (a) cleaning up correctly is
664 * very complex at these places and (b) abort is used when a
665 * resource problems is indicated which would be due to much more
666 * serious issues - eg. memory or file descriptor leaks. We
667 * wouldn't expect fork(2) or pipe(2) to fail in normal
671 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
672 error (0, errno, "pipe");
676 if (flag_copy_stdin) {
677 if (pipe (stdin_fd) == -1) {
678 error (0, errno, "pipe");
685 error (0, errno, "fork");
689 if (pid == 0) { /* Child process running the command. */
690 signal (SIGALRM, SIG_DFL);
691 signal (SIGPIPE, SIG_DFL);
693 if (flag_copy_stdin) {
694 dup2 (stdin_fd[0], 0);
698 /* Set stdin to /dev/null (ignore failure) */
699 ignore_value (open ("/dev/null", O_RDONLY));
703 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
711 execvp (argv[0], (void *) argv);
713 _exit (EXIT_FAILURE);
716 if (flag_copy_stdin) {
717 int fd = flags & COMMAND_FLAG_FD_MASK;
720 if (stdin_pid == -1) {
721 error (0, errno, "fork");
725 if (stdin_pid == 0) { /* Child process copying stdin. */
732 dup2 (stdin_fd[1], 1);
736 if (chroot (sysroot) == -1) {
738 _exit (EXIT_FAILURE);
743 while ((n = read (fd, buffer, sizeof buffer)) > 0) {
744 if (xwrite (1, buffer, n) == -1)
745 /* EPIPE error indicates the command process has exited
746 * early. If the command process fails that will be caught
747 * by the daemon, and if not, then it's not an error.
749 _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
754 _exit (EXIT_FAILURE);
757 if (close (fd) == -1) {
759 _exit (EXIT_FAILURE);
762 _exit (EXIT_SUCCESS);
770 /* Parent process. */
775 FD_SET (so_fd[0], &rset);
776 FD_SET (se_fd[0], &rset);
782 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
795 /* Need to return non-NULL *stderror here since most callers
796 * will try to print and then free the err string.
797 * Unfortunately recovery from strdup failure here is not
800 *stderror = strdup ("error running external command, "
801 "see debug output for details");
805 waitpid (pid, NULL, 0);
806 if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
810 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
811 r = read (so_fd[0], buf, sizeof buf);
816 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
818 if (r > 0 && stdoutput) {
820 p = realloc (*stdoutput, so_size);
826 memcpy (*stdoutput + so_size - r, buf, r);
830 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
831 r = read (se_fd[0], buf, sizeof buf);
836 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
840 ignore_value (write (2, buf, r));
844 p = realloc (*stderror, se_size);
850 memcpy (*stderror + se_size - r, buf, r);
859 /* Make sure the output buffers are \0-terminated. Also remove any
860 * trailing \n characters from the error buffer (not from stdout).
863 void *q = realloc (*stdoutput, so_size+1);
870 (*stdoutput)[so_size] = '\0';
873 void *q = realloc (*stderror, se_size+1);
880 (*stderror)[se_size] = '\0';
882 while (se_size >= 0 && (*stderror)[se_size] == '\n')
883 (*stderror)[se_size--] = '\0';
887 if (flag_copy_stdin) {
888 /* Check copy process didn't fail. */
889 if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
892 waitpid (pid, NULL, 0);
896 if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
897 fprintf (stderr, "failed copying from input file, see earlier messages\n");
899 waitpid (pid, NULL, 0);
904 /* Get the exit status of the command. */
905 if (waitpid (pid, &r, 0) != pid) {
911 return WEXITSTATUS (r);
916 /* Split an output string into a NULL-terminated list of lines.
917 * Typically this is used where we have run an external command
918 * which has printed out a list of things, and we want to return
921 * The corner cases here are quite tricky. Note in particular:
925 * "a\nb" -> ["a"; "b"]
926 * "a\nb\n" -> ["a"; "b"]
927 * "a\nb\n\n" -> ["a"; "b"; ""]
929 * The original string is written over and destroyed by this
930 * function (which is usually OK because it's the 'out' string
931 * from command()). You can free the original string, because
932 * add_string() strdups the strings.
935 split_lines (char *str)
938 int size = 0, alloc = 0;
946 /* Empty last line? */
950 pend = strchr (p, '\n');
956 if (add_string (&lines, &size, &alloc, p) == -1) {
964 if (add_string (&lines, &size, &alloc, NULL) == -1)
970 /* Skip leading and trailing whitespace, updating the original string
976 size_t len = strlen (str);
978 while (len > 0 && c_isspace (str[len-1])) {
984 while (*p && c_isspace (*p)) {
989 memmove (str, p, len+1);
992 /* printf helper function so we can use %Q ("quoted") and %R to print
993 * shell-quoted strings. See guestfs(3)/EXTENDING LIBGUESTFS for more
997 print_shell_quote (FILE *stream,
998 const struct printf_info *info ATTRIBUTE_UNUSED,
999 const void *const *args)
1001 #define SAFE(c) (c_isalnum((c)) || \
1002 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
1004 const char *str = *((const char **) (args[0]));
1006 for (i = len = 0; str[i]; ++i) {
1007 if (!SAFE(str[i])) {
1008 putc ('\\', stream);
1011 putc (str[i], stream);
1019 print_sysroot_shell_quote (FILE *stream,
1020 const struct printf_info *info,
1021 const void *const *args)
1023 fputs (sysroot, stream);
1024 return sysroot_len + print_shell_quote (stream, info, args);
1027 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1029 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1030 size_t n, int *argtypes, int *size)
1033 argtypes[0] = PA_STRING;
1034 size[0] = sizeof (const char *);
1039 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1041 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1044 argtypes[0] = PA_STRING;
1048 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1052 /* Perform device name translation. Don't call this directly -
1053 * use the RESOLVE_DEVICE macro.
1055 * See guestfs(3) for the algorithm.
1057 * We have to open the device and test for ENXIO, because
1058 * the device nodes themselves will exist in the appliance.
1061 device_name_translation (char *device)
1065 fd = open (device, O_RDONLY);
1072 if (errno != ENXIO && errno != ENOENT)
1075 /* If the name begins with "/dev/sd" then try the alternatives. */
1076 if (STRNEQLEN (device, "/dev/sd", 7))
1079 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1080 fd = open (device, O_RDONLY);
1084 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1085 fd = open (device, O_RDONLY);
1089 device[5] = 's'; /* Restore original device name. */
1093 /* Check program exists and is executable on $PATH. Actually, we
1094 * just assume PATH contains the default entries (see main() above).
1097 prog_exists (const char *prog)
1099 static const char * const dirs[] =
1100 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1104 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1105 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1106 if (access (buf, X_OK) == 0)
1112 /* LVM and other commands aren't synchronous, especially when udev is
1113 * involved. eg. You can create or remove some device, but the /dev
1114 * device node won't appear until some time later. This means that
1115 * you get an error if you run one command followed by another.
1117 * Use 'udevadm settle' after certain commands, but don't be too
1118 * fussed if it fails.
1120 * 'udevsettle' was the old name for this command (RHEL 5). This was
1121 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1122 * command was left as a symlink. Then in Fedora 13 the old symlink
1123 * remained but it stopped working (RHBZ#548121), so we have to be
1124 * careful not to assume that we can use 'udevsettle' if it exists.
1129 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1130 (void) command (NULL, NULL, "udevsettle", NULL);