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>
51 #include "ignore-value.h"
56 static char *read_cmdline (void);
58 /* This is the default address we connect to for very old libraries
59 * which didn't specify the address and port number explicitly on the
60 * kernel command line. It's now recommended to always specify the
61 * address and port number on the command line, so this will not be
64 #define OLD_GUESTFWD_ADDR "10.0.2.4"
65 #define OLD_GUESTFWD_PORT "6666"
67 /* This is only a hint. If not defined, ignore it. */
69 # define AI_ADDRCONFIG 0
73 # define MAX(a,b) ((a)>(b)?(a):(b))
78 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
79 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
80 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
81 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
83 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
84 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
86 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
92 daemon (int nochdir, int noclose)
95 "On Windows the daemon does not support forking into the "
96 "background.\nYou *must* run the daemon with the -f option.\n");
107 /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
108 r = gl_sockets_startup (SOCKETS_2_2);
109 return r == 0 ? 0 : -1;
119 /* Location to mount root device. */
120 const char *sysroot = "/sysroot"; /* No trailing slash. */
123 /* Not used explicitly, but required by the gnulib 'error' module. */
124 const char *program_name = "guestfsd";
130 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
134 main (int argc, char *argv[])
136 static const char *options = "fc:v?";
137 static const struct option long_options[] = {
138 { "channel", required_argument, 0, 'c' },
139 { "foreground", 0, 0, 'f' },
140 { "help", 0, 0, '?' },
141 { "verbose", 0, 0, 'v' },
147 char *vmchannel = NULL;
149 if (winsock_init () == -1)
150 error (EXIT_FAILURE, 0, "winsock initialization failed");
152 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
153 /* http://udrepper.livejournal.com/20948.html */
154 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
155 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
157 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
158 register_printf_function ('Q', print_shell_quote, print_arginfo);
159 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
161 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
166 c = getopt_long (argc, argv, options, long_options, NULL);
187 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
197 cmdline = read_cmdline ();
199 /* Set the verbose flag. */
201 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
203 printf ("verbose daemon enabled\n");
207 printf ("linux commmand line: %s\n", cmdline);
209 printf ("could not read linux command line\n");
213 /* Make sure SIGPIPE doesn't kill us. */
215 memset (&sa, 0, sizeof sa);
216 sa.sa_handler = SIG_IGN;
218 if (sigaction (SIGPIPE, &sa, NULL) == -1)
219 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
223 # define setenv(n,v,f) _putenv(n "=" v)
225 /* Set up a basic environment. After we are called by /init the
226 * environment is essentially empty.
227 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
229 * NOTE: if you change $PATH, you must also change 'prog_exists'
232 setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
233 setenv ("SHELL", "/bin/sh", 1);
234 setenv ("LC_ALL", "C", 1);
235 setenv ("TERM", "dumb", 1);
238 /* We document that umask defaults to 022 (it should be this anyway). */
241 /* This is the default for Windows anyway. It's not even clear if
242 * Windows ever uses this -- the MSDN documentation for the function
243 * contains obvious errors.
248 /* Get the vmchannel string.
251 * --channel/-c option on the command line
252 * guestfs_vmchannel=... from the kernel command line
253 * guestfs=... from the kernel command line
256 * At the moment we expect this to contain "tcp:ip:port" but in
257 * future it might contain a device name, eg. "/dev/vcon4" for
258 * virtio-console vmchannel.
260 if (vmchannel == NULL && cmdline) {
264 p = strstr (cmdline, "guestfs_vmchannel=");
266 len = strcspn (p + 18, " \t\n");
267 vmchannel = strndup (p + 18, len);
274 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
275 if (vmchannel == NULL) {
276 /* We will rewrite it part of the "guestfs=" string with
277 * "tcp:" hence p + 4 below. */
278 p = strstr (cmdline, "guestfs=");
280 len = strcspn (p + 4, " \t\n");
281 vmchannel = strndup (p + 4, len);
286 memcpy (vmchannel, "tcp:", 4);
291 /* Default vmchannel. */
292 if (vmchannel == NULL) {
293 vmchannel = strdup ("tcp:" OLD_GUESTFWD_ADDR ":" OLD_GUESTFWD_PORT);
301 printf ("vmchannel: %s\n", vmchannel);
303 /* Connect to vmchannel. */
306 if (STREQLEN (vmchannel, "tcp:", 4)) {
307 /* Resolve the hostname. */
308 struct addrinfo *res, *rr;
309 struct addrinfo hints;
314 port = strchr (host, ':');
319 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
324 memset (&hints, 0, sizeof hints);
325 hints.ai_socktype = SOCK_STREAM;
326 hints.ai_flags = AI_ADDRCONFIG;
327 r = getaddrinfo (host, port, &hints, &res);
329 fprintf (stderr, "%s:%s: %s\n",
330 host, port, gai_strerror (r));
334 /* Connect to the given TCP socket. */
335 for (rr = res; rr != NULL; rr = rr->ai_next) {
336 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
338 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
349 "unknown vmchannel connection type: %s\n"
350 "expecting \"tcp:<ip>:<port>\"\n",
358 "Failed to connect to any vmchannel implementation.\n"
361 "This is a fatal error and the appliance will now exit.\n"
363 "Usually this error is caused by either QEMU or the appliance\n"
364 "kernel not supporting the vmchannel method that the\n"
365 "libguestfs library chose to use. Please run\n"
366 "'libguestfs-test-tool' and provide the complete, unedited\n"
367 "output to the libguestfs developers, either in a bug report\n"
368 "or on the libguestfs redhat com mailing list.\n"
374 /* Send the magic length message which indicates that
375 * userspace is up inside the guest.
379 uint32_t len = GUESTFS_LAUNCH_FLAG;
380 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
381 xdr_u_int (&xdr, &len);
383 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
388 /* Fork into the background. */
390 if (daemon (0, 1) == -1) {
396 /* Enter the main loop, reading and performing actions. */
402 /* Read /proc/cmdline. */
406 int fd = open ("/proc/cmdline", O_RDONLY);
408 perror ("/proc/cmdline");
418 n = read (fd, buf, sizeof buf);
427 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
435 memcpy (&r[len], buf, n);
442 if (close (fd) == -1) {
451 /* Turn "/path" into "/sysroot/path".
453 * Caller must check for NULL and call reply_with_perror ("malloc")
454 * if it is. Caller must also free the string.
456 * See also the custom %R printf formatter which does shell quoting too.
459 sysroot_path (const char *path)
462 int len = strlen (path) + sysroot_len + 1;
468 snprintf (r, len, "%s%s", sysroot, path);
473 xwrite (int sock, const void *v_buf, size_t len)
476 const char *buf = v_buf;
479 r = write (sock, buf, len);
492 xread (int sock, void *v_buf, size_t len)
498 r = read (sock, buf, len);
504 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
515 add_string (char ***argv, int *size, int *alloc, const char *str)
520 if (*size >= *alloc) {
522 new_argv = realloc (*argv, *alloc * sizeof (char *));
523 if (new_argv == NULL) {
524 reply_with_perror ("realloc");
525 free_strings (*argv);
532 new_str = strdup (str);
533 if (new_str == NULL) {
534 reply_with_perror ("strdup");
535 free_strings (*argv);
540 (*argv)[*size] = new_str;
547 count_strings (char *const *argv)
551 for (argc = 0; argv[argc] != NULL; ++argc)
557 compare (const void *vp1, const void *vp2)
559 char * const *p1 = (char * const *) vp1;
560 char * const *p2 = (char * const *) vp2;
561 return strcmp (*p1, *p2);
565 sort_strings (char **argv, int len)
567 qsort (argv, len, sizeof (char *), compare);
571 free_strings (char **argv)
575 for (argc = 0; argv[argc] != NULL; ++argc)
581 free_stringslen (char **argv, int len)
585 for (i = 0; i < len; ++i)
590 /* Easy ways to run external commands. For full documentation, see
591 * 'commandrvf' below.
594 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
601 /* Collect the command line arguments into an array. */
603 argv = malloc (sizeof (char *) * i);
608 argv[0] = (char *) name;
611 va_start (args, name);
613 while ((s = va_arg (args, char *)) != NULL) {
614 const char **p = realloc (argv, sizeof (char *) * (++i));
628 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
630 /* NB: Mustn't free the strings which are on the stack. */
636 /* Same as 'command', but we allow the status code from the
637 * subcommand to be non-zero, and return that status code.
638 * We still return -1 if there was some other error.
641 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
648 /* Collect the command line arguments into an array. */
650 argv = malloc (sizeof (char *) * i);
655 argv[0] = (char *) name;
658 va_start (args, name);
660 while ((s = va_arg (args, char *)) != NULL) {
661 const char **p = realloc (argv, sizeof (char *) * (++i));
675 r = commandrvf (stdoutput, stderror, flags, argv);
677 /* NB: Mustn't free the strings which are on the stack. */
683 /* Same as 'command', but passing an argv. */
685 commandvf (char **stdoutput, char **stderror, int flags,
686 char const *const *argv)
690 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
697 /* This is a more sane version of 'system(3)' for running external
698 * commands. It uses fork/execvp, so we don't need to worry about
699 * quoting of parameters, and it allows us to capture any error
700 * messages in a buffer.
702 * If stdoutput is not NULL, then *stdoutput will return the stdout
705 * If stderror is not NULL, then *stderror will return the stderr
706 * of the command. If there is a final \n character, it is removed
707 * so you can use the error string directly in a call to
712 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
713 * that send error messages to stdout (hello, parted) but that don't
714 * have any useful stdout information, use this flag to capture the
715 * error messages in the *stderror buffer. If using this flag,
716 * you should pass stdoutput as NULL because nothing could ever be
717 * captured in that buffer.
719 * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
720 * commands on chrooted files correctly (see RHBZ#579608) specifying
721 * this flag causes another process to be forked which chroots into
722 * sysroot and just copies the input file to stdin of the specified
723 * command. The file descriptor is ORed with the flags, and that file
724 * descriptor is always closed by this function. See hexdump.c for an
728 commandrvf (char **stdoutput, char **stderror, int flags,
729 char const* const *argv)
731 int so_size = 0, se_size = 0;
732 int so_fd[2], se_fd[2];
733 int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
734 int stdin_fd[2] = { -1, -1 };
735 pid_t pid, stdin_pid = -1;
741 if (stdoutput) *stdoutput = NULL;
742 if (stderror) *stderror = NULL;
745 printf ("%s", argv[0]);
746 for (i = 1; argv[i] != NULL; ++i)
747 printf (" %s", argv[i]);
751 /* Note: abort is used in a few places along the error paths early
752 * in this function. This is because (a) cleaning up correctly is
753 * very complex at these places and (b) abort is used when a
754 * resource problems is indicated which would be due to much more
755 * serious issues - eg. memory or file descriptor leaks. We
756 * wouldn't expect fork(2) or pipe(2) to fail in normal
760 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
765 if (flag_copy_stdin) {
766 if (pipe (stdin_fd) == -1) {
778 if (pid == 0) { /* Child process running the command. */
780 if (flag_copy_stdin) {
781 dup2 (stdin_fd[0], 0);
785 /* Set stdin to /dev/null (ignore failure) */
786 open ("/dev/null", O_RDONLY);
789 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
797 execvp (argv[0], (void *) argv);
799 _exit (EXIT_FAILURE);
802 if (flag_copy_stdin) {
803 int fd = flags & COMMAND_FLAG_FD_MASK;
806 if (stdin_pid == -1) {
811 if (stdin_pid == 0) { /* Child process copying stdin. */
818 dup2 (stdin_fd[1], 1);
822 if (chroot (sysroot) == -1) {
824 _exit (EXIT_FAILURE);
829 while ((n = read (fd, buffer, sizeof buffer)) > 0) {
830 if (xwrite (1, buffer, n) == -1)
831 /* EPIPE error indicates the command process has exited
832 * early. If the command process fails that will be caught
833 * by the daemon, and if not, then it's not an error.
835 _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
840 _exit (EXIT_FAILURE);
843 if (close (fd) == -1) {
845 _exit (EXIT_FAILURE);
848 _exit (EXIT_SUCCESS);
856 /* Parent process. */
861 FD_SET (so_fd[0], &rset);
862 FD_SET (se_fd[0], &rset);
867 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
871 if (stdoutput) free (*stdoutput);
872 if (stderror) free (*stderror);
875 waitpid (pid, NULL, 0);
876 if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
880 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
881 r = read (so_fd[0], buf, sizeof buf);
886 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
888 if (r > 0 && stdoutput) {
890 p = realloc (*stdoutput, so_size);
896 memcpy (*stdoutput + so_size - r, buf, r);
900 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
901 r = read (se_fd[0], buf, sizeof buf);
906 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
910 ignore_value (write (2, buf, r));
914 p = realloc (*stderror, se_size);
920 memcpy (*stderror + se_size - r, buf, r);
929 /* Make sure the output buffers are \0-terminated. Also remove any
930 * trailing \n characters from the error buffer (not from stdout).
933 void *q = realloc (*stdoutput, so_size+1);
940 (*stdoutput)[so_size] = '\0';
943 void *q = realloc (*stderror, se_size+1);
950 (*stderror)[se_size] = '\0';
952 while (se_size >= 0 && (*stderror)[se_size] == '\n')
953 (*stderror)[se_size--] = '\0';
957 if (flag_copy_stdin) {
958 /* Check copy process didn't fail. */
959 if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
962 waitpid (pid, NULL, 0);
966 if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
967 fprintf (stderr, "failed copying from input file, see earlier messages\n");
969 waitpid (pid, NULL, 0);
974 /* Get the exit status of the command. */
975 if (waitpid (pid, &r, 0) != pid) {
981 return WEXITSTATUS (r);
986 /* Split an output string into a NULL-terminated list of lines.
987 * Typically this is used where we have run an external command
988 * which has printed out a list of things, and we want to return
991 * The corner cases here are quite tricky. Note in particular:
995 * "a\nb" -> ["a"; "b"]
996 * "a\nb\n" -> ["a"; "b"]
997 * "a\nb\n\n" -> ["a"; "b"; ""]
999 * The original string is written over and destroyed by this
1000 * function (which is usually OK because it's the 'out' string
1001 * from command()). You can free the original string, because
1002 * add_string() strdups the strings.
1005 split_lines (char *str)
1007 char **lines = NULL;
1008 int size = 0, alloc = 0;
1011 if (STREQ (str, ""))
1016 /* Empty last line? */
1020 pend = strchr (p, '\n');
1026 if (add_string (&lines, &size, &alloc, p) == -1) {
1034 if (add_string (&lines, &size, &alloc, NULL) == -1)
1040 /* Skip leading and trailing whitespace, updating the original string
1046 size_t len = strlen (str);
1048 while (len > 0 && c_isspace (str[len-1])) {
1053 const char *p = str;
1054 while (*p && c_isspace (*p)) {
1059 memmove (str, p, len+1);
1062 /* printf helper function so we can use %Q ("quoted") and %R to print
1063 * shell-quoted strings. See HACKING file for more details.
1066 print_shell_quote (FILE *stream,
1067 const struct printf_info *info ATTRIBUTE_UNUSED,
1068 const void *const *args)
1070 #define SAFE(c) (c_isalnum((c)) || \
1071 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
1073 const char *str = *((const char **) (args[0]));
1075 for (i = len = 0; str[i]; ++i) {
1076 if (!SAFE(str[i])) {
1077 putc ('\\', stream);
1080 putc (str[i], stream);
1088 print_sysroot_shell_quote (FILE *stream,
1089 const struct printf_info *info,
1090 const void *const *args)
1092 fputs (sysroot, stream);
1093 return sysroot_len + print_shell_quote (stream, info, args);
1096 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1098 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1099 size_t n, int *argtypes, int *size)
1102 argtypes[0] = PA_STRING;
1103 size[0] = sizeof (const char *);
1108 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1110 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1113 argtypes[0] = PA_STRING;
1117 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1121 /* Perform device name translation. Don't call this directly -
1122 * use the RESOLVE_DEVICE macro.
1124 * See guestfs(3) for the algorithm.
1126 * We have to open the device and test for ENXIO, because
1127 * the device nodes themselves will exist in the appliance.
1130 device_name_translation (char *device)
1134 fd = open (device, O_RDONLY);
1141 if (errno != ENXIO && errno != ENOENT)
1144 /* If the name begins with "/dev/sd" then try the alternatives. */
1145 if (STRNEQLEN (device, "/dev/sd", 7))
1148 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1149 fd = open (device, O_RDONLY);
1153 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1154 fd = open (device, O_RDONLY);
1158 device[5] = 's'; /* Restore original device name. */
1162 /* Check program exists and is executable on $PATH. Actually, we
1163 * just assume PATH contains the default entries (see main() above).
1166 prog_exists (const char *prog)
1168 static const char * const dirs[] =
1169 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1173 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1174 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1175 if (access (buf, X_OK) == 0)
1181 /* LVM and other commands aren't synchronous, especially when udev is
1182 * involved. eg. You can create or remove some device, but the /dev
1183 * device node won't appear until some time later. This means that
1184 * you get an error if you run one command followed by another.
1186 * Use 'udevadm settle' after certain commands, but don't be too
1187 * fussed if it fails.
1189 * 'udevsettle' was the old name for this command (RHEL 5). This was
1190 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1191 * command was left as a symlink. Then in Fedora 13 the old symlink
1192 * remained but it stopped working (RHBZ#548121), so we have to be
1193 * careful not to assume that we can use 'udevsettle' if it exists.
1198 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1199 (void) command (NULL, NULL, "udevsettle", NULL);