X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fupload.c;h=623ad3a171e0380258d9edcc016e15cf683cf2d1;hp=d93a5ade9b996a2ab05bb7bd83c0a797fb0a6ddc;hb=d600342b7d29c0176ff96a7807ebb38303ecb3a6;hpb=5922d7084d6b43f0a1a15b664c7082dfeaf584d0

diff --git a/daemon/upload.c b/daemon/upload.c
index d93a5ad..623ad3a 100644
--- a/daemon/upload.c
+++ b/daemon/upload.c
@@ -20,8 +20,12 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 #include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 
 #include "../src/guestfs_protocol.h"
 #include "daemon.h"
@@ -35,30 +39,40 @@ write_cb (void *fd_ptr, const void *buf, size_t len)
 }
 
 /* Has one FileIn parameter. */
-int
-do_upload (const char *filename)
+static int
+upload (const char *filename, int flags, int64_t offset)
 {
   int err, fd, r, is_dev;
 
   is_dev = STRPREFIX (filename, "/dev/");
 
   if (!is_dev) CHROOT_IN;
-  fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);
+  fd = open (filename, flags, 0666);
   if (!is_dev) CHROOT_OUT;
   if (fd == -1) {
     err = errno;
-    cancel_receive ();
+    r = cancel_receive ();
     errno = err;
-    reply_with_perror ("%s", filename);
+    if (r != -2) reply_with_perror ("%s", filename);
     return -1;
   }
 
+  if (offset) {
+    if (lseek (fd, offset, SEEK_SET) == -1) {
+      err = errno;
+      r = cancel_receive ();
+      errno = err;
+      if (r != -2) reply_with_perror ("lseek: %s", filename);
+      return -1;
+    }
+  }
+
   r = receive_file (write_cb, &fd);
   if (r == -1) {		/* write error */
     err = errno;
-    cancel_receive ();
+    r = cancel_receive ();
     errno = err;
-    reply_with_error ("write error: %s", filename);
+    if (r != -2) reply_with_error ("write error: %s", filename);
     close (fd);
     return -1;
   }
@@ -71,15 +85,35 @@ do_upload (const char *filename)
   if (close (fd) == -1) {
     err = errno;
     if (r == -1)                /* if r == 0, file transfer ended already */
-      cancel_receive ();
+      r = cancel_receive ();
     errno = err;
-    reply_with_perror ("close: %s", filename);
+    if (r != -2)
+      reply_with_perror ("close: %s", filename);
     return -1;
   }
 
   return 0;
 }
 
+/* Has one FileIn parameter. */
+int
+do_upload (const char *filename)
+{
+  return upload (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0);
+}
+
+/* Has one FileIn parameter. */
+int
+do_upload_offset (const char *filename, int64_t offset)
+{
+  if (offset < 0) {
+    reply_with_perror ("%s: offset in file is negative", filename);
+    return -1;
+  }
+
+  return upload (filename, O_WRONLY|O_CREAT|O_NOCTTY, offset);
+}
+
 /* Has one FileOut parameter. */
 int
 do_download (const char *filename)
@@ -97,6 +131,26 @@ do_download (const char *filename)
     return -1;
   }
 
+  /* Calculate the size of the file or device for notification messages. */
+  uint64_t total, sent = 0;
+  if (!is_dev) {
+    struct stat statbuf;
+    if (fstat (fd, &statbuf) == -1) {
+      reply_with_perror ("%s", filename);
+      close (fd);
+      return -1;
+    }
+    total = statbuf.st_size;
+  } else {
+    int64_t size = do_blockdev_getsize64 (filename);
+    if (size == -1) {
+      /* do_blockdev_getsize64 has already sent a reply. */
+      close (fd);
+      return -1;
+    }
+    total = (uint64_t) size;
+  }
+
   /* Now we must send the reply message, before the file contents.  After
    * this there is no opportunity in the protocol to send any error
    * message back.  Instead we can only cancel the transfer.
@@ -108,6 +162,9 @@ do_download (const char *filename)
       close (fd);
       return -1;
     }
+
+    sent += r;
+    notify_progress (sent, total);
   }
 
   if (r == -1) {
@@ -128,3 +185,83 @@ do_download (const char *filename)
 
   return 0;
 }
+
+/* Has one FileOut parameter. */
+int
+do_download_offset (const char *filename, int64_t offset, int64_t size)
+{
+  int fd, r, is_dev;
+  char buf[GUESTFS_MAX_CHUNK_SIZE];
+
+  if (offset < 0) {
+    reply_with_perror ("%s: offset in file is negative", filename);
+    return -1;
+  }
+
+  if (size < 0) {
+    reply_with_perror ("%s: size is negative", filename);
+    return -1;
+  }
+  uint64_t usize = (uint64_t) size;
+
+  is_dev = STRPREFIX (filename, "/dev/");
+
+  if (!is_dev) CHROOT_IN;
+  fd = open (filename, O_RDONLY);
+  if (!is_dev) CHROOT_OUT;
+  if (fd == -1) {
+    reply_with_perror ("%s", filename);
+    return -1;
+  }
+
+  if (offset) {
+    if (lseek (fd, offset, SEEK_SET) == -1) {
+      reply_with_perror ("lseek: %s", filename);
+      return -1;
+    }
+  }
+
+  uint64_t total = usize, sent = 0;
+
+  /* Now we must send the reply message, before the file contents.  After
+   * this there is no opportunity in the protocol to send any error
+   * message back.  Instead we can only cancel the transfer.
+   */
+  reply (NULL, NULL);
+
+  while (usize > 0) {
+    r = read (fd, buf, usize > sizeof buf ? sizeof buf : usize);
+    if (r == -1) {
+      perror (filename);
+      send_file_end (1);        /* Cancel. */
+      close (fd);
+      return -1;
+    }
+
+    if (r == 0)
+      /* The documentation leaves this case undefined.  Currently we
+       * just read fewer bytes than requested.
+       */
+      break;
+
+    if (send_file_write (buf, r) < 0) {
+      close (fd);
+      return -1;
+    }
+
+    sent += r;
+    usize -= r;
+    notify_progress (sent, total);
+  }
+
+  if (close (fd) == -1) {
+    perror (filename);
+    send_file_end (1);		/* Cancel. */
+    return -1;
+  }
+
+  if (send_file_end (0))	/* Normal end of file. */
+    return -1;
+
+  return 0;
+}