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) */
27 #include <rpc/types.h>
30 #include <sys/param.h>
31 #include <sys/types.h>
40 #ifdef HAVE_SYS_SELECT_H
41 #include <sys/select.h>
44 #ifdef HAVE_SYS_WAIT_H
53 #include "ignore-value.h"
57 static char *read_cmdline (void);
59 /* Also in guestfs.c */
60 #define GUESTFWD_ADDR "10.0.2.4"
61 #define GUESTFWD_PORT "6666"
65 static int print_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
66 static int print_sysroot_shell_quote (FILE *stream, const struct printf_info *info, const void *const *args);
67 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
68 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes, int *size);
70 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
71 static int print_arginfo (const struct printf_info *info, size_t n, int *argtypes);
73 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
77 /* Location to mount root device. */
78 const char *sysroot = "/sysroot"; /* No trailing slash. */
85 "guestfsd [-f|--foreground] [-c|--channel vmchannel] [-v|--verbose]\n");
89 main (int argc, char *argv[])
91 static const char *options = "fc:v?";
92 static const struct option long_options[] = {
93 { "channel", required_argument, 0, 'c' },
94 { "foreground", 0, 0, 'f' },
95 { "help", 0, 0, '?' },
96 { "verbose", 0, 0, 'v' },
102 char *vmchannel = NULL;
104 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
105 /* http://udrepper.livejournal.com/20948.html */
106 register_printf_specifier ('Q', print_shell_quote, print_arginfo);
107 register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
109 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
110 register_printf_function ('Q', print_shell_quote, print_arginfo);
111 register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
113 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
118 c = getopt_long (argc, argv, options, long_options, NULL);
139 fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
149 cmdline = read_cmdline ();
151 /* Set the verbose flag. */
153 (cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
155 printf ("verbose daemon enabled\n");
159 printf ("linux commmand line: %s\n", cmdline);
161 printf ("could not read linux command line\n");
164 /* Make sure SIGPIPE doesn't kill us. */
166 memset (&sa, 0, sizeof sa);
167 sa.sa_handler = SIG_IGN;
169 if (sigaction (SIGPIPE, &sa, NULL) == -1)
170 perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
172 /* Set up a basic environment. After we are called by /init the
173 * environment is essentially empty.
174 * https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
176 setenv ("PATH", "/usr/bin:/bin", 1);
177 setenv ("SHELL", "/bin/sh", 1);
178 setenv ("LC_ALL", "C", 1);
180 /* We document that umask defaults to 022 (it should be this anyway). */
183 /* Get the vmchannel string.
186 * --channel/-c option on the command line
187 * guestfs_vmchannel=... from the kernel command line
188 * guestfs=... from the kernel command line
191 * At the moment we expect this to contain "tcp:ip:port" but in
192 * future it might contain a device name, eg. "/dev/vcon4" for
193 * virtio-console vmchannel.
195 if (vmchannel == NULL && cmdline) {
199 p = strstr (cmdline, "guestfs_vmchannel=");
201 len = strcspn (p + 18, " \t\n");
202 vmchannel = strndup (p + 18, len);
209 /* Old libraries passed guestfs=host:port. Rewrite it as tcp:host:port. */
210 if (vmchannel == NULL) {
211 /* We will rewrite it part of the "guestfs=" string with
212 * "tcp:" hence p + 4 below. */
213 p = strstr (cmdline, "guestfs=");
215 len = strcspn (p + 4, " \t\n");
216 vmchannel = strndup (p + 4, len);
221 memcpy (vmchannel, "tcp:", 4);
226 /* Default vmchannel. */
227 if (vmchannel == NULL) {
228 vmchannel = strdup ("tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT);
236 printf ("vmchannel: %s\n", vmchannel);
238 /* Connect to vmchannel. */
241 if (STREQLEN (vmchannel, "tcp:", 4)) {
242 /* Resolve the hostname. */
243 struct addrinfo *res, *rr;
244 struct addrinfo hints;
249 port = strchr (host, ':');
254 fprintf (stderr, "vmchannel: expecting \"tcp:<ip>:<port>\": %s\n",
259 memset (&hints, 0, sizeof hints);
260 hints.ai_socktype = SOCK_STREAM;
261 hints.ai_flags = AI_ADDRCONFIG;
262 r = getaddrinfo (host, port, &hints, &res);
264 fprintf (stderr, "%s:%s: %s\n",
265 host, port, gai_strerror (r));
269 /* Connect to the given TCP socket. */
270 for (rr = res; rr != NULL; rr = rr->ai_next) {
271 sock = socket (rr->ai_family, rr->ai_socktype, rr->ai_protocol);
273 if (connect (sock, rr->ai_addr, rr->ai_addrlen) == 0)
284 "unknown vmchannel connection type: %s\n"
285 "expecting \"tcp:<ip>:<port>\"\n",
293 "Failed to connect to any vmchannel implementation.\n"
296 "This is a fatal error and the appliance will now exit.\n"
298 "Usually this error is caused by either QEMU or the appliance\n"
299 "kernel not supporting the vmchannel method that the\n"
300 "libguestfs library chose to use. Please run\n"
301 "'libguestfs-test-tool' and provide the complete, unedited\n"
302 "output to the libguestfs developers, either in a bug report\n"
303 "or on the libguestfs redhat com mailing list.\n"
309 /* Send the magic length message which indicates that
310 * userspace is up inside the guest.
314 uint32_t len = GUESTFS_LAUNCH_FLAG;
315 xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
316 xdr_uint32_t (&xdr, &len);
318 if (xwrite (sock, lenbuf, sizeof lenbuf) == -1)
323 /* Fork into the background. */
325 if (daemon (0, 1) == -1) {
331 /* Enter the main loop, reading and performing actions. */
337 /* Read /proc/cmdline. */
341 int fd = open ("/proc/cmdline", O_RDONLY);
343 perror ("/proc/cmdline");
353 n = read (fd, buf, sizeof buf);
362 char *newr = realloc (r, len + n + 1); /* + 1 is for terminating NUL */
370 memcpy (&r[len], buf, n);
377 if (close (fd) == -1) {
386 /* Turn "/path" into "/sysroot/path".
388 * Caller must check for NULL and call reply_with_perror ("malloc")
389 * if it is. Caller must also free the string.
391 * See also the custom %R printf formatter which does shell quoting too.
394 sysroot_path (const char *path)
397 int len = strlen (path) + sysroot_len + 1;
403 snprintf (r, len, "%s%s", sysroot, path);
408 xwrite (int sock, const void *v_buf, size_t len)
411 const char *buf = v_buf;
414 r = write (sock, buf, len);
427 xread (int sock, void *v_buf, size_t len)
433 r = read (sock, buf, len);
439 fprintf (stderr, "read: unexpected end of file on fd %d\n", sock);
450 add_string (char ***argv, int *size, int *alloc, const char *str)
455 if (*size >= *alloc) {
457 new_argv = realloc (*argv, *alloc * sizeof (char *));
458 if (new_argv == NULL) {
459 reply_with_perror ("realloc");
460 free_strings (*argv);
467 new_str = strdup (str);
468 if (new_str == NULL) {
469 reply_with_perror ("strdup");
470 free_strings (*argv);
475 (*argv)[*size] = new_str;
482 count_strings (char *const *argv)
486 for (argc = 0; argv[argc] != NULL; ++argc)
492 compare (const void *vp1, const void *vp2)
494 char * const *p1 = (char * const *) vp1;
495 char * const *p2 = (char * const *) vp2;
496 return strcmp (*p1, *p2);
500 sort_strings (char **argv, int len)
502 qsort (argv, len, sizeof (char *), compare);
506 free_strings (char **argv)
510 for (argc = 0; argv[argc] != NULL; ++argc)
516 free_stringslen (char **argv, int len)
520 for (i = 0; i < len; ++i)
525 /* Easy ways to run external commands. For full documentation, see
526 * 'commandrvf' below.
529 commandf (char **stdoutput, char **stderror, int flags, const char *name, ...)
536 /* Collect the command line arguments into an array. */
538 argv = malloc (sizeof (char *) * i);
543 argv[0] = (char *) name;
546 va_start (args, name);
548 while ((s = va_arg (args, char *)) != NULL) {
549 const char **p = realloc (argv, sizeof (char *) * (++i));
563 r = commandvf (stdoutput, stderror, flags, (const char * const*) argv);
565 /* NB: Mustn't free the strings which are on the stack. */
571 /* Same as 'command', but we allow the status code from the
572 * subcommand to be non-zero, and return that status code.
573 * We still return -1 if there was some other error.
576 commandrf (char **stdoutput, char **stderror, int flags, const char *name, ...)
583 /* Collect the command line arguments into an array. */
585 argv = malloc (sizeof (char *) * i);
590 argv[0] = (char *) name;
593 va_start (args, name);
595 while ((s = va_arg (args, char *)) != NULL) {
596 const char **p = realloc (argv, sizeof (char *) * (++i));
610 r = commandrvf (stdoutput, stderror, flags, argv);
612 /* NB: Mustn't free the strings which are on the stack. */
618 /* Same as 'command', but passing an argv. */
620 commandvf (char **stdoutput, char **stderror, int flags,
621 char const *const *argv)
625 r = commandrvf (stdoutput, stderror, flags, (void *) argv);
632 /* This is a more sane version of 'system(3)' for running external
633 * commands. It uses fork/execvp, so we don't need to worry about
634 * quoting of parameters, and it allows us to capture any error
635 * messages in a buffer.
637 * If stdoutput is not NULL, then *stdoutput will return the stdout
640 * If stderror is not NULL, then *stderror will return the stderr
641 * of the command. If there is a final \n character, it is removed
642 * so you can use the error string directly in a call to
647 * COMMAND_FLAG_FOLD_STDOUT_ON_STDERR: For broken external commands
648 * that send error messages to stdout (hello, parted) but that don't
649 * have any useful stdout information, use this flag to capture the
650 * error messages in the *stderror buffer. If using this flag,
651 * you should pass stdoutput as NULL because nothing could ever be
652 * captured in that buffer.
655 commandrvf (char **stdoutput, char **stderror, int flags,
656 char const* const *argv)
658 int so_size = 0, se_size = 0;
659 int so_fd[2], se_fd[2];
666 if (stdoutput) *stdoutput = NULL;
667 if (stderror) *stderror = NULL;
670 printf ("%s", argv[0]);
671 for (i = 1; argv[i] != NULL; ++i)
672 printf (" %s", argv[i]);
676 if (pipe (so_fd) == -1 || pipe (se_fd) == -1) {
691 if (pid == 0) { /* Child process. */
693 open ("/dev/null", O_RDONLY); /* Set stdin to /dev/null (ignore failure) */
696 if (!(flags & COMMAND_FLAG_FOLD_STDOUT_ON_STDERR))
704 execvp (argv[0], (void *) argv);
709 /* Parent process. */
714 FD_SET (so_fd[0], &rset);
715 FD_SET (se_fd[0], &rset);
720 r = select (MAX (so_fd[0], se_fd[0]) + 1, &rset2, NULL, NULL, NULL);
724 if (stdoutput) free (*stdoutput);
725 if (stderror) free (*stderror);
728 waitpid (pid, NULL, 0);
732 if (FD_ISSET (so_fd[0], &rset2)) { /* something on stdout */
733 r = read (so_fd[0], buf, sizeof buf);
738 if (r == 0) { FD_CLR (so_fd[0], &rset); quit++; }
740 if (r > 0 && stdoutput) {
742 p = realloc (*stdoutput, so_size);
748 memcpy (*stdoutput + so_size - r, buf, r);
752 if (FD_ISSET (se_fd[0], &rset2)) { /* something on stderr */
753 r = read (se_fd[0], buf, sizeof buf);
758 if (r == 0) { FD_CLR (se_fd[0], &rset); quit++; }
762 ignore_value (write (2, buf, r));
766 p = realloc (*stderror, se_size);
772 memcpy (*stderror + se_size - r, buf, r);
781 /* Make sure the output buffers are \0-terminated. Also remove any
782 * trailing \n characters from the error buffer (not from stdout).
785 void *q = realloc (*stdoutput, so_size+1);
792 (*stdoutput)[so_size] = '\0';
795 void *q = realloc (*stderror, se_size+1);
802 (*stderror)[se_size] = '\0';
804 while (se_size >= 0 && (*stderror)[se_size] == '\n')
805 (*stderror)[se_size--] = '\0';
809 /* Get the exit status of the command. */
810 if (waitpid (pid, &r, 0) != pid) {
816 return WEXITSTATUS (r);
821 /* Split an output string into a NULL-terminated list of lines.
822 * Typically this is used where we have run an external command
823 * which has printed out a list of things, and we want to return
826 * The corner cases here are quite tricky. Note in particular:
830 * "a\nb" -> ["a"; "b"]
831 * "a\nb\n" -> ["a"; "b"]
832 * "a\nb\n\n" -> ["a"; "b"; ""]
834 * The original string is written over and destroyed by this
835 * function (which is usually OK because it's the 'out' string
836 * from command()). You can free the original string, because
837 * add_string() strdups the strings.
840 split_lines (char *str)
843 int size = 0, alloc = 0;
851 /* Empty last line? */
855 pend = strchr (p, '\n');
861 if (add_string (&lines, &size, &alloc, p) == -1) {
869 if (add_string (&lines, &size, &alloc, NULL) == -1)
875 /* printf helper function so we can use %Q ("quoted") and %R to print
876 * shell-quoted strings. See HACKING file for more details.
879 print_shell_quote (FILE *stream,
880 const struct printf_info *info ATTRIBUTE_UNUSED,
881 const void *const *args)
883 #define SAFE(c) (c_isalnum((c)) || \
884 (c) == '/' || (c) == '-' || (c) == '_' || (c) == '.')
886 const char *str = *((const char **) (args[0]));
888 for (i = len = 0; str[i]; ++i) {
893 putc (str[i], stream);
901 print_sysroot_shell_quote (FILE *stream,
902 const struct printf_info *info,
903 const void *const *args)
905 fputs (sysroot, stream);
906 return sysroot_len + print_shell_quote (stream, info, args);
909 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
911 print_arginfo (const struct printf_info *info ATTRIBUTE_UNUSED,
912 size_t n, int *argtypes, int *size)
915 argtypes[0] = PA_STRING;
916 size[0] = sizeof (const char *);
921 #ifdef HAVE_REGISTER_PRINTF_FUNCTION
923 print_arginfo (const struct printf_info *info, size_t n, int *argtypes)
926 argtypes[0] = PA_STRING;
930 #error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
934 /* Perform device name translation. Don't call this directly -
935 * use the RESOLVE_DEVICE macro.
937 * See guestfs(3) for the algorithm.
939 * We have to open the device and test for ENXIO, because
940 * the device nodes themselves will exist in the appliance.
943 device_name_translation (char *device, const char *func)
947 fd = open (device, O_RDONLY);
953 if (errno != ENXIO && errno != ENOENT) {
955 reply_with_perror ("%s: %s", func, device);
959 /* If the name begins with "/dev/sd" then try the alternatives. */
960 if (STRNEQLEN (device, "/dev/sd", 7))
963 device[5] = 'h'; /* /dev/hd (old IDE driver) */
964 fd = open (device, O_RDONLY);
970 device[5] = 'v'; /* /dev/vd (for virtio devices) */
971 fd = open (device, O_RDONLY);
977 device[5] = 's'; /* Restore original device name. */
981 /* LVM and other commands aren't synchronous, especially when udev is
982 * involved. eg. You can create or remove some device, but the /dev
983 * device node won't appear until some time later. This means that
984 * you get an error if you run one command followed by another.
985 * Use 'udevadm settle' after certain commands, but don't be too
986 * fussed if it fails.
991 static int which_prog = 0;
993 if (which_prog == 0) {
994 if (access ("/sbin/udevsettle", X_OK) == 0)
996 else if (access ("/sbin/udevadm", X_OK) == 0)
1002 switch (which_prog) {
1004 command (NULL, NULL, "/sbin/udevadm", "settle", NULL);
1007 command (NULL, NULL, "/sbin/udevsettle", NULL);