fish/copy.c

   1 /* guestfish - the filesystem interactive shell
   2  * Copyright (C) 2010-2011 Red Hat Inc.
   3  *
   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.
   8  *
   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.
  13  *
  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <limits.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <sys/wait.h>
  29
  30 #include "fish.h"
  31
  32 struct fd_pid {
  33   int fd;                       /* -1 == error */
  34   pid_t pid;
  35 };
  36
  37 static struct fd_pid make_tar_from_local (const char *local);
  38 static struct fd_pid make_tar_output (const char *local, const char *basename);
  39 static int split_path (char *buf, size_t buf_size, const char *path, const char **dirname, const char **basename);
  40
  41 int
  42 run_copy_in (const char *cmd, size_t argc, char *argv[])
  43 {
  44   if (argc < 2) {
  45     fprintf (stderr,
  46              _("use 'copy-in <local> [<local>...] <remotedir>' to copy files into the image\n"));
  47     return -1;
  48   }
  49
  50   /* Remote directory is always the last arg. */
  51   char *remote = argv[argc-1];
  52
  53   /* Allow win: prefix on remote. */
  54   remote = win_prefix (remote);
  55   if (remote == NULL)
  56     return -1;
  57
  58   int nr_locals = argc-1;
  59
  60   int remote_is_dir = guestfs_is_dir (g, remote);
  61   if (remote_is_dir == -1) {
  62     free (remote);
  63     return -1;
  64   }
  65
  66   if (!remote_is_dir) {
  67     fprintf (stderr, _("copy-in: target '%s' is not a directory\n"), remote);
  68     free (remote);
  69     return -1;
  70   }
  71
  72   /* Upload each local one at a time using tar-in. */
  73   int i;
  74   for (i = 0; i < nr_locals; ++i) {
  75     struct fd_pid fdpid = make_tar_from_local (argv[i]);
  76     if (fdpid.fd == -1) {
  77       free (remote);
  78       return -1;
  79     }
  80
  81     char fdbuf[64];
  82     snprintf (fdbuf, sizeof fdbuf, "/dev/fd/%d", fdpid.fd);
  83
  84     int r = guestfs_tar_in (g, fdbuf, remote);
  85
  86     if (close (fdpid.fd) == -1) {
  87       perror ("close (tar-from-local subprocess)");
  88       r = -1;
  89     }
  90
  91     int status;
  92     if (waitpid (fdpid.pid, &status, 0) == -1) {
  93       perror ("wait (tar-from-local subprocess)");
  94       free (remote);
  95       return -1;
  96     }
  97     if (!(WIFEXITED (status) && WEXITSTATUS (status) == 0)) {
  98       free (remote);
  99       return -1;
 100     }
 101
 102     if (r == -1) {
 103       free (remote);
 104       return -1;
 105     }
 106   }
 107
 108   free (remote);
 109
 110   return 0;
 111 }
 112
 113 static void tar_create (const char *dir, const char *path) __attribute__((noreturn));
 114
 115 /* This creates a subprocess which feeds a tar file back to the
 116  * main guestfish process.
 117  */
 118 static struct fd_pid
 119 make_tar_from_local (const char *local)
 120 {
 121   int fd[2];
 122   struct fd_pid r = { .fd = -1 };
 123
 124   if (pipe (fd) == -1) {
 125     perror ("pipe");
 126     return r;
 127   }
 128
 129   r.pid = fork ();
 130   if (r.pid == -1) {
 131     perror ("fork");
 132     return r;
 133   }
 134
 135   if (r.pid > 0) {              /* Parent */
 136     close (fd[1]);
 137     r.fd = fd[0];
 138     return r;
 139   }
 140
 141   /* Child. */
 142   close (fd[0]);
 143   dup2 (fd[1], 1);
 144   close (fd[1]);
 145
 146   char buf[PATH_MAX];
 147   const char *dirname, *basename;
 148   if (split_path (buf, sizeof buf, local, &dirname, &basename) == -1)
 149     _exit (EXIT_FAILURE);
 150
 151   tar_create (dirname, basename);
 152 }
 153
 154 /* Split path into directory name and base name, using the buffer
 155  * provided as a working area.  If there is no directory name
 156  * (eg. path == "/") then this can return dirname as NULL.
 157  */
 158 static int
 159 split_path (char *buf, size_t buf_size,
 160             const char *path, const char **dirname, const char **basename)
 161 {
 162   size_t len = strlen (path);
 163   if (len == 0 || len > buf_size - 1) {
 164     fprintf (stderr, _("error: argument is zero length or longer than maximum permitted\n"));
 165     return -1;
 166   }
 167
 168   strcpy (buf, path);
 169
 170   if (len >= 2 && buf[len-1] == '/') {
 171     buf[len-1] = '\0';
 172     len--;
 173   }
 174
 175   char *p = strrchr (buf, '/');
 176   if (p && p > buf) {           /* "foo/bar" */
 177     *p = '\0';
 178     p++;
 179     if (dirname) *dirname = buf;
 180     if (basename) *basename = p;
 181   } else if (p && p == buf) {   /* "/foo" */
 182     if (dirname) *dirname = "/";
 183     if (basename) *basename = buf+1;
 184   } else {
 185     if (dirname) *dirname = NULL;
 186     if (basename) *basename = buf;
 187   }
 188
 189   return 0;
 190 }
 191
 192 static void
 193 tar_create (const char *dir, const char *path)
 194 {
 195   if (dir)
 196     execlp ("tar", "tar", "-C", dir, "-cf", "-", path, NULL);
 197   else
 198     execlp ("tar", "tar", "-cf", "-", path, NULL);
 199
 200   perror ("execlp: tar");
 201   _exit (EXIT_FAILURE);
 202 }
 203
 204 int
 205 run_copy_out (const char *cmd, size_t argc, char *argv[])
 206 {
 207   if (argc < 2) {
 208     fprintf (stderr,
 209              _("use 'copy-out <remote> [<remote>...] <localdir>' to copy files out of the image\n"));
 210     return -1;
 211   }
 212
 213   /* Local directory is always the last arg. */
 214   const char *local = argv[argc-1];
 215   int nr_remotes = argc-1;
 216
 217   struct stat statbuf;
 218   if (stat (local, &statbuf) == -1 ||
 219       ! (S_ISDIR (statbuf.st_mode))) {
 220     fprintf (stderr, _("copy-out: target '%s' is not a directory\n"), local);
 221     return -1;
 222   }
 223
 224   /* Download each remote one at a time using tar-out. */
 225   int i, r;
 226   for (i = 0; i < nr_remotes; ++i) {
 227     char *remote = argv[i];
 228
 229     /* Allow win:... prefix on remotes. */
 230     remote = win_prefix (remote);
 231     if (remote == NULL)
 232       return -1;
 233
 234     /* If the remote is a file, download it.  If it's a directory,
 235      * create the directory in local first before using tar-out.
 236      */
 237     r = guestfs_is_file (g, remote);
 238     if (r == -1) {
 239       free (remote);
 240       return -1;
 241     }
 242     if (r == 1) {               /* is file */
 243       char buf[PATH_MAX];
 244       const char *basename;
 245       if (split_path (buf, sizeof buf, remote, NULL, &basename) == -1) {
 246         free (remote);
 247         return -1;
 248       }
 249
 250       char filename[PATH_MAX];
 251       snprintf (filename, sizeof filename, "%s/%s", local, basename);
 252       if (guestfs_download (g, remote, filename) == -1) {
 253         free (remote);
 254         return -1;
 255       }
 256     }
 257     else {                      /* not a regular file */
 258       r = guestfs_is_dir (g, remote);
 259       if (r == -1) {
 260         free (remote);
 261         return -1;
 262       }
 263
 264       if (r == 0) {
 265         fprintf (stderr, _("copy-out: '%s' is not a file or directory\n"),
 266                  remote);
 267         free (remote);
 268         return -1;
 269       }
 270
 271       char buf[PATH_MAX];
 272       const char *basename;
 273       if (split_path (buf, sizeof buf, remote, NULL, &basename) == -1) {
 274         free (remote);
 275         return -1;
 276       }
 277
 278       struct fd_pid fdpid = make_tar_output (local, basename);
 279       if (fdpid.fd == -1) {
 280         free (remote);
 281         return -1;
 282       }
 283
 284       char fdbuf[64];
 285       snprintf (fdbuf, sizeof fdbuf, "/dev/fd/%d", fdpid.fd);
 286
 287       int r = guestfs_tar_out (g, remote, fdbuf);
 288
 289       if (close (fdpid.fd) == -1) {
 290         perror ("close (tar-output subprocess)");
 291         free (remote);
 292         r = -1;
 293       }
 294
 295       int status;
 296       if (waitpid (fdpid.pid, &status, 0) == -1) {
 297         perror ("wait (tar-output subprocess)");
 298         free (remote);
 299         return -1;
 300       }
 301       if (!(WIFEXITED (status) && WEXITSTATUS (status) == 0)) {
 302         free (remote);
 303         return -1;
 304       }
 305
 306       if (r == -1) {
 307         free (remote);
 308         return -1;
 309       }
 310     }
 311
 312     free (remote);
 313   }
 314
 315   return 0;
 316 }
 317
 318 /* This creates a subprocess which takes a tar file from the main
 319  * guestfish process and unpacks it into the 'local/basename'
 320  * directory.
 321  */
 322 static struct fd_pid
 323 make_tar_output (const char *local, const char *basename)
 324 {
 325   int fd[2];
 326   struct fd_pid r = { .fd = -1 };
 327
 328   if (pipe (fd) == -1) {
 329     perror ("pipe");
 330     return r;
 331   }
 332
 333   r.pid = fork ();
 334   if (r.pid == -1) {
 335     perror ("fork");
 336     return r;
 337   }
 338
 339   if (r.pid > 0) {              /* Parent */
 340     close (fd[0]);
 341     r.fd = fd[1];
 342     return r;
 343   }
 344
 345   /* Child. */
 346   close (fd[1]);
 347   dup2 (fd[0], 0);
 348   close (fd[0]);
 349
 350   if (chdir (local) == -1) {
 351     perror (local);
 352     _exit (EXIT_FAILURE);
 353   }
 354
 355   mkdir (basename, 0777);
 356
 357   if (chdir (basename) == -1) {
 358     perror (basename);
 359     _exit (EXIT_FAILURE);
 360   }
 361
 362   execlp ("tar", "tar", "-xf", "-", NULL);
 363   perror ("execlp: tar");
 364   _exit (EXIT_FAILURE);
 365 }