1 /* libguestfs - the guestfsd daemon
2 * Copyright (C) 2009 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 /* Also in guestfs.c */
59 #define GUESTFWD_ADDR "10.0.2.4"
60 #define GUESTFWD_PORT "6666"
62 /* This is only a hint. If not defined, ignore it. */
64 # define AI_ADDRCONFIG 0
68 # define MAX(a,b) ((a)>(b)?(a):(b))
73 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
74 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
75 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
76 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
78 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
79 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
81 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
87 daemon (int nochdir, int noclose)
90 "On Windows the daemon does not support forking into the "
91 "background.\nYou *must* run the daemon with the -f option.\n");
102 /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */
103 r = gl_sockets_startup (SOCKETS_2_2);
104 return r == 0 ? 0 : -1;
114 /* Location to mount root device. */
115 const char *sysroot = "/sysroot"; /* No trailing slash. */
118 /* Not used explicitly, but required by the gnulib 'error' module. */
119 const char *program_name = "guestfsd";
125 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
129 main (int argc, char *argv[])
131 static const char *options = "fc:v?";
132 static const struct option long_options[] = {
133 { "channel", required_argument, 0, 'c' },
134 { "foreground", 0, 0, 'f' },
135 { "help", 0, 0, '?' },
136 { "verbose", 0, 0, 'v' },
142 char *vmchannel = NULL;
144 if (winsock_init () == -1)
145 error (EXIT_FAILURE, 0, "winsock initialization failed");
147 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
148 /* http://udrepper.livejournal.com/20948.html */
149 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
150 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
152 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
153 register_printf_function ('Q', print_shell_quote, print_arginfo);
154 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
156 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
161 c = getopt_long (argc, argv, options, long_options, NULL);
182 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
192 cmdline = read_cmdline ();
194 /* Set the verbose flag. */
196 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
198 printf ("verbose daemon enabled\n");
202 printf ("linux commmand line: %s\n", cmdline);
204 printf ("could not read linux command line\n");
208 /* Make sure SIGPIPE doesn't kill us. */
210 memset (&sa, 0, sizeof sa);
211 sa.sa_handler = SIG_IGN;
213 if (sigaction (SIGPIPE, &sa, NULL) == -1)
214 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
218 # define setenv(n,v,f) _putenv(n "=" v)
220 /* Set up a basic environment. After we are called by /init the
221 * environment is essentially empty.
222 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
224 * NOTE: if you change $PATH, you must also change 'prog_exists'
227 setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
228 setenv ("SHELL", "/bin/sh", 1);
229 setenv ("LC_ALL", "C", 1);
230 setenv ("TERM", "dumb", 1);
233 /* We document that umask defaults to 022 (it should be this anyway). */
236 /* This is the default for Windows anyway. It's not even clear if
237 * Windows ever uses this -- the MSDN documentation for the function
238 * contains obvious errors.
243 /* Get the vmchannel string.
246 * --channel/-c option on the command line
247 * guestfs_vmchannel=... from the kernel command line
248 * guestfs=... from the kernel command line
251 * At the moment we expect this to contain "tcp:ip:port" but in
252 * future it might contain a device name, eg. "/dev/vcon4" for
253 * virtio-console vmchannel.
255 if (vmchannel == NULL && cmdline) {
259 p = strstr (cmdline, "guestfs_vmchannel=");
261 len = strcspn (p + 18, " \t\n");
262 vmchannel = strndup (p + 18, len);
269 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
270 if (vmchannel == NULL) {
271 /* We will rewrite it part of the "guestfs=" string with
272 * "tcp:" hence p + 4 below. */
273 p = strstr (cmdline, "guestfs=");
275 len = strcspn (p + 4, " \t\n");
276 vmchannel = strndup (p + 4, len);
281 memcpy (vmchannel, "tcp:", 4);
286 /* Default vmchannel. */
287 if (vmchannel == NULL) {
288 vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
296 printf ("vmchannel: %s\n", vmchannel);
298 /* Connect to vmchannel. */
301 if (STREQLEN (vmchannel, "tcp:", 4)) {
302 /* Resolve the hostname. */
303 struct addrinfo *res, *rr;
304 struct addrinfo hints;
309 port = strchr (host, ':');
314 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
319 memset (&hints, 0, sizeof hints);
320 hints.ai_socktype = SOCK_STREAM;
321 hints.ai_flags = AI_ADDRCONFIG;
322 r = getaddrinfo (host, port, &hints, &res);
324 fprintf (stderr, "%s:%s: %s\n",
325 host, port, gai_strerror (r));
329 /* Connect to the given TCP socket. */
330 for (rr = res; rr != NULL; rr = rr->ai_next) {
331 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
333 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
344 "unknown vmchannel connection type: %s\n"
345 "expecting \"tcp:<ip>:<port>\"\n",
353 "Failed to connect to any vmchannel implementation.\n"
356 "This is a fatal error and the appliance will now exit.\n"
358 "Usually this error is caused by either QEMU or the appliance\n"
359 "kernel not supporting the vmchannel method that the\n"
360 "libguestfs library chose to use. Please run\n"
361 "'libguestfs-test-tool' and provide the complete, unedited\n"
362 "output to the libguestfs developers, either in a bug report\n"
363 "or on the libguestfs redhat com mailing list.\n"
369 /* Send the magic length message which indicates that
370 * userspace is up inside the guest.
374 uint32_t len = GUESTFS_LAUNCH_FLAG;
375 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
376 xdr_u_int (&xdr, &len);
378 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
383 /* Fork into the background. */
385 if (daemon (0, 1) == -1) {
391 /* Enter the main loop, reading and performing actions. */
397 /* Read /proc/cmdline. */
401 int fd = open ("/proc/cmdline", O_RDONLY);
403 perror ("/proc/cmdline");
413 n = read (fd, buf, sizeof buf);
422 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
430 memcpy (&r[len], buf, n);
437 if (close (fd) == -1) {
446 /* Turn "/path" into "/sysroot/path".
448 * Caller must check for NULL and call reply_with_perror ("malloc")
449 * if it is. Caller must also free the string.
451 * See also the custom %R printf formatter which does shell quoting too.
454 sysroot_path (const char *path)
457 int len = strlen (path) + sysroot_len + 1;
463 snprintf (r, len, "%s%s", sysroot, path);
468 xwrite (int sock, const void *v_buf, size_t len)
471 const char *buf = v_buf;
474 r = write (sock, buf, len);
487 xread (int sock, void *v_buf, size_t len)
493 r = read (sock, buf, len);
499 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
510 add_string (char ***argv, int *size, int *alloc, const char *str)
515 if (*size >= *alloc) {
517 new_argv = realloc (*argv, *alloc * sizeof (char *));
518 if (new_argv == NULL) {
519 reply_with_perror ("realloc");
520 free_strings (*argv);
527 new_str = strdup (str);
528 if (new_str == NULL) {
529 reply_with_perror ("strdup");
530 free_strings (*argv);
535 (*argv)[*size] = new_str;
542 count_strings (char *const *argv)
546 for (argc = 0; argv[argc] != NULL; ++argc)
552 compare (const void *vp1, const void *vp2)
554 char * const *p1 = (char * const *) vp1;
555 char * const *p2 = (char * const *) vp2;
556 return strcmp (*p1, *p2);
560 sort_strings (char **argv, int len)
562 qsort (argv, len, sizeof (char *), compare);
566 free_strings (char **argv)
570 for (argc = 0; argv[argc] != NULL; ++argc)
576 free_stringslen (char **argv, int len)
580 for (i = 0; i < len; ++i)
585 /* Easy ways to run external commands. For full documentation, see
586 * 'commandrvf' below.
589 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
596 /* Collect the command line arguments into an array. */
598 argv = malloc (sizeof (char *) * i);
603 argv[0] = (char *) name;
606 va_start (args, name);
608 while ((s = va_arg (args, char *)) != NULL) {
609 const char **p = realloc (argv, sizeof (char *) * (++i));
623 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
625 /* NB: Mustn't free the strings which are on the stack. */
631 /* Same as 'command', but we allow the status code from the
632 * subcommand to be non-zero, and return that status code.
633 * We still return -1 if there was some other error.
636 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
643 /* Collect the command line arguments into an array. */
645 argv = malloc (sizeof (char *) * i);
650 argv[0] = (char *) name;
653 va_start (args, name);
655 while ((s = va_arg (args, char *)) != NULL) {
656 const char **p = realloc (argv, sizeof (char *) * (++i));
670 r = commandrvf (stdoutput, stderror, flags, argv);
672 /* NB: Mustn't free the strings which are on the stack. */
678 /* Same as 'command', but passing an argv. */
680 commandvf (char **stdoutput, char **stderror, int flags,
681 char const *const *argv)
685 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
692 /* This is a more sane version of 'system(3)' for running external
693 * commands. It uses fork/execvp, so we don't need to worry about
694 * quoting of parameters, and it allows us to capture any error
695 * messages in a buffer.
697 * If stdoutput is not NULL, then *stdoutput will return the stdout
700 * If stderror is not NULL, then *stderror will return the stderr
701 * of the command. If there is a final \n character, it is removed
702 * so you can use the error string directly in a call to
707 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
708 * that send error messages to stdout (hello, parted) but that don't
709 * have any useful stdout information, use this flag to capture the
710 * error messages in the *stderror buffer. If using this flag,
711 * you should pass stdoutput as NULL because nothing could ever be
712 * captured in that buffer.
715 commandrvf (char **stdoutput, char **stderror, int flags,
716 char const* const *argv)
718 int so_size = 0, se_size = 0;
719 int so_fd[2], se_fd[2];
726 if (stdoutput) *stdoutput = NULL;
727 if (stderror) *stderror = NULL;
730 printf ("%s", argv[0]);
731 for (i = 1; argv[i] != NULL; ++i)
732 printf (" %s", argv[i]);
736 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
751 if (pid == 0) { /* Child process. */
753 open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
756 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
764 execvp (argv[0], (void *) argv);
769 /* Parent process. */
774 FD_SET (so_fd[0], &rset);
775 FD_SET (se_fd[0], &rset);
780 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
784 if (stdoutput) free (*stdoutput);
785 if (stderror) free (*stderror);
788 waitpid (pid, NULL, 0);
792 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
793 r = read (so_fd[0], buf, sizeof buf);
798 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
800 if (r > 0 && stdoutput) {
802 p = realloc (*stdoutput, so_size);
808 memcpy (*stdoutput + so_size - r, buf, r);
812 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
813 r = read (se_fd[0], buf, sizeof buf);
818 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
822 ignore_value (write (2, buf, r));
826 p = realloc (*stderror, se_size);
832 memcpy (*stderror + se_size - r, buf, r);
841 /* Make sure the output buffers are \0-terminated. Also remove any
842 * trailing \n characters from the error buffer (not from stdout).
845 void *q = realloc (*stdoutput, so_size+1);
852 (*stdoutput)[so_size] = '\0';
855 void *q = realloc (*stderror, se_size+1);
862 (*stderror)[se_size] = '\0';
864 while (se_size >= 0 && (*stderror)[se_size] == '\n')
865 (*stderror)[se_size--] = '\0';
869 /* Get the exit status of the command. */
870 if (waitpid (pid, &r, 0) != pid) {
876 return WEXITSTATUS (r);
881 /* Split an output string into a NULL-terminated list of lines.
882 * Typically this is used where we have run an external command
883 * which has printed out a list of things, and we want to return
886 * The corner cases here are quite tricky. Note in particular:
890 * "a\nb" -> ["a"; "b"]
891 * "a\nb\n" -> ["a"; "b"]
892 * "a\nb\n\n" -> ["a"; "b"; ""]
894 * The original string is written over and destroyed by this
895 * function (which is usually OK because it's the 'out' string
896 * from command()). You can free the original string, because
897 * add_string() strdups the strings.
900 split_lines (char *str)
903 int size = 0, alloc = 0;
911 /* Empty last line? */
915 pend = strchr (p, '\n');
921 if (add_string (&lines, &size, &alloc, p) == -1) {
929 if (add_string (&lines, &size, &alloc, NULL) == -1)
935 /* Skip leading and trailing whitespace, updating the original string
941 size_t len = strlen (str);
943 while (len > 0 && c_isspace (str[len-1])) {
949 while (*p && c_isspace (*p)) {
954 memmove (str, p, len+1);
957 /* printf helper function so we can use %Q ("quoted") and %R to print
958 * shell-quoted strings. See HACKING file for more details.
961 print_shell_quote (FILE *stream,
962 const struct printf_info *info ATTRIBUTE_UNUSED,
963 const void *const *args)
965 #define SAFE(c) (c_isalnum((c)) || \
966 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
968 const char *str = *((const char **) (args[0]));
970 for (i = len = 0; str[i]; ++i) {
975 putc (str[i], stream);
983 print_sysroot_shell_quote (FILE *stream,
984 const struct printf_info *info,
985 const void *const *args)
987 fputs (sysroot, stream);
988 return sysroot_len + print_shell_quote (stream, info, args);
991 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
993 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
994 size_t n, int *argtypes, int *size)
997 argtypes[0] = PA_STRING;
998 size[0] = sizeof (const char *);
1003 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
1005 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
1008 argtypes[0] = PA_STRING;
1012 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
1016 /* Perform device name translation. Don't call this directly -
1017 * use the RESOLVE_DEVICE macro.
1019 * See guestfs(3) for the algorithm.
1021 * We have to open the device and test for ENXIO, because
1022 * the device nodes themselves will exist in the appliance.
1025 device_name_translation (char *device, const char *func)
1029 fd = open (device, O_RDONLY);
1035 if (errno != ENXIO && errno != ENOENT) {
1037 reply_with_perror ("%s: %s", func, device);
1041 /* If the name begins with "/dev/sd" then try the alternatives. */
1042 if (STRNEQLEN (device, "/dev/sd", 7))
1045 device[5] = 'h'; /* /dev/hd (old IDE driver) */
1046 fd = open (device, O_RDONLY);
1052 device[5] = 'v'; /* /dev/vd (for virtio devices) */
1053 fd = open (device, O_RDONLY);
1059 device[5] = 's'; /* Restore original device name. */
1063 /* Check program exists and is executable on $PATH. Actually, we
1064 * just assume PATH contains the default entries (see main() above).
1067 prog_exists (const char *prog)
1069 static const char * const dirs[] =
1070 { "/sbin", "/usr/sbin", "/bin", "/usr/bin" };
1074 for (i = 0; i < sizeof dirs / sizeof dirs[0]; ++i) {
1075 snprintf (buf, sizeof buf, "%s/%s", dirs[i], prog);
1076 if (access (buf, X_OK) == 0)
1082 /* LVM and other commands aren't synchronous, especially when udev is
1083 * involved. eg. You can create or remove some device, but the /dev
1084 * device node won't appear until some time later. This means that
1085 * you get an error if you run one command followed by another.
1087 * Use 'udevadm settle' after certain commands, but don't be too
1088 * fussed if it fails.
1090 * 'udevsettle' was the old name for this command (RHEL 5). This was
1091 * deprecated in favour of 'udevadm settle'. The old 'udevsettle'
1092 * command was left as a symlink. Then in Fedora 13 the old symlink
1093 * remained but it stopped working (RHBZ#548121), so we have to be
1094 * careful not to assume that we can use 'udevsettle' if it exists.
1099 (void) command (NULL, NULL, "udevadm", "settle", NULL);
1100 (void) command (NULL, NULL, "udevsettle", NULL);