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 /* Not the end of the world if this open flag is not defined. */
68 /* If root device is an ext2 filesystem, this is the major and minor.
69 * This is so we can ignore this device from the point of view of the
70 * user, eg. in guestfs_list_devices and many other places.
72 static dev_t root_device = 0;
76 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
77 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
78 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
79 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
81 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
82 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
84 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
90 daemon (int nochdir, int noclose)
93 "On Windows the daemon does not support forking into the "
94 "background.\nYou *must* run the daemon with the -f option.\n");
105 /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
106 r = gl_sockets_startup (SOCKETS_2_2);
107 return r == 0 ? 0 : -1;
117 /* Location to mount root device. */
118 const char *sysroot = "/sysroot"; /* No trailing slash. */
121 /* Not used explicitly, but required by the gnulib 'error' module. */
122 const char *program_name = "guestfsd";
128 "guestfsd [-f|--foreground] [-v|--verbose]\n");
132 main (int argc, char *argv[])
134 static const char *options = "fv?";
135 static const struct option long_options[] = {
136 { "foreground", 0, 0, 'f' },
137 { "help", 0, 0, '?' },
138 { "verbose", 0, 0, 'v' },
145 if (winsock_init () == -1)
146 error (EXIT_FAILURE, 0, "winsock initialization failed");
148 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
149 /* http://udrepper.livejournal.com/20948.html */
150 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
151 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
153 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
154 register_printf_function ('Q', print_shell_quote, print_arginfo);
155 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
157 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
162 if (stat ("/", &statbuf) == 0)
163 root_device = statbuf.st_dev;
166 c = getopt_long (argc, argv, options, long_options, NULL);
183 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
193 cmdline = read_cmdline ();
195 /* Set the verbose flag. */
197 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
199 printf ("verbose daemon enabled\n");
203 printf ("linux commmand line: %s\n", cmdline);
205 printf ("could not read linux command line\n");
209 /* Make sure SIGPIPE doesn't kill us. */
211 memset (&sa, 0, sizeof sa);
212 sa.sa_handler = SIG_IGN;
214 if (sigaction (SIGPIPE, &sa, NULL) == -1)
215 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
219 # define setenv(n,v,f) _putenv(n "=" v)
221 /* Set up a basic environment. After we are called by /init the
222 * environment is essentially empty.
223 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
225 * NOTE: if you change $PATH, you must also change 'prog_exists'
228 setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
229 setenv ("SHELL", "/bin/sh", 1);
230 setenv ("LC_ALL", "C", 1);
231 setenv ("TERM", "dumb", 1);
234 /* We document that umask defaults to 022 (it should be this anyway). */
237 /* This is the default for Windows anyway. It's not even clear if
238 * Windows ever uses this -- the MSDN documentation for the function
239 * contains obvious errors.
244 /* Connect to virtio-serial channel. */
245 int sock = open ("/dev/virtio-ports/org.libguestfs.channel.0",
250 "Failed to connect to virtio-serial channel.\n"
252 "This is a fatal error and the appliance will now exit.\n"
254 "Usually this error is caused by either QEMU or the appliance\n"
255 "kernel not supporting the vmchannel method that the\n"
256 "libguestfs library chose to use. Please run\n"
257 "'libguestfs-test-tool' and provide the complete, unedited\n"
258 "output to the libguestfs developers, either in a bug report\n"
259 "or on the libguestfs redhat com mailing list.\n"
261 perror ("/dev/virtio-ports/org.libguestfs.channel.0");
265 /* Send the magic length message which indicates that
266 * userspace is up inside the guest.
270 uint32_t len = GUESTFS_LAUNCH_FLAG;
271 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
272 xdr_u_int (&xdr, &len);
274 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1) {
281 /* Fork into the background. */
283 if (daemon (0, 1) == -1) {
289 /* Enter the main loop, reading and performing actions. */
295 /* Read /proc/cmdline. */
299 int fd = open ("/proc/cmdline", O_RDONLY);
301 perror ("/proc/cmdline");
311 n = read (fd, buf, sizeof buf);
320 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
328 memcpy (&r[len], buf, n);
335 if (close (fd) == -1) {
344 /* Return true iff device is the root device (and therefore should be
345 * ignored from the point of view of user calls).
348 is_root_device (const char *device)
351 if (stat (device, &statbuf) == -1) {
355 if (statbuf.st_rdev == root_device)
360 /* Turn "/path" into "/sysroot/path".
362 * Caller must check for NULL and call reply_with_perror ("malloc")
363 * if it is. Caller must also free the string.
365 * See also the custom %R printf formatter which does shell quoting too.
368 sysroot_path (const char *path)
371 int len = strlen (path) + sysroot_len + 1;
377 snprintf (r, len, "%s%s", sysroot, path);
382 xwrite (int sock, const void *v_buf, size_t len)
385 const char *buf = v_buf;
388 r = write (sock, buf, len);
401 xread (int sock, void *v_buf, size_t len)
407 r = read (sock, buf, len);
413 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
424 add_string (char ***argv, int *size, int *alloc, const char *str)
429 if (*size >= *alloc) {
431 new_argv = realloc (*argv, *alloc * sizeof (char *));
432 if (new_argv == NULL) {
433 reply_with_perror ("realloc");
434 free_strings (*argv);
441 new_str = strdup (str);
442 if (new_str == NULL) {
443 reply_with_perror ("strdup");
444 free_strings (*argv);
449 (*argv)[*size] = new_str;
456 count_strings (char *const *argv)
460 for (argc = 0; argv[argc] != NULL; ++argc)
465 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
467 is_power_of_2 (unsigned long v)
469 return v && ((v & (v - 1)) == 0);
473 compare (const void *vp1, const void *vp2)
475 char * const *p1 = (char * const *) vp1;
476 char * const *p2 = (char * const *) vp2;
477 return strcmp (*p1, *p2);
481 sort_strings (char **argv, int len)
483 qsort (argv, len, sizeof (char *), compare);
487 free_strings (char **argv)
491 for (argc = 0; argv[argc] != NULL; ++argc)
497 free_stringslen (char **argv, int len)
501 for (i = 0; i < len; ++i)
506 /* Easy ways to run external commands. For full documentation, see
507 * 'commandrvf' below.
510 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
517 /* Collect the command line arguments into an array. */
519 argv = malloc (sizeof (char *) * i);
524 argv[0] = (char *) name;
527 va_start (args, name);
529 while ((s = va_arg (args, char *)) != NULL) {
530 const char **p = realloc (argv, sizeof (char *) * (++i));
544 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
546 /* NB: Mustn't free the strings which are on the stack. */
552 /* Same as 'command', but we allow the status code from the
553 * subcommand to be non-zero, and return that status code.
554 * We still return -1 if there was some other error.
557 commandrf (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 = commandrvf (stdoutput, stderror, flags, argv);
593 /* NB: Mustn't free the strings which are on the stack. */
599 /* Same as 'command', but passing an argv. */
601 commandvf (char **stdoutput, char **stderror, int flags,
602 char const *const *argv)
606 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
613 /* This is a more sane version of 'system(3)' for running external
614 * commands. It uses fork/execvp, so we don't need to worry about
615 * quoting of parameters, and it allows us to capture any error
616 * messages in a buffer.
618 * If stdoutput is not NULL, then *stdoutput will return the stdout
621 * If stderror is not NULL, then *stderror will return the stderr
622 * of the command. If there is a final \n character, it is removed
623 * so you can use the error string directly in a call to
628 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
629 * that send error messages to stdout (hello, parted) but that don't
630 * have any useful stdout information, use this flag to capture the
631 * error messages in the *stderror buffer. If using this flag,
632 * you should pass stdoutput as NULL because nothing could ever be
633 * captured in that buffer.
635 * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
636 * commands on chrooted files correctly (see RHBZ#579608) specifying
637 * this flag causes another process to be forked which chroots into
638 * sysroot and just copies the input file to stdin of the specified
639 * command. The file descriptor is ORed with the flags, and that file
640 * descriptor is always closed by this function. See hexdump.c for an
644 commandrvf (char **stdoutput, char **stderror, int flags,
645 char const* const *argv)
647 int so_size = 0, se_size = 0;
648 int so_fd[2], se_fd[2];
649 int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
650 int stdin_fd[2] = { -1, -1 };
651 pid_t pid, stdin_pid = -1;
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 /* Note: abort is used in a few places along the error paths early
668 * in this function. This is because (a) cleaning up correctly is
669 * very complex at these places and (b) abort is used when a
670 * resource problems is indicated which would be due to much more
671 * serious issues - eg. memory or file descriptor leaks. We
672 * wouldn't expect fork(2) or pipe(2) to fail in normal
676 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
677 error (0, errno, "pipe");
681 if (flag_copy_stdin) {
682 if (pipe (stdin_fd) == -1) {
683 error (0, errno, "pipe");
690 error (0, errno, "fork");
694 if (pid == 0) { /* Child process running the command. */
696 if (flag_copy_stdin) {
697 dup2 (stdin_fd[0], 0);
701 /* Set stdin to /dev/null (ignore failure) */
702 open ("/dev/null", O_RDONLY);
706 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
714 execvp (argv[0], (void *) argv);
716 _exit (EXIT_FAILURE);
719 if (flag_copy_stdin) {
720 int fd = flags & COMMAND_FLAG_FD_MASK;
723 if (stdin_pid == -1) {
724 error (0, errno, "fork");
728 if (stdin_pid == 0) { /* Child process copying stdin. */
735 dup2 (stdin_fd[1], 1);
739 if (chroot (sysroot) == -1) {
741 _exit (EXIT_FAILURE);
746 while ((n = read (fd, buffer, sizeof buffer)) > 0) {
747 if (xwrite (1, buffer, n) == -1)
748 /* EPIPE error indicates the command process has exited
749 * early. If the command process fails that will be caught
750 * by the daemon, and if not, then it's not an error.
752 _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
757 _exit (EXIT_FAILURE);
760 if (close (fd) == -1) {
762 _exit (EXIT_FAILURE);
765 _exit (EXIT_SUCCESS);
773 /* Parent process. */
778 FD_SET (so_fd[0], &rset);
779 FD_SET (se_fd[0], &rset);
784 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
788 if (stdoutput) free (*stdoutput);
789 if (stderror) free (*stderror);
792 waitpid (pid, NULL, 0);
793 if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
797 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
798 r = read (so_fd[0], buf, sizeof buf);
803 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
805 if (r > 0 && stdoutput) {
807 p = realloc (*stdoutput, so_size);
813 memcpy (*stdoutput + so_size - r, buf, r);
817 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
818 r = read (se_fd[0], buf, sizeof buf);
823 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
827 ignore_value (write (2, buf, r));
831 p = realloc (*stderror, se_size);
837 memcpy (*stderror + se_size - r, buf, r);
846 /* Make sure the output buffers are \0-terminated. Also remove any
847 * trailing \n characters from the error buffer (not from stdout).
850 void *q = realloc (*stdoutput, so_size+1);
857 (*stdoutput)[so_size] = '\0';
860 void *q = realloc (*stderror, se_size+1);
867 (*stderror)[se_size] = '\0';
869 while (se_size >= 0 && (*stderror)[se_size] == '\n')
870 (*stderror)[se_size--] = '\0';
874 if (flag_copy_stdin) {
875 /* Check copy process didn't fail. */
876 if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
879 waitpid (pid, NULL, 0);
883 if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
884 fprintf (stderr, "failed copying from input file, see earlier messages\n");
886 waitpid (pid, NULL, 0);
891 /* Get the exit status of the command. */
892 if (waitpid (pid, &r, 0) != pid) {
898 return WEXITSTATUS (r);
903 /* Split an output string into a NULL-terminated list of lines.
904 * Typically this is used where we have run an external command
905 * which has printed out a list of things, and we want to return
908 * The corner cases here are quite tricky. Note in particular:
912 * "a\nb" -> ["a"; "b"]
913 * "a\nb\n" -> ["a"; "b"]
914 * "a\nb\n\n" -> ["a"; "b"; ""]
916 * The original string is written over and destroyed by this
917 * function (which is usually OK because it's the 'out' string
918 * from command()). You can free the original string, because
919 * add_string() strdups the strings.
922 split_lines (char *str)
925 int size = 0, alloc = 0;
933 /* Empty last line? */
937 pend = strchr (p, '\n');
943 if (add_string (&lines, &size, &alloc, p) == -1) {
951 if (add_string (&lines, &size, &alloc, NULL) == -1)
957 /* Skip leading and trailing whitespace, updating the original string
963 size_t len = strlen (str);
965 while (len > 0 && c_isspace (str[len-1])) {
971 while (*p && c_isspace (*p)) {
976 memmove (str, p, len+1);
979 /* printf helper function so we can use %Q ("quoted") and %R to print
980 * shell-quoted strings. See guestfs(3)/EXTENDING LIBGUESTFS for more
984 print_shell_quote (FILE *stream,
985 const struct printf_info *info ATTRIBUTE_UNUSED,
986 const void *const *args)
988 #define SAFE(c) (c_isalnum((c)) || \
989 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
991 const char *str = *((const char **) (args[0]));
993 for (i = len = 0; str[i]; ++i) {
998 putc (str[i], stream);
1006 print_sysroot_shell_quote (FILE *stream,
1007 const struct printf_info *info,
1008 const void *const *args)
1010 fputs (sysroot, stream);
1011 return sysroot_len + print_shell_quote (stream, info, args);
1014 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1016 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1017 size_t n, int *argtypes, int *size)
1020 argtypes[0] = PA_STRING;
1021 size[0] = sizeof (const char *);
1026 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1028 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1031 argtypes[0] = PA_STRING;
1035 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1039 /* Perform device name translation. Don't call this directly -
1040 * use the RESOLVE_DEVICE macro.
1042 * See guestfs(3) for the algorithm.
1044 * We have to open the device and test for ENXIO, because
1045 * the device nodes themselves will exist in the appliance.
1048 device_name_translation (char *device)
1052 fd = open (device, O_RDONLY);
1059 if (errno != ENXIO && errno != ENOENT)
1062 /* If the name begins with "/dev/sd" then try the alternatives. */
1063 if (STRNEQLEN (device, "/dev/sd", 7))
1066 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1067 fd = open (device, O_RDONLY);
1071 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1072 fd = open (device, O_RDONLY);
1076 device[5] = 's'; /* Restore original device name. */
1080 /* Check program exists and is executable on $PATH. Actually, we
1081 * just assume PATH contains the default entries (see main() above).
1084 prog_exists (const char *prog)
1086 static const char * const dirs[] =
1087 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1091 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1092 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1093 if (access (buf, X_OK) == 0)
1099 /* LVM and other commands aren't synchronous, especially when udev is
1100 * involved. eg. You can create or remove some device, but the /dev
1101 * device node won't appear until some time later. This means that
1102 * you get an error if you run one command followed by another.
1104 * Use 'udevadm settle' after certain commands, but don't be too
1105 * fussed if it fails.
1107 * 'udevsettle' was the old name for this command (RHEL 5). This was
1108 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1109 * command was left as a symlink. Then in Fedora 13 the old symlink
1110 * remained but it stopped working (RHBZ#548121), so we have to be
1111 * careful not to assume that we can use 'udevsettle' if it exists.
1116 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1117 (void) command (NULL, NULL, "udevsettle", NULL);