Add the possibility to forward to the stdin of the process, and get the fd for it; only in async mode for now. --- src/command.c | 43 ++++++++++++++++++++++++++++++++++++++----- src/guestfs-internal.h | 2 +- 2 files changed, 39 insertions(+), 6 deletions(-) diff --git a/src/command.c b/src/command.c index 563d0af..0480cd3 100644 --- a/src/command.c +++ b/src/command.c @@ -138,6 +138,9 @@ struct command /* Optional child setup callback. */ cmd_child_callback child_callback; void *child_callback_data; + + /* Optional stdin forwarding to the child. */ + int infd; }; /* Create a new command handle. */ @@ -152,6 +155,7 @@ guestfs___new_command (guestfs_h *g) cmd->close_files = true; cmd->errorfd = -1; cmd->outfd = -1; + cmd->infd = -1; return cmd; } @@ -377,17 +381,27 @@ debug_command (struct command *cmd) } static int -run_command (struct command *cmd, bool get_stdout_fd, bool get_stderr_fd) +run_command (struct command *cmd, bool get_stdin_fd, bool get_stdout_fd, + bool get_stderr_fd) { struct sigaction sa; int i, fd, max_fd, r; int errorfd[2] = { -1, -1 }; int outfd[2] = { -1, -1 }; + int infd[2] = { -1, -1 }; char status_string[80]; get_stdout_fd = get_stdout_fd || cmd->stdout_callback != NULL; get_stderr_fd = get_stderr_fd || cmd->capture_errors; + /* Set up a pipe to forward the stdin to the command. */ + if (get_stdin_fd) { + if (pipe2 (infd, O_CLOEXEC) == -1) { + perrorf (cmd->g, "pipe2"); + goto error; + } + } + /* Set up a pipe to capture command output and send it to the error log. */ if (get_stderr_fd) { if (pipe2 (errorfd, O_CLOEXEC) == -1) { @@ -426,6 +440,13 @@ run_command (struct command *cmd, bool get_stdout_fd, bool get_stderr_fd) outfd[0] = -1; } + if (get_stdin_fd) { + close (infd[0]); + infd[0] = -1; + cmd->infd = infd[1]; + infd[1] = -1; + } + return 0; } @@ -444,6 +465,12 @@ run_command (struct command *cmd, bool get_stdout_fd, bool get_stderr_fd) close (outfd[1]); } + if (get_stdin_fd) { + close (infd[1]); + dup2 (infd[0], 0); + close (infd[0]); + } + if (cmd->stderr_to_stdout) dup2 (1, 2); @@ -640,7 +667,7 @@ guestfs___cmd_run (struct command *cmd) if (cmd->g->verbose) debug_command (cmd); - if (run_command (cmd, false, false) == -1) + if (run_command (cmd, false, false, false) == -1) return -1; if (loop (cmd) == -1) @@ -650,7 +677,7 @@ guestfs___cmd_run (struct command *cmd) } /* Fork, run the command, and returns the pid of the command, - * and its stdout and stderr file descriptors. + * and its stdin, stdout and stderr file descriptors. * * Returns the exit status. Test it using WIF* macros. * @@ -658,18 +685,21 @@ guestfs___cmd_run (struct command *cmd) */ int guestfs___cmd_run_async (struct command *cmd, pid_t *pid, - int *stdout_fd, int *stderr_fd) + int *stdin_fd, int *stdout_fd, int *stderr_fd) { finish_command (cmd); if (cmd->g->verbose) debug_command (cmd); - if (run_command (cmd, stdout_fd != NULL, stderr_fd != NULL) == -1) + if (run_command (cmd, stdin_fd != NULL, stdout_fd != NULL, + stderr_fd != NULL) == -1) return -1; if (pid) *pid = cmd->pid; + if (stdin_fd) + *stdin_fd = cmd->infd; if (stdout_fd) *stdout_fd = cmd->outfd; if (stderr_fd) @@ -718,6 +748,9 @@ guestfs___cmd_close (struct command *cmd) if (cmd->outfd >= 0) close (cmd->outfd); + if (cmd->infd >= 0) + close (cmd->infd); + free (cmd->outbuf.buffer); if (cmd->pid > 0) diff --git a/src/guestfs-internal.h b/src/guestfs-internal.h index 91e3065..01bee2c 100644 --- a/src/guestfs-internal.h +++ b/src/guestfs-internal.h @@ -873,7 +873,7 @@ extern void guestfs___cmd_clear_capture_errors (struct command *); extern void guestfs___cmd_clear_close_files (struct command *); extern void guestfs___cmd_set_child_callback (struct command *, cmd_child_callback child_callback, void *data); extern int guestfs___cmd_run (struct command *); -extern int guestfs___cmd_run_async (struct command *, pid_t *pid, int *stdout_fd, int *stderr_fd); +extern int guestfs___cmd_run_async (struct command *, pid_t *pid, int *stdin_fd, int *stdout_fd, int *stderr_fd); extern int guestfs___cmd_wait (struct command *); extern void guestfs___cmd_close (struct command *); -- 1.9.3

Currently implemented as guestfish commands, provide them instead as single source -> destination functions for the library, so they can be used also in other places. These functions are not added to guestfish, since guestfish has its own implementation (which will soon switch to call copy-in and copy-out for multiple paths). --- generator/actions.ml | 28 ++++++ po/POTFILES | 1 + src/Makefile.am | 1 + src/copy-in-out.c | 244 +++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 274 insertions(+) create mode 100644 src/copy-in-out.c diff --git a/generator/actions.ml b/generator/actions.ml index 25f4bb5..ab97891 100644 --- a/generator/actions.ml +++ b/generator/actions.ml @@ -3310,6 +3310,34 @@ In non-C language bindings, this allows you to retrieve the underlying C pointer to the handle (ie. C<guestfs_h *>). The purpose of this is to allow other libraries to interwork with libguestfs." }; + { defaults with + name = "copy_in"; + style = RErr, [String "localpath"; Pathname "remotedir"], []; + visibility = VPublicNoFish; + shortdesc = "copy local files or directories into an image"; + longdesc = "\ +C<guestfs_copy_in> copies local files or directories recursively into +the disk image, placing them in the directory called C</remotedir> +(which must exist). + +Wildcards cannot be used." }; + + { defaults with + name = "copy_out"; + style = RErr, [Pathname "remotepath"; String "localdir"], []; + visibility = VPublicNoFish; + shortdesc = "copy remote files or directories out of an image"; + longdesc = "\ +C<guestfs_copy_out> copies remote files or directories recursively +out of the disk image, placing them on the host disk in a local +directory called C<localdir> (which must exist). + +To download to the current directory, use C<.> as in: + + C<guestfs_copy_out> /home . + +Wildcards cannot be used." }; + ] (* daemon_functions are any functions which cause some action diff --git a/po/POTFILES b/po/POTFILES index 4194e5f..6e65377 100644 --- a/po/POTFILES +++ b/po/POTFILES @@ -297,6 +297,7 @@ src/canonical-name.c src/cleanup.c src/command.c src/conn-socket.c +src/copy-in-out.c src/create.c src/dbdump.c src/drives.c diff --git a/src/Makefile.am b/src/Makefile.am index a83f257..2496887 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -90,6 +90,7 @@ libguestfs_la_SOURCES = \ canonical-name.c \ command.c \ conn-socket.c \ + copy-in-out.c \ create.c \ dbdump.c \ drives.c \ diff --git a/src/copy-in-out.c b/src/copy-in-out.c new file mode 100644 index 0000000..8e2edd3 --- /dev/null +++ b/src/copy-in-out.c @@ -0,0 +1,244 @@ +/* libguestfs + * Copyright (C) 2015 Red Hat Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <inttypes.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/wait.h> +#include <errno.h> +#include <string.h> + +#include "guestfs.h" +#include "guestfs-internal.h" +#include "guestfs-internal-actions.h" + +static int split_path (char *buf, size_t buf_size, const char *path, const char **dirname, const char **basename); + +int +guestfs__copy_in (guestfs_h *g, const char *localpath, const char *remotedir) +{ + CLEANUP_CMD_CLOSE struct command *cmd = guestfs___new_command (g); + int fd; + int r; + char fdbuf[64]; + size_t buf_len = strlen (localpath) + 1; + char buf[buf_len]; + const char *dirname, *basename; + + if (guestfs_is_dir (g, remotedir) == -1) + return -1; + + if (split_path (buf, buf_len, localpath, &dirname, &basename) == -1) + return -1; + + guestfs___cmd_add_arg (cmd, "tar"); + if (dirname) { + guestfs___cmd_add_arg (cmd, "-C"); + guestfs___cmd_add_arg (cmd, dirname); + } + guestfs___cmd_add_arg (cmd, "-cf"); + guestfs___cmd_add_arg (cmd, "-"); + guestfs___cmd_add_arg (cmd, basename); + + r = guestfs___cmd_run_async (cmd, NULL, NULL, &fd, NULL); + if (r == -1) + return -1; + + snprintf (fdbuf, sizeof fdbuf, "/dev/fd/%d", fd); + + r = guestfs_tar_in (g, fdbuf, remotedir); + + if (close (fd) == -1) { + perror ("close (tar subprocess)"); + return -1; + } + + r = guestfs___cmd_wait (cmd); + if (r == -1) + return -1; + if (!(WIFEXITED (r) && WEXITSTATUS (r) == 0)) + return -1; + + return 0; +} + +struct copy_out_child_data { + const char *localdir; + const char *basename; +}; + +static int +child_setup (guestfs_h *g, void *data) +{ + struct copy_out_child_data d = *(struct copy_out_child_data *) data; + + if (chdir (d.localdir) == -1) { + perror (d.localdir); + return -1; + } + + if (mkdir (d.basename, 0777) == -1 && errno != EEXIST) { + perror (d.basename); + return -1; + } + + if (chdir (d.basename) == -1) { + perror (d.basename); + return -1; + } + + return 0; +} + +int +guestfs__copy_out (guestfs_h *g, const char *remotepath, const char *localdir) +{ + struct stat statbuf; + int r; + + if (stat (localdir, &statbuf) == -1 || + ! (S_ISDIR (statbuf.st_mode))) { + error (g, _("target '%s' is not a directory"), localdir); + return -1; + } + + /* If the remote is a file, download it. If it's a directory, + * create the directory in localdir first before using tar-out. + */ + r = guestfs_is_file (g, remotepath); + if (r == -1) + return -1; + + if (r == 1) { /* is file */ + CLEANUP_FREE char *filename = NULL; + size_t buf_len = strlen (remotepath) + 1; + char buf[buf_len]; + const char *basename; + + if (split_path (buf, buf_len, remotepath, NULL, &basename) == -1) + return -1; + + if (asprintf (&filename, "%s/%s", localdir, basename) == -1) { + perror ("asprintf"); + return -1; + } + if (guestfs_download (g, remotepath, filename) == -1) + return -1; + } else { /* not a regular file */ + CLEANUP_CMD_CLOSE struct command *cmd = guestfs___new_command (g); + struct copy_out_child_data data; + char fdbuf[64]; + int fd; + + r = guestfs_is_dir (g, remotepath); + if (r == -1) + return -1; + + if (r == 0) { + error (g, _("'%s' is not a file or directory"), remotepath); + return -1; + } + + size_t buf_len = strlen (remotepath) + 1; + char buf[buf_len]; + const char *basename; + if (split_path (buf, buf_len, remotepath, NULL, &basename) == -1) + return -1; + + /* RHBZ#845522: If remotepath == "/" then basename would be an empty + * string. Replace it with "." so that make_tar_output writes + * to "localdir/." + */ + if (STREQ (basename, "")) + basename = "."; + + data.localdir = localdir; + data.basename = basename; + + guestfs___cmd_set_child_callback (cmd, &child_setup, &data); + + guestfs___cmd_add_arg (cmd, "tar"); + guestfs___cmd_add_arg (cmd, "-xf"); + guestfs___cmd_add_arg (cmd, "-"); + + r = guestfs___cmd_run_async (cmd, NULL, &fd, NULL, NULL); + if (r == -1) + return -1; + + snprintf (fdbuf, sizeof fdbuf, "/dev/fd/%d", fd); + + r = guestfs_tar_out (g, remotepath, fdbuf); + + if (close (fd) == -1) { + perror ("close (tar-output subprocess)"); + return -1; + } + + r = guestfs___cmd_wait (cmd); + if (r == -1) + return -1; + if (!(WIFEXITED (r) && WEXITSTATUS (r) == 0)) + return -1; + } + + return 0; +} + +/* Split path into directory name and base name, using the buffer + * provided as a working area. If there is no directory name + * (eg. path == "/") then this can return dirname as NULL. + */ +static int +split_path (char *buf, size_t buf_size, + const char *path, const char **dirname, const char **basename) +{ + size_t len = strlen (path); + if (len == 0 || len > buf_size - 1) { + fprintf (stderr, _("error: argument is zero length or longer than maximum permitted\n")); + return -1; + } + + strcpy (buf, path); + + if (len >= 2 && buf[len-1] == '/') { + buf[len-1] = '\0'; + len--; + } + + char *p = strrchr (buf, '/'); + if (p && p > buf) { /* "foo/bar" */ + *p = '\0'; + p++; + if (dirname) *dirname = buf; + if (basename) *basename = p; + } else if (p && p == buf) { /* "/foo" */ + if (dirname) *dirname = "/"; + if (basename) *basename = buf+1; + } else { + if (dirname) *dirname = NULL; + if (basename) *basename = buf; + } + + return 0; +} -- 1.9.3

On Monday 02 February 2015 13:40:44 Richard W.M. Jones wrote: Fixed. You're right, I overly simplified it, thanks. Taken back, using error() instead. Some of the guestfish code is about the handling of the tar child processes, either by directing copy_out's output to tar, or piping tar's output to copy_in. This is now replaced by using the internal commands API, which has been improved to handle the use cases of the previous copy_in & copy_out implementations. The rest of the code has either been used directly, or slightly adapted to use commands and other internal API. I should not have missed anything else, I think. -- Pino Toscano