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);
59 /* This is the default address we connect to for very old libraries
60 * which didn't specify the address and port number explicitly on the
61 * kernel command line. It's now recommended to always specify the
62 * address and port number on the command line, so this will not be
65 #define OLD_GUESTFWD_ADDR "10.0.2.4"
66 #define OLD_GUESTFWD_PORT "6666"
68 /* This is only a hint. If not defined, ignore it. */
70 # define AI_ADDRCONFIG 0
74 # define MAX(a,b) ((a)>(b)?(a):(b))
79 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
80 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
81 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
82 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
84 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
85 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
87 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
93 daemon (int nochdir, int noclose)
96 "On Windows the daemon does not support forking into the "
97 "background.\nYou *must* run the daemon with the -f option.\n");
108 /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
109 r = gl_sockets_startup (SOCKETS_2_2);
110 return r == 0 ? 0 : -1;
120 /* Location to mount root device. */
121 const char *sysroot = "/sysroot"; /* No trailing slash. */
124 /* Not used explicitly, but required by the gnulib 'error' module. */
125 const char *program_name = "guestfsd";
131 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
135 main (int argc, char *argv[])
137 static const char *options = "fc:v?";
138 static const struct option long_options[] = {
139 { "channel", required_argument, 0, 'c' },
140 { "foreground", 0, 0, 'f' },
141 { "help", 0, 0, '?' },
142 { "verbose", 0, 0, 'v' },
148 char *vmchannel = NULL;
150 if (winsock_init () == -1)
151 error (EXIT_FAILURE, 0, "winsock initialization failed");
153 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
154 /* http://udrepper.livejournal.com/20948.html */
155 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
156 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
158 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
159 register_printf_function ('Q', print_shell_quote, print_arginfo);
160 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
162 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
167 c = getopt_long (argc, argv, options, long_options, NULL);
188 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
198 cmdline = read_cmdline ();
200 /* Set the verbose flag. */
202 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
204 printf ("verbose daemon enabled\n");
208 printf ("linux commmand line: %s\n", cmdline);
210 printf ("could not read linux command line\n");
214 /* Make sure SIGPIPE doesn't kill us. */
216 memset (&sa, 0, sizeof sa);
217 sa.sa_handler = SIG_IGN;
219 if (sigaction (SIGPIPE, &sa, NULL) == -1)
220 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
224 # define setenv(n,v,f) _putenv(n "=" v)
226 /* Set up a basic environment. After we are called by /init the
227 * environment is essentially empty.
228 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
230 * NOTE: if you change $PATH, you must also change 'prog_exists'
233 setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
234 setenv ("SHELL", "/bin/sh", 1);
235 setenv ("LC_ALL", "C", 1);
236 setenv ("TERM", "dumb", 1);
239 /* We document that umask defaults to 022 (it should be this anyway). */
242 /* This is the default for Windows anyway. It's not even clear if
243 * Windows ever uses this -- the MSDN documentation for the function
244 * contains obvious errors.
249 /* Get the vmchannel string.
252 * --channel/-c option on the command line
253 * guestfs_vmchannel=... from the kernel command line
254 * guestfs=... from the kernel command line
257 * At the moment we expect this to contain "tcp:ip:port" but in
258 * future it might contain a device name, eg. "/dev/vcon4" for
259 * virtio-console vmchannel.
261 if (vmchannel == NULL && cmdline) {
265 p = strstr (cmdline, "guestfs_vmchannel=");
267 len = strcspn (p + 18, " \t\n");
268 vmchannel = strndup (p + 18, len);
275 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
276 if (vmchannel == NULL) {
277 /* We will rewrite it part of the "guestfs=" string with
278 * "tcp:" hence p + 4 below. */
279 p = strstr (cmdline, "guestfs=");
281 len = strcspn (p + 4, " \t\n");
282 vmchannel = strndup (p + 4, len);
287 memcpy (vmchannel, "tcp:", 4);
292 /* Default vmchannel. */
293 if (vmchannel == NULL) {
294 vmchannel = strdup ("tcp:" OLD_GUESTFWD_ADDR ":" OLD_GUESTFWD_PORT);
302 printf ("vmchannel: %s\n", vmchannel);
304 /* Connect to vmchannel. */
307 if (STREQLEN (vmchannel, "tcp:", 4)) {
308 /* Resolve the hostname. */
309 struct addrinfo *res, *rr;
310 struct addrinfo hints;
315 port = strchr (host, ':');
320 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
325 memset (&hints, 0, sizeof hints);
326 hints.ai_socktype = SOCK_STREAM;
327 hints.ai_flags = AI_ADDRCONFIG;
328 r = getaddrinfo (host, port, &hints, &res);
330 fprintf (stderr, "%s:%s: %s\n",
331 host, port, gai_strerror (r));
335 /* Connect to the given TCP socket. */
336 for (rr = res; rr != NULL; rr = rr->ai_next) {
337 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
339 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
350 "unknown vmchannel connection type: %s\n"
351 "expecting \"tcp:<ip>:<port>\"\n",
359 "Failed to connect to any vmchannel implementation.\n"
362 "This is a fatal error and the appliance will now exit.\n"
364 "Usually this error is caused by either QEMU or the appliance\n"
365 "kernel not supporting the vmchannel method that the\n"
366 "libguestfs library chose to use. Please run\n"
367 "'libguestfs-test-tool' and provide the complete, unedited\n"
368 "output to the libguestfs developers, either in a bug report\n"
369 "or on the libguestfs redhat com mailing list.\n"
375 /* Send the magic length message which indicates that
376 * userspace is up inside the guest.
380 uint32_t len = GUESTFS_LAUNCH_FLAG;
381 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
382 xdr_u_int (&xdr, &len);
384 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
389 /* Fork into the background. */
391 if (daemon (0, 1) == -1) {
397 /* Enter the main loop, reading and performing actions. */
403 /* Read /proc/cmdline. */
407 int fd = open ("/proc/cmdline", O_RDONLY);
409 perror ("/proc/cmdline");
419 n = read (fd, buf, sizeof buf);
428 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
436 memcpy (&r[len], buf, n);
443 if (close (fd) == -1) {
452 /* Turn "/path" into "/sysroot/path".
454 * Caller must check for NULL and call reply_with_perror ("malloc")
455 * if it is. Caller must also free the string.
457 * See also the custom %R printf formatter which does shell quoting too.
460 sysroot_path (const char *path)
463 int len = strlen (path) + sysroot_len + 1;
469 snprintf (r, len, "%s%s", sysroot, path);
474 xwrite (int sock, const void *v_buf, size_t len)
477 const char *buf = v_buf;
480 r = write (sock, buf, len);
493 xread (int sock, void *v_buf, size_t len)
499 r = read (sock, buf, len);
505 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
516 add_string (char ***argv, int *size, int *alloc, const char *str)
521 if (*size >= *alloc) {
523 new_argv = realloc (*argv, *alloc * sizeof (char *));
524 if (new_argv == NULL) {
525 reply_with_perror ("realloc");
526 free_strings (*argv);
533 new_str = strdup (str);
534 if (new_str == NULL) {
535 reply_with_perror ("strdup");
536 free_strings (*argv);
541 (*argv)[*size] = new_str;
548 count_strings (char *const *argv)
552 for (argc = 0; argv[argc] != NULL; ++argc)
557 /* http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2 */
559 is_power_of_2 (unsigned long v)
561 return v && ((v & (v - 1)) == 0);
565 compare (const void *vp1, const void *vp2)
567 char * const *p1 = (char * const *) vp1;
568 char * const *p2 = (char * const *) vp2;
569 return strcmp (*p1, *p2);
573 sort_strings (char **argv, int len)
575 qsort (argv, len, sizeof (char *), compare);
579 free_strings (char **argv)
583 for (argc = 0; argv[argc] != NULL; ++argc)
589 free_stringslen (char **argv, int len)
593 for (i = 0; i < len; ++i)
598 /* Easy ways to run external commands. For full documentation, see
599 * 'commandrvf' below.
602 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
609 /* Collect the command line arguments into an array. */
611 argv = malloc (sizeof (char *) * i);
616 argv[0] = (char *) name;
619 va_start (args, name);
621 while ((s = va_arg (args, char *)) != NULL) {
622 const char **p = realloc (argv, sizeof (char *) * (++i));
636 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
638 /* NB: Mustn't free the strings which are on the stack. */
644 /* Same as 'command', but we allow the status code from the
645 * subcommand to be non-zero, and return that status code.
646 * We still return -1 if there was some other error.
649 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
656 /* Collect the command line arguments into an array. */
658 argv = malloc (sizeof (char *) * i);
663 argv[0] = (char *) name;
666 va_start (args, name);
668 while ((s = va_arg (args, char *)) != NULL) {
669 const char **p = realloc (argv, sizeof (char *) * (++i));
683 r = commandrvf (stdoutput, stderror, flags, argv);
685 /* NB: Mustn't free the strings which are on the stack. */
691 /* Same as 'command', but passing an argv. */
693 commandvf (char **stdoutput, char **stderror, int flags,
694 char const *const *argv)
698 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
705 /* This is a more sane version of 'system(3)' for running external
706 * commands. It uses fork/execvp, so we don't need to worry about
707 * quoting of parameters, and it allows us to capture any error
708 * messages in a buffer.
710 * If stdoutput is not NULL, then *stdoutput will return the stdout
713 * If stderror is not NULL, then *stderror will return the stderr
714 * of the command. If there is a final \n character, it is removed
715 * so you can use the error string directly in a call to
720 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
721 * that send error messages to stdout (hello, parted) but that don't
722 * have any useful stdout information, use this flag to capture the
723 * error messages in the *stderror buffer. If using this flag,
724 * you should pass stdoutput as NULL because nothing could ever be
725 * captured in that buffer.
727 * COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN: For running external
728 * commands on chrooted files correctly (see RHBZ#579608) specifying
729 * this flag causes another process to be forked which chroots into
730 * sysroot and just copies the input file to stdin of the specified
731 * command. The file descriptor is ORed with the flags, and that file
732 * descriptor is always closed by this function. See hexdump.c for an
736 commandrvf (char **stdoutput, char **stderror, int flags,
737 char const* const *argv)
739 int so_size = 0, se_size = 0;
740 int so_fd[2], se_fd[2];
741 int flag_copy_stdin = flags & COMMAND_FLAG_CHROOT_COPY_FILE_TO_STDIN;
742 int stdin_fd[2] = { -1, -1 };
743 pid_t pid, stdin_pid = -1;
749 if (stdoutput) *stdoutput = NULL;
750 if (stderror) *stderror = NULL;
753 printf ("%s", argv[0]);
754 for (i = 1; argv[i] != NULL; ++i)
755 printf (" %s", argv[i]);
759 /* Note: abort is used in a few places along the error paths early
760 * in this function. This is because (a) cleaning up correctly is
761 * very complex at these places and (b) abort is used when a
762 * resource problems is indicated which would be due to much more
763 * serious issues - eg. memory or file descriptor leaks. We
764 * wouldn't expect fork(2) or pipe(2) to fail in normal
768 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
769 error (0, errno, "pipe");
773 if (flag_copy_stdin) {
774 if (pipe (stdin_fd) == -1) {
775 error (0, errno, "pipe");
782 error (0, errno, "fork");
786 if (pid == 0) { /* Child process running the command. */
788 if (flag_copy_stdin) {
789 dup2 (stdin_fd[0], 0);
793 /* Set stdin to /dev/null (ignore failure) */
794 open ("/dev/null", O_RDONLY);
798 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
806 execvp (argv[0], (void *) argv);
808 _exit (EXIT_FAILURE);
811 if (flag_copy_stdin) {
812 int fd = flags & COMMAND_FLAG_FD_MASK;
815 if (stdin_pid == -1) {
816 error (0, errno, "fork");
820 if (stdin_pid == 0) { /* Child process copying stdin. */
827 dup2 (stdin_fd[1], 1);
831 if (chroot (sysroot) == -1) {
833 _exit (EXIT_FAILURE);
838 while ((n = read (fd, buffer, sizeof buffer)) > 0) {
839 if (xwrite (1, buffer, n) == -1)
840 /* EPIPE error indicates the command process has exited
841 * early. If the command process fails that will be caught
842 * by the daemon, and if not, then it's not an error.
844 _exit (errno == EPIPE ? EXIT_SUCCESS : EXIT_FAILURE);
849 _exit (EXIT_FAILURE);
852 if (close (fd) == -1) {
854 _exit (EXIT_FAILURE);
857 _exit (EXIT_SUCCESS);
865 /* Parent process. */
870 FD_SET (so_fd[0], &rset);
871 FD_SET (se_fd[0], &rset);
876 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
880 if (stdoutput) free (*stdoutput);
881 if (stderror) free (*stderror);
884 waitpid (pid, NULL, 0);
885 if (stdin_pid >= 0) waitpid (stdin_pid, NULL, 0);
889 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
890 r = read (so_fd[0], buf, sizeof buf);
895 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
897 if (r > 0 && stdoutput) {
899 p = realloc (*stdoutput, so_size);
905 memcpy (*stdoutput + so_size - r, buf, r);
909 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
910 r = read (se_fd[0], buf, sizeof buf);
915 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
919 ignore_value (write (2, buf, r));
923 p = realloc (*stderror, se_size);
929 memcpy (*stderror + se_size - r, buf, r);
938 /* Make sure the output buffers are \0-terminated. Also remove any
939 * trailing \n characters from the error buffer (not from stdout).
942 void *q = realloc (*stdoutput, so_size+1);
949 (*stdoutput)[so_size] = '\0';
952 void *q = realloc (*stderror, se_size+1);
959 (*stderror)[se_size] = '\0';
961 while (se_size >= 0 && (*stderror)[se_size] == '\n')
962 (*stderror)[se_size--] = '\0';
966 if (flag_copy_stdin) {
967 /* Check copy process didn't fail. */
968 if (waitpid (stdin_pid, &r, 0) != stdin_pid) {
971 waitpid (pid, NULL, 0);
975 if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
976 fprintf (stderr, "failed copying from input file, see earlier messages\n");
978 waitpid (pid, NULL, 0);
983 /* Get the exit status of the command. */
984 if (waitpid (pid, &r, 0) != pid) {
990 return WEXITSTATUS (r);
995 /* Split an output string into a NULL-terminated list of lines.
996 * Typically this is used where we have run an external command
997 * which has printed out a list of things, and we want to return
1000 * The corner cases here are quite tricky. Note in particular:
1004 * "a\nb" -> ["a"; "b"]
1005 * "a\nb\n" -> ["a"; "b"]
1006 * "a\nb\n\n" -> ["a"; "b"; ""]
1008 * The original string is written over and destroyed by this
1009 * function (which is usually OK because it's the 'out' string
1010 * from command()). You can free the original string, because
1011 * add_string() strdups the strings.
1014 split_lines (char *str)
1016 char **lines = NULL;
1017 int size = 0, alloc = 0;
1020 if (STREQ (str, ""))
1025 /* Empty last line? */
1029 pend = strchr (p, '\n');
1035 if (add_string (&lines, &size, &alloc, p) == -1) {
1043 if (add_string (&lines, &size, &alloc, NULL) == -1)
1049 /* Skip leading and trailing whitespace, updating the original string
1055 size_t len = strlen (str);
1057 while (len > 0 && c_isspace (str[len-1])) {
1062 const char *p = str;
1063 while (*p && c_isspace (*p)) {
1068 memmove (str, p, len+1);
1071 /* printf helper function so we can use %Q ("quoted") and %R to print
1072 * shell-quoted strings. See HACKING file for more details.
1075 print_shell_quote (FILE *stream,
1076 const struct printf_info *info ATTRIBUTE_UNUSED,
1077 const void *const *args)
1079 #define SAFE(c) (c_isalnum((c)) || \
1080 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
1082 const char *str = *((const char **) (args[0]));
1084 for (i = len = 0; str[i]; ++i) {
1085 if (!SAFE(str[i])) {
1086 putc ('\\', stream);
1089 putc (str[i], stream);
1097 print_sysroot_shell_quote (FILE *stream,
1098 const struct printf_info *info,
1099 const void *const *args)
1101 fputs (sysroot, stream);
1102 return sysroot_len + print_shell_quote (stream, info, args);
1105 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
1107 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
1108 size_t n, int *argtypes, int *size)
1111 argtypes[0] = PA_STRING;
1112 size[0] = sizeof (const char *);
1117 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1119 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1122 argtypes[0] = PA_STRING;
1126 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1130 /* Perform device name translation. Don't call this directly -
1131 * use the RESOLVE_DEVICE macro.
1133 * See guestfs(3) for the algorithm.
1135 * We have to open the device and test for ENXIO, because
1136 * the device nodes themselves will exist in the appliance.
1139 device_name_translation (char *device)
1143 fd = open (device, O_RDONLY);
1150 if (errno != ENXIO && errno != ENOENT)
1153 /* If the name begins with "/dev/sd" then try the alternatives. */
1154 if (STRNEQLEN (device, "/dev/sd", 7))
1157 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1158 fd = open (device, O_RDONLY);
1162 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1163 fd = open (device, O_RDONLY);
1167 device[5] = 's'; /* Restore original device name. */
1171 /* Check program exists and is executable on $PATH. Actually, we
1172 * just assume PATH contains the default entries (see main() above).
1175 prog_exists (const char *prog)
1177 static const char * const dirs[] =
1178 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1182 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1183 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1184 if (access (buf, X_OK) == 0)
1190 /* LVM and other commands aren't synchronous, especially when udev is
1191 * involved. eg. You can create or remove some device, but the /dev
1192 * device node won't appear until some time later. This means that
1193 * you get an error if you run one command followed by another.
1195 * Use 'udevadm settle' after certain commands, but don't be too
1196 * fussed if it fails.
1198 * 'udevsettle' was the old name for this command (RHEL 5). This was
1199 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1200 * command was left as a symlink. Then in Fedora 13 the old symlink
1201 * remained but it stopped working (RHBZ#548121), so we have to be
1202 * careful not to assume that we can use 'udevsettle' if it exists.
1207 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1208 (void) command (NULL, NULL, "udevsettle", NULL);