X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=src%2Fguestfs.c;h=395bc97c8cd7f74382a7a0094dbc3f04302325cc;hb=60258700e81a6a68875496f365d9f9cec19c8df2;hp=8836a7e3c26e31170ba2a4ebd68e1145838251bd;hpb=ab76c39d696c7f0a0071bfbac0e36af69594e68c;p=libguestfs.git

diff --git a/src/guestfs.c b/src/guestfs.c
index 8836a7e..395bc97 100644
--- a/src/guestfs.c
+++ b/src/guestfs.c
@@ -267,8 +267,10 @@ guestfs_close (guestfs_h *g)
     fprintf (stderr, "closing guestfs handle %p (state %d)\n", g, g->state);
 
   /* Try to sync if autosync flag is set. */
-  if (g->autosync && g->state == READY)
+  if (g->autosync && g->state == READY) {
+    guestfs_umount_all (g);
     guestfs_sync (g);
+  }
 
   /* Remove any handlers that might be called back before we kill the
    * subprocess.
@@ -807,7 +809,7 @@ guestfs_launch (guestfs_h *g)
     add_cmdline (g, "-net");
     add_cmdline (g, "user,vlan=0");
     add_cmdline (g, "-net");
-    add_cmdline (g, "nic,model=rtl8139,vlan=0");
+    add_cmdline (g, "nic,model=virtio,vlan=0");
     incr_cmdline_size (g);
     g->cmdline[g->cmdline_size-1] = NULL;
 
@@ -1840,13 +1842,14 @@ check_for_daemon_cancellation (guestfs_h *g)
 
 /* Synchronously receive a file. */
 
-static int receive_file_data_sync (guestfs_h *g, void **buf);
+/* Returns -1 = error, 0 = EOF, 1 = more data */
+static int receive_file_data_sync (guestfs_h *g, void **buf, int *len);
 
 int
 guestfs__receive_file_sync (guestfs_h *g, const char *filename)
 {
   void *buf;
-  int fd, r;
+  int fd, r, len;
 
   fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666);
   if (fd == -1) {
@@ -1855,13 +1858,14 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename)
   }
 
   /* Receive the file in chunked encoding. */
-  while ((r = receive_file_data_sync (g, &buf)) > 0) {
-    if (xwrite (fd, buf, r) == -1) {
+  while ((r = receive_file_data_sync (g, &buf, &len)) >= 0) {
+    if (xwrite (fd, buf, len) == -1) {
       perrorf (g, "%s: write", filename);
       free (buf);
       goto cancel;
     }
     free (buf);
+    if (r == 0) break; /* End of file. */
   }
 
   if (r == -1) {
@@ -1893,75 +1897,123 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename)
     return -1;
   }
 
-  while ((r = receive_file_data_sync (g, &buf)) > 0)
-    free (buf);			/* just discard it */
+  while ((r = receive_file_data_sync (g, NULL, NULL)) > 0)
+    ;				/* just discard it */
 
   return -1;
 }
 
+/* Note that the reply callback can be called multiple times before
+ * the main loop quits and we get back to the synchronous code.  So
+ * we have to be prepared to save multiple chunks on a list here.
+ */
 struct receive_file_ctx {
-  int code;
-  void **buf;
+  int count;			/* 0 if receive_file_cb not called, or
+				 * else count number of chunks.
+				 */
+  guestfs_chunk *chunks;	/* Array of chunks. */
 };
 
 static void
+free_chunks (struct receive_file_ctx *ctx)
+{
+  int i;
+
+  for (i = 0; i < ctx->count; ++i)
+    free (ctx->chunks[i].data.data_val);
+
+  free (ctx->chunks);
+}
+
+static void
 receive_file_cb (guestfs_h *g, void *data, XDR *xdr)
 {
   guestfs_main_loop *ml = guestfs_get_main_loop (g);
   struct receive_file_ctx *ctx = (struct receive_file_ctx *) data;
   guestfs_chunk chunk;
 
+  if (ctx->count == -1)		/* Parse error occurred previously. */
+    return;
+
   ml->main_loop_quit (ml, g);
 
   memset (&chunk, 0, sizeof chunk);
 
   if (!xdr_guestfs_chunk (xdr, &chunk)) {
     error (g, "failed to parse file chunk");
-    ctx->code = -1;
-    return;
-  }
-  if (chunk.cancel) {
-    error (g, "file receive cancelled by daemon");
-    ctx->code = -2;
-    return;
-  }
-  if (chunk.data.data_len == 0) { /* end of transfer */
-    ctx->code = 0;
+    free_chunks (ctx);
+    ctx->chunks = NULL;
+    ctx->count = -1;
     return;
   }
 
-  ctx->code = chunk.data.data_len;
-  *ctx->buf = chunk.data.data_val; /* caller frees */
+  /* Copy the chunk to the list. */
+  ctx->chunks = safe_realloc (g, ctx->chunks,
+			      sizeof (guestfs_chunk) * (ctx->count+1));
+  ctx->chunks[ctx->count] = chunk;
+  ctx->count++;
 }
 
 /* Receive a chunk of file data. */
+/* Returns -1 = error, 0 = EOF, 1 = more data */
 static int
-receive_file_data_sync (guestfs_h *g, void **buf)
+receive_file_data_sync (guestfs_h *g, void **buf, int *len_r)
 {
   struct receive_file_ctx ctx;
   guestfs_main_loop *ml = guestfs_get_main_loop (g);
+  int i, len;
 
-  ctx.code = -3;
-  ctx.buf = buf;
+  ctx.count = 0;
+  ctx.chunks = NULL;
 
   guestfs_set_reply_callback (g, receive_file_cb, &ctx);
   (void) ml->main_loop_run (ml, g);
   guestfs_set_reply_callback (g, NULL, NULL);
 
-  if (g->verbose)
-    fprintf (stderr, "receive_file_data_sync: code %d\n", ctx.code);
-
-  switch (ctx.code) {
-  case 0:			/* end of file */
-    return 0;
-  case -1: case -2:
+  if (ctx.count == 0) {
+    error (g, "receive_file_data_sync: reply callback not called\n");
     return -1;
-  case -3:
-    error (g, "failed to call receive_file_cb");
+  }
+
+  if (ctx.count == -1) {
+    error (g, "receive_file_data_sync: parse error in reply callback\n");
+    /* callback already freed the chunks */
     return -1;
-  default:			/* received n bytes of data */
-    return ctx.code;
   }
+
+  if (g->verbose)
+    fprintf (stderr, "receive_file_data_sync: got %d chunks\n", ctx.count);
+
+  /* Process each chunk in the list. */
+  if (buf) *buf = NULL;		/* Accumulate data in this buffer. */
+  len = 0;
+
+  for (i = 0; i < ctx.count; ++i) {
+    if (ctx.chunks[i].cancel) {
+      error (g, "file receive cancelled by daemon");
+      free_chunks (&ctx);
+      if (buf) free (*buf);
+      if (len_r) *len_r = 0;
+      return -1;
+    }
+
+    if (ctx.chunks[i].data.data_len == 0) { /* end of transfer */
+      free_chunks (&ctx);
+      if (len_r) *len_r = len;
+      return 0;
+    }
+
+    if (buf) {
+      *buf = safe_realloc (g, *buf, len + ctx.chunks[i].data.data_len);
+      memcpy (*buf+len, ctx.chunks[i].data.data_val,
+	      ctx.chunks[i].data.data_len);
+    }
+    len += ctx.chunks[i].data.data_len;
+  }
+
+  if (len_r) *len_r = len;
+  free_chunks (&ctx);
+  return 1;
 }
 
 /* This is the default main loop implementation, using select(2). */