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., 675 Mass Ave, Cambridge, MA 02139, 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. */
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";
118 "guestfsd [-r] [-v|--verbose]\n");
122 main (int argc, char *argv[])
124 static const char *options = "rv?";
125 static const struct option long_options[] = {
126 { "help", 0, 0, '?' },
127 { "verbose", 0, 0, 'v' },
133 ignore_value (chdir ("/"));
135 if (winsock_init () == -1)
136 error (EXIT_FAILURE, 0, "winsock initialization failed");
138 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
139 /* http://udrepper.livejournal.com/20948.html */
140 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
141 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
143 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
144 register_printf_function ('Q', print_shell_quote, print_arginfo);
145 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
147 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
152 if (stat ("/", &statbuf) == 0)
153 root_device = statbuf.st_dev;
156 c = getopt_long (argc, argv, options, long_options, NULL);
160 /* The -r flag is used when running standalone. It changes
161 * several aspects of the daemon.
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",
245 "Failed to connect to virtio-serial channel.\n"
247 "This is a fatal error and the appliance will now exit.\n"
249 "Usually this error is caused by either QEMU or the appliance\n"
250 "kernel not supporting the vmchannel method that the\n"
251 "libguestfs library chose to use. Please run\n"
252 "'libguestfs-test-tool' and provide the complete, unedited\n"
253 "output to the libguestfs developers, either in a bug report\n"
254 "or on the libguestfs redhat com mailing list.\n"
256 perror ("/dev/virtio-ports/org.libguestfs.channel.0");
260 /* Send the magic length message which indicates that
261 * userspace is up inside the guest.
265 uint32_t len = GUESTFS_LAUNCH_FLAG;
266 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
267 xdr_u_int (&xdr, &len);
269 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1) {
276 /* Enter the main loop, reading and performing actions. */
282 /* Read /proc/cmdline. */
286 int fd = open ("/proc/cmdline", O_RDONLY);
288 perror ("/proc/cmdline");
298 n = read (fd, buf, sizeof buf);
307 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
315 memcpy (&r[len], buf, n);
322 if (close (fd) == -1) {
331 /* Return true iff device is the root device (and therefore should be
332 * ignored from the point of view of user calls).
335 is_root_device (const char *device)
338 if (stat (device, &statbuf) == -1) {
342 if (statbuf.st_rdev == root_device)
347 /* Turn "/path" into "/sysroot/path".
349 * Caller must check for NULL and call reply_with_perror ("malloc")
350 * if it is. Caller must also free the string.
352 * See also the custom %R printf formatter which does shell quoting too.
355 sysroot_path (const char *path)
358 int len = strlen (path) + sysroot_len + 1;
364 snprintf (r, len, "%s%s", sysroot, path);
369 xwrite (int sock, const void *v_buf, size_t len)
372 const char *buf = v_buf;
375 r = write (sock, buf, len);
388 xread (int sock, void *v_buf, size_t len)
394 r = read (sock, buf, len);
400 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
411 add_string (char ***argv, int *size, int *alloc, const char *str)
416 if (*size >= *alloc) {
418 new_argv = realloc (*argv, *alloc * sizeof (char *));
419 if (new_argv == NULL) {
420 reply_with_perror ("realloc");
421 free_strings (*argv);
428 new_str = strdup (str);
429 if (new_str == NULL) {
430 reply_with_perror ("strdup");
431 free_strings (*argv);
436 (*argv)[*size] = new_str;
443 count_strings (char *const *argv)
447 for (argc = 0; argv[argc] != NULL; ++argc)
452 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
454 is_power_of_2 (unsigned long v)
456 return v && ((v & (v - 1)) == 0);
460 compare (const void *vp1, const void *vp2)
462 char * const *p1 = (char * const *) vp1;
463 char * const *p2 = (char * const *) vp2;
464 return strcmp (*p1, *p2);
468 sort_strings (char **argv, int len)
470 qsort (argv, len, sizeof (char *), compare);
474 free_strings (char **argv)
478 for (argc = 0; argv[argc] != NULL; ++argc)
484 free_stringslen (char **argv, int len)
488 for (i = 0; i < len; ++i)
493 /* Easy ways to run external commands. For full documentation, see
494 * 'commandrvf' below.
497 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
504 /* Collect the command line arguments into an array. */
506 argv = malloc (sizeof (char *) * i);
511 argv[0] = (char *) name;
514 va_start (args, name);
516 while ((s = va_arg (args, char *)) != NULL) {
517 const char **p = realloc (argv, sizeof (char *) * (++i));
531 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
533 /* NB: Mustn't free the strings which are on the stack. */
539 /* Same as 'command', but we allow the status code from the
540 * subcommand to be non-zero, and return that status code.
541 * We still return -1 if there was some other error.
544 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
551 /* Collect the command line arguments into an array. */
553 argv = malloc (sizeof (char *) * i);
558 argv[0] = (char *) name;
561 va_start (args, name);
563 while ((s = va_arg (args, char *)) != NULL) {
564 const char **p = realloc (argv, sizeof (char *) * (++i));
578 r = commandrvf (stdoutput, stderror, flags, argv);
580 /* NB: Mustn't free the strings which are on the stack. */
586 /* Same as 'command', but passing an argv. */
588 commandvf (char **stdoutput, char **stderror, int flags,
589 char const *const *argv)
593 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
600 /* This is a more sane version of 'system(3)' for running external
601 * commands. It uses fork/execvp, so we don't need to worry about
602 * quoting of parameters, and it allows us to capture any error
603 * messages in a buffer.
605 * If stdoutput is not NULL, then *stdoutput will return the stdout
608 * If stderror is not NULL, then *stderror will return the stderr
609 * of the command. If there is a final \n character, it is removed
610 * so you can use the error string directly in a call to
615 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
616 * that send error messages to stdout (hello, parted) but that don't
617 * have any useful stdout information, use this flag to capture the
618 * error messages in the *stderror buffer. If using this flag,
619 * you should pass stdoutput as NULL because nothing could ever be
620 * captured in that buffer.
622 * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
623 * commands on chrooted files correctly (see RHBZ#579608) specifying
624 * this flag causes another process to be forked which chroots into
625 * sysroot and just copies the input file to stdin of the specified
626 * command. The file descriptor is ORed with the flags, and that file
627 * descriptor is always closed by this function. See hexdump.c for an
631 commandrvf (char **stdoutput, char **stderror, int flags,
632 char const* const *argv)
634 int so_size = 0, se_size = 0;
635 int so_fd[2], se_fd[2];
636 int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
637 int stdin_fd[2] = { -1, -1 };
638 pid_t pid, stdin_pid = -1;
644 if (stdoutput) *stdoutput = NULL;
645 if (stderror) *stderror = NULL;
648 printf ("%s", argv[0]);
649 for (i = 1; argv[i] != NULL; ++i)
650 printf (" %s", argv[i]);
654 /* Note: abort is used in a few places along the error paths early
655 * in this function. This is because (a) cleaning up correctly is
656 * very complex at these places and (b) abort is used when a
657 * resource problems is indicated which would be due to much more
658 * serious issues - eg. memory or file descriptor leaks. We
659 * wouldn't expect fork(2) or pipe(2) to fail in normal
663 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
664 error (0, errno, "pipe");
668 if (flag_copy_stdin) {
669 if (pipe (stdin_fd) == -1) {
670 error (0, errno, "pipe");
677 error (0, errno, "fork");
681 if (pid == 0) { /* Child process running the command. */
682 signal (SIGPIPE, SIG_DFL);
684 if (flag_copy_stdin) {
685 dup2 (stdin_fd[0], 0);
689 /* Set stdin to /dev/null (ignore failure) */
690 open ("/dev/null", O_RDONLY);
694 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
702 execvp (argv[0], (void *) argv);
704 _exit (EXIT_FAILURE);
707 if (flag_copy_stdin) {
708 int fd = flags & COMMAND_FLAG_FD_MASK;
711 if (stdin_pid == -1) {
712 error (0, errno, "fork");
716 if (stdin_pid == 0) { /* Child process copying stdin. */
723 dup2 (stdin_fd[1], 1);
727 if (chroot (sysroot) == -1) {
729 _exit (EXIT_FAILURE);
734 while ((n = read (fd, buffer, sizeof buffer)) > 0) {
735 if (xwrite (1, buffer, n) == -1)
736 /* EPIPE error indicates the command process has exited
737 * early. If the command process fails that will be caught
738 * by the daemon, and if not, then it's not an error.
740 _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
745 _exit (EXIT_FAILURE);
748 if (close (fd) == -1) {
750 _exit (EXIT_FAILURE);
753 _exit (EXIT_SUCCESS);
761 /* Parent process. */
766 FD_SET (so_fd[0], &rset);
767 FD_SET (se_fd[0], &rset);
773 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
780 if (stdoutput) free (*stdoutput);
781 if (stderror) free (*stderror);
784 waitpid (pid, NULL, 0);
785 if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
789 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
790 r = read (so_fd[0], buf, sizeof buf);
795 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
797 if (r > 0 && stdoutput) {
799 p = realloc (*stdoutput, so_size);
805 memcpy (*stdoutput + so_size - r, buf, r);
809 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
810 r = read (se_fd[0], buf, sizeof buf);
815 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
819 ignore_value (write (2, buf, r));
823 p = realloc (*stderror, se_size);
829 memcpy (*stderror + se_size - r, buf, r);
838 /* Make sure the output buffers are \0-terminated. Also remove any
839 * trailing \n characters from the error buffer (not from stdout).
842 void *q = realloc (*stdoutput, so_size+1);
849 (*stdoutput)[so_size] = '\0';
852 void *q = realloc (*stderror, se_size+1);
859 (*stderror)[se_size] = '\0';
861 while (se_size >= 0 && (*stderror)[se_size] == '\n')
862 (*stderror)[se_size--] = '\0';
866 if (flag_copy_stdin) {
867 /* Check copy process didn't fail. */
868 if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
871 waitpid (pid, NULL, 0);
875 if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
876 fprintf (stderr, "failed copying from input file, see earlier messages\n");
878 waitpid (pid, NULL, 0);
883 /* Get the exit status of the command. */
884 if (waitpid (pid, &r, 0) != pid) {
890 return WEXITSTATUS (r);
895 /* Split an output string into a NULL-terminated list of lines.
896 * Typically this is used where we have run an external command
897 * which has printed out a list of things, and we want to return
900 * The corner cases here are quite tricky. Note in particular:
904 * "a\nb" -> ["a"; "b"]
905 * "a\nb\n" -> ["a"; "b"]
906 * "a\nb\n\n" -> ["a"; "b"; ""]
908 * The original string is written over and destroyed by this
909 * function (which is usually OK because it's the 'out' string
910 * from command()). You can free the original string, because
911 * add_string() strdups the strings.
914 split_lines (char *str)
917 int size = 0, alloc = 0;
925 /* Empty last line? */
929 pend = strchr (p, '\n');
935 if (add_string (&lines, &size, &alloc, p) == -1) {
943 if (add_string (&lines, &size, &alloc, NULL) == -1)
949 /* Skip leading and trailing whitespace, updating the original string
955 size_t len = strlen (str);
957 while (len > 0 && c_isspace (str[len-1])) {
963 while (*p && c_isspace (*p)) {
968 memmove (str, p, len+1);
971 /* printf helper function so we can use %Q ("quoted") and %R to print
972 * shell-quoted strings. See guestfs(3)/EXTENDING LIBGUESTFS for more
976 print_shell_quote (FILE *stream,
977 const struct printf_info *info ATTRIBUTE_UNUSED,
978 const void *const *args)
980 #define SAFE(c) (c_isalnum((c)) || \
981 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
983 const char *str = *((const char **) (args[0]));
985 for (i = len = 0; str[i]; ++i) {
990 putc (str[i], stream);
998 print_sysroot_shell_quote (FILE *stream,
999 const struct printf_info *info,
1000 const void *const *args)
1002 fputs (sysroot, stream);
1003 return sysroot_len + print_shell_quote (stream, info, args);
1006 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1008 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1009 size_t n, int *argtypes, int *size)
1012 argtypes[0] = PA_STRING;
1013 size[0] = sizeof (const char *);
1018 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1020 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1023 argtypes[0] = PA_STRING;
1027 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1031 /* Perform device name translation. Don't call this directly -
1032 * use the RESOLVE_DEVICE macro.
1034 * See guestfs(3) for the algorithm.
1036 * We have to open the device and test for ENXIO, because
1037 * the device nodes themselves will exist in the appliance.
1040 device_name_translation (char *device)
1044 fd = open (device, O_RDONLY);
1051 if (errno != ENXIO && errno != ENOENT)
1054 /* If the name begins with "/dev/sd" then try the alternatives. */
1055 if (STRNEQLEN (device, "/dev/sd", 7))
1058 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1059 fd = open (device, O_RDONLY);
1063 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1064 fd = open (device, O_RDONLY);
1068 device[5] = 's'; /* Restore original device name. */
1072 /* Check program exists and is executable on $PATH. Actually, we
1073 * just assume PATH contains the default entries (see main() above).
1076 prog_exists (const char *prog)
1078 static const char * const dirs[] =
1079 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1083 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1084 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1085 if (access (buf, X_OK) == 0)
1091 /* LVM and other commands aren't synchronous, especially when udev is
1092 * involved. eg. You can create or remove some device, but the /dev
1093 * device node won't appear until some time later. This means that
1094 * you get an error if you run one command followed by another.
1096 * Use 'udevadm settle' after certain commands, but don't be too
1097 * fussed if it fails.
1099 * 'udevsettle' was the old name for this command (RHEL 5). This was
1100 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1101 * command was left as a symlink. Then in Fedora 13 the old symlink
1102 * remained but it stopped working (RHBZ#548121), so we have to be
1103 * careful not to assume that we can use 'udevsettle' if it exists.
1108 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1109 (void) command (NULL, NULL, "udevsettle", NULL);