From: Richard Jones Date: Fri, 11 Sep 2009 19:00:30 +0000 (+0100) Subject: Remove main loop. X-Git-Tag: 1.0.69~5 X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=commitdiff_plain;h=0a0d743ba80e33e676084f2a254c63d4188857b0 Remove main loop. This commit removes the external main loop, which never worked and caused a number of bugs. Requests are now done synchronously, and if the user wants to have requests issued in the background or to have a responsive GUI, then they'll just have to use threads. The big change is to push all reads and writes through two functions called send_to_daemon (for writes) and recv_from_daemon (for reads) which operate synchronously. These functions read/write whole messages, and also handle checking for EOF (ie. daemon died) and asynchronous log message events from qemu (eg. from debug / dmesg printed by the guest). A more complete description of how these work can be found in the code. This code passes a complete run of the tests. Bugs believed to be fixed by this commit: https://bugzilla.redhat.com/show_bug.cgi?id=501888 internal error: reply callback called twice https://bugzilla.redhat.com/show_bug.cgi?id=504418 In virt-inspector: "download: guestfs_download reply failed, see earlier error messages" I have tried to avoid reintroducing this: https://bugzilla.redhat.com/show_bug.cgi?id=508713 libguestfs: error: write: Broken pipe (guestfish only) One other benefit of this is that 'set_busy/end_busy' calls no longer appear in traces. --- diff --git a/guestfs.pod b/guestfs.pod index b8379d0..c5b756e 100644 --- a/guestfs.pod +++ b/guestfs.pod @@ -486,8 +486,7 @@ register to receive these messages. =head2 SETTING CALLBACKS TO HANDLE EVENTS The child process generates events in some situations. Current events -include: receiving a reply message after some action, receiving a log -message, the child process exits, &c. +include: receiving a log message, the child process exits. Use the C functions to set a callback for different types of events. @@ -497,39 +496,6 @@ Calling C again overwrites the previous callback of that type. Cancel all callbacks of this type by calling this function with C set to C. -=head2 NON-BLOCKING ACTIONS - -XXX This section was documented in previous versions but never -implemented in a way which matched the documentation. For now I have -removed the documentation, pending a working implementation. See also -C in the source. - - -=head2 guestfs_set_send_callback - - typedef void (*guestfs_send_cb) (guestfs_h *g, void *opaque); - void guestfs_set_send_callback (guestfs_h *handle, - guestfs_send_cb cb, - void *opaque); - -The callback function C will be called whenever a message -which is queued for sending, has been sent. - -=head2 guestfs_set_reply_callback - - typedef void (*guestfs_reply_cb) (guestfs_h *g, void *opaque, XDR *xdr); - void guestfs_set_reply_callback (guestfs_h *handle, - guestfs_reply_cb cb, - void *opaque); - -The callback function C will be called whenever a reply is -received from the child process. (This corresponds to a transition -from the BUSY state to the READY state). - -Note that the C that you get in the callback is in C -mode, and you need to consume it before you return from the callback -function (since it gets destroyed after). - =head2 guestfs_set_log_message_callback typedef void (*guestfs_log_message_cb) (guestfs_h *g, void *opaque, @@ -572,113 +538,6 @@ corresponds to a transition from LAUNCHING to the READY state). You can use this instead of C to implement a non-blocking wait for the child process to finish booting up. -=head2 EVENT MAIN LOOP - -To use the low-level event API and/or to use handles from multiple -threads, you have to provide an event "main loop". You can write your -own, but if you don't want to write one, two types are provided for -you: - -=over 4 - -=item libguestfs-select - -A simple main loop that is implemented using L. - -This is the default main loop for new guestfs handles, unless you -call C after a handle is created. - -=item libguestfs-glib - -An implementation which can be used with GLib and GTK+ programs. You -can use this to write graphical (GTK+) programs which use libguestfs -without hanging during long or slow operations. - -=back - -=head2 MULTIPLE HANDLES AND MULTIPLE THREADS - -The support for multiple handles and multiple threads is modelled -after glib (although doesn't require glib, if you use the select-based -main loop). - -L - -You will need to create one main loop for each thread that wants to -use libguestfs. Each guestfs handle should be confined to one thread. -If you try to pass guestfs handles between threads, you will get -undefined results. - -If you only want to use guestfs handles from one thread in your -program, but your program has other threads doing other things, then -you don't need to do anything special. - -=head2 SINGLE THREAD CASE - -In the single thread case, there is a single select-based main loop -created for you. All guestfs handles will use this main loop to -execute high level API actions. - -=head2 MULTIPLE THREADS CASE - -In the multiple threads case, you will need to create a main loop for -each thread that wants to use libguestfs. - -To create main loops for other threads, use -C or C. - -Then you will need to attach each handle to the thread-specific main -loop by calling: - - handle = guestfs_create (); - guestfs_set_main_loop (handle, main_loop_of_current_thread); - -=head2 guestfs_set_main_loop - - void guestfs_set_main_loop (guestfs_h *handle, - guestfs_main_loop *main_loop); - -Sets the main loop used by high level API actions for this handle. By -default, the select-based main loop is used (see -C). - -You only need to use this in multi-threaded programs, where multiple -threads want to use libguestfs. Create a main loop for each thread, -then call this function. - -You cannot pass guestfs handles between threads. - -=head2 guestfs_get_main_loop - - guestfs_main_loop *guestfs_get_main_loop (guestfs_h *handle); - -Return the main loop used by C. - -=head2 guestfs_get_default_main_loop - - guestfs_main_loop *guestfs_get_default_main_loop (void); - -Return the default select-based main loop. - -=head2 guestfs_create_main_loop - - guestfs_main_loop *guestfs_create_main_loop (void); - -This creates a select-based main loop. You should create one main -loop for each additional thread that needs to use libguestfs. - -=head2 guestfs_free_main_loop - - void guestfs_free_main_loop (guestfs_main_loop *); - -Free the select-based main loop which was previously allocated with -C. - -=head2 WRITING A CUSTOM MAIN LOOP - -This isn't documented. Please see the libguestfs-select and -libguestfs-glib implementations. - =head1 BLOCK DEVICE NAMING In the kernel there is now quite a profusion of schemata for naming diff --git a/src/generator.ml b/src/generator.ml index 19de0b7..179665b 100755 --- a/src/generator.ml +++ b/src/generator.ml @@ -680,34 +680,6 @@ only useful for printing debug and internal error messages. For more information on states, see L."); - ("set_busy", (RErr, []), -1, [NotInFish], - [], - "set state to busy", - "\ -This sets the state to C. This is only used when implementing -actions using the low-level API. - -For more information on states, see L."); - - ("set_ready", (RErr, []), -1, [NotInFish], - [], - "set state to ready", - "\ -This sets the state to C. This is only used when implementing -actions using the low-level API. - -For more information on states, see L."); - - ("end_busy", (RErr, []), -1, [NotInFish], - [], - "leave the busy state", - "\ -This sets the state to C, or if in C then it leaves the -state as is. This is only used when implementing -actions using the low-level API. - -For more information on states, see L."); - ("set_memsize", (RErr, [Int "memsize"]), -1, [FishAlias "memsize"], [InitNone, Always, TestOutputInt ( [["set_memsize"; "500"]; @@ -4652,16 +4624,16 @@ check_reply_header (guestfs_h *g, static int check_state (guestfs_h *g, const char *caller) { - if (!guestfs_is_ready (g)) { - if (guestfs_is_config (g)) + if (!guestfs__is_ready (g)) { + if (guestfs__is_config (g)) error (g, \"%%s: call launch before using this function\\n(in guestfish, don't forget to use the 'run' command)\", caller); - else if (guestfs_is_launching (g)) + else if (guestfs__is_launching (g)) error (g, \"%%s: call wait_ready() before using this function\", caller); else error (g, \"%%s called from the wrong state, %%d != READY\", - caller, guestfs_get_state (g)); + caller, guestfs__get_state (g)); return -1; } return 0; @@ -4736,76 +4708,6 @@ check_state (guestfs_h *g, const char *caller) fun (shortname, style, _, _, _, _, _) -> let name = "guestfs_" ^ shortname in - (* Generate the context struct which stores the high-level - * state between callback functions. - *) - pr "struct %s_ctx {\n" shortname; - pr " /* This flag is set by the callbacks, so we know we've done\n"; - pr " * the callbacks as expected, and in the right sequence.\n"; - pr " * 0 = not called, 1 = reply_cb called.\n"; - pr " */\n"; - pr " int cb_sequence;\n"; - pr " struct guestfs_message_header hdr;\n"; - pr " struct guestfs_message_error err;\n"; - (match fst style with - | RErr -> () - | RConstString _ | RConstOptString _ -> - failwithf "RConstString|RConstOptString cannot be used by daemon functions" - | RInt _ | RInt64 _ - | RBool _ | RString _ | RStringList _ - | RStruct _ | RStructList _ - | RHashtable _ | RBufferOut _ -> - pr " struct %s_ret ret;\n" name - ); - pr "};\n"; - pr "\n"; - - (* Generate the reply callback function. *) - pr "static void %s_reply_cb (guestfs_h *g, void *data, XDR *xdr)\n" shortname; - pr "{\n"; - pr " guestfs_main_loop *ml = guestfs_get_main_loop (g);\n"; - pr " struct %s_ctx *ctx = (struct %s_ctx *) data;\n" shortname shortname; - pr "\n"; - pr " /* This should definitely not happen. */\n"; - pr " if (ctx->cb_sequence != 0) {\n"; - pr " ctx->cb_sequence = 9999;\n"; - pr " error (g, \"%%s: internal error: reply callback called twice\", \"%s\");\n" name; - pr " return;\n"; - pr " }\n"; - pr "\n"; - pr " ml->main_loop_quit (ml, g);\n"; - pr "\n"; - pr " if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {\n"; - pr " error (g, \"%%s: failed to parse reply header\", \"%s\");\n" name; - pr " return;\n"; - pr " }\n"; - pr " if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {\n"; - pr " if (!xdr_guestfs_message_error (xdr, &ctx->err)) {\n"; - pr " error (g, \"%%s: failed to parse reply error\", \"%s\");\n" - name; - pr " return;\n"; - pr " }\n"; - pr " goto done;\n"; - pr " }\n"; - - (match fst style with - | RErr -> () - | RConstString _ | RConstOptString _ -> - failwithf "RConstString|RConstOptString cannot be used by daemon functions" - | RInt _ | RInt64 _ - | RBool _ | RString _ | RStringList _ - | RStruct _ | RStructList _ - | RHashtable _ | RBufferOut _ -> - pr " if (!xdr_%s_ret (xdr, &ctx->ret)) {\n" name; - pr " error (g, \"%%s: failed to parse reply\", \"%s\");\n" name; - pr " return;\n"; - pr " }\n"; - ); - - pr " done:\n"; - pr " ctx->cb_sequence = 1;\n"; - pr "}\n\n"; - (* Generate the action stub. *) generate_prototype ~extern:false ~semicolon:false ~newline:true ~handle:"g" name style; @@ -4827,21 +4729,32 @@ check_state (guestfs_h *g, const char *caller) | _ -> pr " struct %s_args args;\n" name ); - pr " struct %s_ctx ctx;\n" shortname; - pr " guestfs_main_loop *ml = guestfs_get_main_loop (g);\n"; + pr " guestfs_message_header hdr;\n"; + pr " guestfs_message_error err;\n"; + let has_ret = + match fst style with + | RErr -> false + | RConstString _ | RConstOptString _ -> + failwithf "RConstString|RConstOptString cannot be used by daemon functions" + | RInt _ | RInt64 _ + | RBool _ | RString _ | RStringList _ + | RStruct _ | RStructList _ + | RHashtable _ | RBufferOut _ -> + pr " struct %s_ret ret;\n" name; + true in + pr " int serial;\n"; + pr " int r;\n"; pr "\n"; trace_call shortname style; pr " if (check_state (g, \"%s\") == -1) return %s;\n" name error_code; - pr " guestfs_set_busy (g);\n"; - pr "\n"; - pr " memset (&ctx, 0, sizeof ctx);\n"; + pr " guestfs___set_busy (g);\n"; pr "\n"; (* Send the main header and arguments. *) (match snd style with | [] -> - pr " serial = guestfs__send_sync (g, GUESTFS_PROC_%s, NULL, NULL);\n" + pr " serial = guestfs___send (g, GUESTFS_PROC_%s, NULL, NULL);\n" (String.uppercase shortname) | args -> List.iter ( @@ -4859,13 +4772,13 @@ check_state (guestfs_h *g, const char *caller) pr " args.%s = %s;\n" n n | FileIn _ | FileOut _ -> () ) args; - pr " serial = guestfs__send_sync (g, GUESTFS_PROC_%s,\n" + pr " serial = guestfs___send (g, GUESTFS_PROC_%s,\n" (String.uppercase shortname); pr " (xdrproc_t) xdr_%s_args, (char *) &args);\n" name; ); pr " if (serial == -1) {\n"; - pr " guestfs_end_busy (g);\n"; + pr " guestfs___end_busy (g);\n"; pr " return %s;\n" error_code; pr " }\n"; pr "\n"; @@ -4875,47 +4788,48 @@ check_state (guestfs_h *g, const char *caller) List.iter ( function | FileIn n -> - pr " {\n"; - pr " int r;\n"; - pr "\n"; - pr " r = guestfs__send_file_sync (g, %s);\n" n; - pr " if (r == -1) {\n"; - pr " guestfs_end_busy (g);\n"; - pr " return %s;\n" error_code; - pr " }\n"; - pr " if (r == -2) /* daemon cancelled */\n"; - pr " goto read_reply;\n"; - need_read_reply_label := true; + pr " r = guestfs___send_file (g, %s);\n" n; + pr " if (r == -1) {\n"; + pr " guestfs___end_busy (g);\n"; + pr " return %s;\n" error_code; pr " }\n"; + pr " if (r == -2) /* daemon cancelled */\n"; + pr " goto read_reply;\n"; + need_read_reply_label := true; pr "\n"; | _ -> () ) (snd style); (* Wait for the reply from the remote end. *) if !need_read_reply_label then pr " read_reply:\n"; - pr " guestfs__switch_to_receiving (g);\n"; - pr " ctx.cb_sequence = 0;\n"; - pr " guestfs_set_reply_callback (g, %s_reply_cb, &ctx);\n" shortname; - pr " (void) ml->main_loop_run (ml, g);\n"; - pr " guestfs_set_reply_callback (g, NULL, NULL);\n"; - pr " if (ctx.cb_sequence != 1) {\n"; - pr " error (g, \"%%s reply failed, see earlier error messages\", \"%s\");\n" name; - pr " guestfs_end_busy (g);\n"; + pr " memset (&hdr, 0, sizeof hdr);\n"; + pr " memset (&err, 0, sizeof err);\n"; + if has_ret then pr " memset (&ret, 0, sizeof ret);\n"; + pr "\n"; + pr " r = guestfs___recv (g, \"%s\", &hdr, &err,\n " shortname; + if not has_ret then + pr "NULL, NULL" + else + pr "(xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret" shortname; + pr ");\n"; + + pr " if (r == -1) {\n"; + pr " guestfs___end_busy (g);\n"; pr " return %s;\n" error_code; pr " }\n"; pr "\n"; - pr " if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_%s, serial) == -1) {\n" + pr " if (check_reply_header (g, &hdr, GUESTFS_PROC_%s, serial) == -1) {\n" (String.uppercase shortname); - pr " guestfs_end_busy (g);\n"; + pr " guestfs___end_busy (g);\n"; pr " return %s;\n" error_code; pr " }\n"; pr "\n"; - pr " if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {\n"; - pr " error (g, \"%%s\", ctx.err.error_message);\n"; - pr " free (ctx.err.error_message);\n"; - pr " guestfs_end_busy (g);\n"; + pr " if (hdr.status == GUESTFS_STATUS_ERROR) {\n"; + pr " error (g, \"%%s: %%s\", \"%s\", err.error_message);\n" shortname; + pr " free (err.error_message);\n"; + pr " guestfs___end_busy (g);\n"; pr " return %s;\n" error_code; pr " }\n"; pr "\n"; @@ -4924,41 +4838,41 @@ check_state (guestfs_h *g, const char *caller) List.iter ( function | FileOut n -> - pr " if (guestfs__receive_file_sync (g, %s) == -1) {\n" n; - pr " guestfs_end_busy (g);\n"; + pr " if (guestfs___recv_file (g, %s) == -1) {\n" n; + pr " guestfs___end_busy (g);\n"; pr " return %s;\n" error_code; pr " }\n"; pr "\n"; | _ -> () ) (snd style); - pr " guestfs_end_busy (g);\n"; + pr " guestfs___end_busy (g);\n"; (match fst style with | RErr -> pr " return 0;\n" | RInt n | RInt64 n | RBool n -> - pr " return ctx.ret.%s;\n" n + pr " return ret.%s;\n" n | RConstString _ | RConstOptString _ -> failwithf "RConstString|RConstOptString cannot be used by daemon functions" | RString n -> - pr " return ctx.ret.%s; /* caller will free */\n" n + pr " return ret.%s; /* caller will free */\n" n | RStringList n | RHashtable n -> pr " /* caller will free this, but we need to add a NULL entry */\n"; - pr " ctx.ret.%s.%s_val =\n" n n; - pr " safe_realloc (g, ctx.ret.%s.%s_val,\n" n n; - pr " sizeof (char *) * (ctx.ret.%s.%s_len + 1));\n" + pr " ret.%s.%s_val =\n" n n; + pr " safe_realloc (g, ret.%s.%s_val,\n" n n; + pr " sizeof (char *) * (ret.%s.%s_len + 1));\n" n n; - pr " ctx.ret.%s.%s_val[ctx.ret.%s.%s_len] = NULL;\n" n n n n; - pr " return ctx.ret.%s.%s_val;\n" n n + pr " ret.%s.%s_val[ret.%s.%s_len] = NULL;\n" n n n n; + pr " return ret.%s.%s_val;\n" n n | RStruct (n, _) -> pr " /* caller will free this */\n"; - pr " return safe_memdup (g, &ctx.ret.%s, sizeof (ctx.ret.%s));\n" n n + pr " return safe_memdup (g, &ret.%s, sizeof (ret.%s));\n" n n | RStructList (n, _) -> pr " /* caller will free this */\n"; - pr " return safe_memdup (g, &ctx.ret.%s, sizeof (ctx.ret.%s));\n" n n + pr " return safe_memdup (g, &ret.%s, sizeof (ret.%s));\n" n n | RBufferOut n -> - pr " *size_r = ctx.ret.%s.%s_len;\n" n n; - pr " return ctx.ret.%s.%s_val; /* caller will free */\n" n n + pr " *size_r = ret.%s.%s_len;\n" n n; + pr " return ret.%s.%s_val; /* caller will free */\n" n n ); pr "}\n\n" diff --git a/src/guestfs.c b/src/guestfs.c index 98d99b8..659ace3 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -78,65 +78,10 @@ //#define safe_memdup guestfs_safe_memdup static void default_error_cb (guestfs_h *g, void *data, const char *msg); -static void stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); -static void sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); -static void sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); - +static int send_to_daemon (guestfs_h *g, const void *v_buf, size_t n); +static int recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn); static void close_handles (void); -static int select_add_handle (guestfs_main_loop *ml, guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data); -static int select_remove_handle (guestfs_main_loop *ml, guestfs_h *g, int watch); -static int select_add_timeout (guestfs_main_loop *ml, guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data); -static int select_remove_timeout (guestfs_main_loop *ml, guestfs_h *g, int timer); -static int select_main_loop_run (guestfs_main_loop *ml, guestfs_h *g); -static int select_main_loop_quit (guestfs_main_loop *ml, guestfs_h *g); - -/* Default select-based main loop. */ -struct select_handle_cb_data { - guestfs_handle_event_cb cb; - guestfs_h *g; - void *data; -}; - -struct select_main_loop { - /* NB. These fields must be the same as in struct guestfs_main_loop: */ - guestfs_add_handle_cb add_handle; - guestfs_remove_handle_cb remove_handle; - guestfs_add_timeout_cb add_timeout; - guestfs_remove_timeout_cb remove_timeout; - guestfs_main_loop_run_cb main_loop_run; - guestfs_main_loop_quit_cb main_loop_quit; - - /* Additional private data: */ - int is_running; - - fd_set rset; - fd_set wset; - fd_set xset; - - int max_fd; - int nr_fds; - struct select_handle_cb_data *handle_cb_data; -}; - -/* Default main loop. */ -static struct select_main_loop default_main_loop = { - .add_handle = select_add_handle, - .remove_handle = select_remove_handle, - .add_timeout = select_add_timeout, - .remove_timeout = select_remove_timeout, - .main_loop_run = select_main_loop_run, - .main_loop_quit = select_main_loop_quit, - - /* XXX hopefully .rset, .wset, .xset are initialized to the empty - * set by the normal action of everything being initialized to zero. - */ - .is_running = 0, - .max_fd = -1, - .nr_fds = 0, - .handle_cb_data = NULL, -}; - #define UNIX_PATH_MAX 108 /* Also in guestfsd.c */ @@ -159,9 +104,6 @@ struct guestfs_h pid_t recoverypid; /* Recovery process PID. */ time_t start_t; /* The time when we started qemu. */ - int stdout_watch; /* Watches qemu stdout for log messages. */ - int sock_watch; /* Watches daemon comm socket. */ - char *tmpdir; /* Temporary directory containing socket. */ char *qemu_help, *qemu_version; /* Output of qemu -help, qemu -version. */ @@ -187,10 +129,6 @@ struct guestfs_h guestfs_abort_cb abort_cb; guestfs_error_handler_cb error_cb; void * error_cb_data; - guestfs_send_cb send_cb; - void * send_cb_data; - guestfs_reply_cb reply_cb; - void * reply_cb_data; guestfs_log_message_cb log_message_cb; void * log_message_cb_data; guestfs_subprocess_quit_cb subprocess_quit_cb; @@ -198,15 +136,6 @@ struct guestfs_h guestfs_launch_done_cb launch_done_cb; void * launch_done_cb_data; - /* Main loop used by this handle. */ - guestfs_main_loop *main_loop; - - /* Messages sent and received from the daemon. */ - char *msg_in; - unsigned int msg_in_size, msg_in_allocated; - char *msg_out; - unsigned int msg_out_size, msg_out_pos; - int msg_next_serial; }; @@ -229,8 +158,6 @@ guestfs_create (void) g->fd[0] = -1; g->fd[1] = -1; g->sock = -1; - g->stdout_watch = -1; - g->sock_watch = -1; g->abort_cb = abort; g->error_cb = default_error_cb; @@ -272,8 +199,6 @@ guestfs_create (void) } else g->memsize = 500; - g->main_loop = guestfs_get_default_main_loop (); - /* Start with large serial numbers so they are easy to spot * inside the protocol. */ @@ -334,14 +259,7 @@ guestfs_close (guestfs_h *g) if (g->state != CONFIG) guestfs_kill_subprocess (g); - /* Close any sockets and deregister any handlers. */ - if (g->stdout_watch >= 0) - g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch); - if (g->sock_watch >= 0) - g->main_loop->remove_handle (g->main_loop, g, g->sock_watch); - g->stdout_watch = -1; - g->sock_watch = -1; - + /* Close sockets. */ if (g->fd[0] >= 0) close (g->fd[0]); if (g->fd[1] >= 0) @@ -391,8 +309,6 @@ guestfs_close (guestfs_h *g) } /* release mutex (XXX) */ - free (g->msg_in); - free (g->msg_out); free (g->last_error); free (g->path); free (g->qemu); @@ -565,27 +481,6 @@ xwrite (int fd, const void *v_buf, size_t len) return 0; } -static int -xread (int fd, void *v_buf, size_t len) -{ - char *buf = v_buf; - int r; - - while (len > 0) { - r = read (fd, buf, len); - if (r == -1) { - if (errno == EINTR || errno == EAGAIN) - continue; - return -1; - } - - buf += r; - len -= r; - } - - return 0; -} - void guestfs_set_out_of_memory_handler (guestfs_h *g, guestfs_abort_cb cb) { @@ -848,7 +743,7 @@ guestfs__add_drive (guestfs_h *g, const char *filename) } } - return guestfs_config (g, "-drive", buf); + return guestfs__config (g, "-drive", buf); } int @@ -869,7 +764,7 @@ guestfs__add_drive_ro (guestfs_h *g, const char *filename) snprintf (buf, len, "file=%s,snapshot=on,if=%s", filename, DRIVE_IF); - return guestfs_config (g, "-drive", buf); + return guestfs__config (g, "-drive", buf); } int @@ -885,7 +780,7 @@ guestfs__add_cdrom (guestfs_h *g, const char *filename) return -1; } - return guestfs_config (g, "-cdrom", filename); + return guestfs__config (g, "-cdrom", filename); } /* Returns true iff file is contained in dir. */ @@ -1309,37 +1204,9 @@ guestfs__launch (guestfs_h *g) goto cleanup2; connected: - /* Watch the file descriptors. */ - free (g->msg_in); - g->msg_in = NULL; - g->msg_in_size = g->msg_in_allocated = 0; - - free (g->msg_out); - g->msg_out = NULL; - g->msg_out_size = 0; - g->msg_out_pos = 0; - - g->stdout_watch = - g->main_loop->add_handle (g->main_loop, g, g->fd[1], - GUESTFS_HANDLE_READABLE, - stdout_event, NULL); - if (g->stdout_watch == -1) { - error (g, _("could not watch qemu stdout")); - goto cleanup3; - } - - if (guestfs__switch_to_receiving (g) == -1) - goto cleanup3; - g->state = LAUNCHING; return 0; - cleanup3: - if (g->stdout_watch >= 0) - g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch); - if (g->sock_watch >= 0) - g->main_loop->remove_handle (g->main_loop, g, g->sock_watch); - cleanup2: close (g->sock); @@ -1356,8 +1223,6 @@ guestfs__launch (guestfs_h *g) g->pid = 0; g->recoverypid = 0; g->start_t = 0; - g->stdout_watch = -1; - g->sock_watch = -1; cleanup0: free (kernel); @@ -1513,20 +1378,12 @@ qemu_supports (guestfs_h *g, const char *option) return g->qemu_help && strstr (g->qemu_help, option) != NULL; } -static void -finish_wait_ready (guestfs_h *g, void *vp) -{ - if (g->verbose) - fprintf (stderr, "finish_wait_ready called, %p, vp = %p\n", g, vp); - - *((int *)vp) = 1; - g->main_loop->main_loop_quit (g->main_loop, g); -} - int guestfs__wait_ready (guestfs_h *g) { - int finished = 0, r; + int r; + uint32_t size; + void *buf = NULL; if (g->state == READY) return 0; @@ -1540,15 +1397,12 @@ guestfs__wait_ready (guestfs_h *g) return -1; } - g->launch_done_cb = finish_wait_ready; - g->launch_done_cb_data = &finished; - r = g->main_loop->main_loop_run (g->main_loop, g); - g->launch_done_cb = NULL; - g->launch_done_cb_data = NULL; + r = recv_from_daemon (g, &size, &buf); + free (buf); if (r == -1) return -1; - if (finished != 1) { + if (size != GUESTFS_LAUNCH_FLAG) { error (g, _("guestfs_wait_ready failed, see earlier error messages")); return -1; } @@ -1614,20 +1468,82 @@ guestfs__get_state (guestfs_h *g) return g->state; } -int -guestfs__set_ready (guestfs_h *g) +void +guestfs_set_log_message_callback (guestfs_h *g, + guestfs_log_message_cb cb, void *opaque) { - if (g->state != BUSY) { - error (g, _("guestfs_set_ready: called when in state %d != BUSY"), - g->state); - return -1; - } - g->state = READY; - return 0; + g->log_message_cb = cb; + g->log_message_cb_data = opaque; } +void +guestfs_set_subprocess_quit_callback (guestfs_h *g, + guestfs_subprocess_quit_cb cb, void *opaque) +{ + g->subprocess_quit_cb = cb; + g->subprocess_quit_cb_data = opaque; +} + +void +guestfs_set_launch_done_callback (guestfs_h *g, + guestfs_launch_done_cb cb, void *opaque) +{ + g->launch_done_cb = cb; + g->launch_done_cb_data = opaque; +} + +/*----------------------------------------------------------------------*/ + +/* This is the code used to send and receive RPC messages and (for + * certain types of message) to perform file transfers. This code is + * driven from the generated actions (src/guestfs-actions.c). There + * are five different cases to consider: + * + * (1) A non-daemon function. There is no RPC involved at all, it's + * all handled inside the library. + * + * (2) A simple RPC (eg. "mount"). We write the request, then read + * the reply. The sequence of calls is: + * + * guestfs___set_busy + * guestfs___send + * guestfs___recv + * guestfs___end_busy + * + * (3) An RPC with FileOut parameters (eg. "upload"). We write the + * request, then write the file(s), then read the reply. The sequence + * of calls is: + * + * guestfs___set_busy + * guestfs___send + * guestfs___send_file (possibly multiple times) + * guestfs___recv + * guestfs___end_busy + * + * (4) An RPC with FileIn parameters (eg. "download"). We write the + * request, then read the reply, then read the file(s). The sequence + * of calls is: + * + * guestfs___set_busy + * guestfs___send + * guestfs___recv + * guestfs___recv_file (possibly multiple times) + * guestfs___end_busy + * + * (5) Both FileOut and FileIn parameters. There are no calls like + * this in the current API, but they would be implemented as a + * combination of cases (3) and (4). + * + * During all writes and reads, we also select(2) on qemu stdout + * looking for messages (guestfsd stderr and guest kernel dmesg), and + * anything received is passed up through the log_message_cb. This is + * also the reason why all the sockets are non-blocking. We also have + * to check for EOF (qemu died). All of this is handled by the + * functions send_to_daemon and recv_from_daemon. + */ + int -guestfs__set_busy (guestfs_h *g) +guestfs___set_busy (guestfs_h *g) { if (g->state != READY) { error (g, _("guestfs_set_busy: called when in state %d != READY"), @@ -1639,7 +1555,7 @@ guestfs__set_busy (guestfs_h *g) } int -guestfs__end_busy (guestfs_h *g) +guestfs___end_busy (guestfs_h *g) { switch (g->state) { @@ -1659,23 +1575,17 @@ guestfs__end_busy (guestfs_h *g) return 0; } -/* We don't know if stdout_event or sock_read_event will be the - * first to receive EOF if the qemu process dies. This function - * has the common cleanup code for both. - */ +/* This is called if we detect EOF, ie. qemu died. */ static void child_cleanup (guestfs_h *g) { if (g->verbose) - fprintf (stderr, "stdout_event: %p: child process died\n", g); + fprintf (stderr, "child_cleanup: %p: child process died\n", g); + /*kill (g->pid, SIGTERM);*/ if (g->recoverypid > 0) kill (g->recoverypid, 9); waitpid (g->pid, NULL, 0); if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0); - if (g->stdout_watch >= 0) - g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch); - if (g->sock_watch >= 0) - g->main_loop->remove_handle (g->main_loop, g, g->sock_watch); close (g->fd[0]); close (g->fd[1]); close (g->sock); @@ -1685,47 +1595,42 @@ child_cleanup (guestfs_h *g) g->pid = 0; g->recoverypid = 0; g->start_t = 0; - g->stdout_watch = -1; - g->sock_watch = -1; g->state = CONFIG; if (g->subprocess_quit_cb) g->subprocess_quit_cb (g, g->subprocess_quit_cb_data); } -/* This function is called whenever qemu prints something on stdout. - * Qemu's stdout is also connected to the guest's serial console, so - * we see kernel messages here too. - */ -static void -stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, - int watch, int fd, int events) +static int +read_log_message_or_eof (guestfs_h *g, int fd) { - char buf[4096]; + char buf[BUFSIZ]; int n; #if 0 if (g->verbose) fprintf (stderr, - "stdout_event: %p g->state = %d, fd = %d, events = 0x%x\n", - g, g->state, fd, events); + "read_log_message_or_eof: %p g->state = %d, fd = %d\n", + g, g->state, fd); #endif - if (g->fd[1] != fd) { - error (g, _("stdout_event: internal error: %d != %d"), g->fd[1], fd); - return; - } - + /* QEMU's console emulates a 16550A serial port. The real 16550A + * device has a small FIFO buffer (16 bytes) which means here we see + * lots of small reads of 1-16 bytes in length, usually single + * bytes. + */ n = read (fd, buf, sizeof buf); if (n == 0) { /* Hopefully this indicates the qemu child process has died. */ child_cleanup (g); - return; + return -1; } if (n == -1) { - if (errno != EINTR && errno != EAGAIN) - perrorf (g, "read"); - return; + if (errno == EINTR || errno == EAGAIN) + return 0; + + perrorf (g, "read"); + return -1; } /* In verbose mode, copy all log messages to stderr. */ @@ -1735,354 +1640,305 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, /* It's an actual log message, send it upwards if anyone is listening. */ if (g->log_message_cb) g->log_message_cb (g, g->log_message_cb_data, buf, n); + + return 0; } -/* The function is called whenever we can read something on the - * guestfsd (daemon inside the guest) communication socket. - */ -static void -sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, - int watch, int fd, int events) +static int +check_for_daemon_cancellation_or_eof (guestfs_h *g, int fd) { - XDR xdr; - u_int32_t len; + char buf[4]; int n; + uint32_t flag; + XDR xdr; if (g->verbose) fprintf (stderr, - "sock_read_event: %p g->state = %d, fd = %d, events = 0x%x\n", - g, g->state, fd, events); - - if (g->sock != fd) { - error (g, _("sock_read_event: internal error: %d != %d"), g->sock, fd); - return; - } + "check_for_daemon_cancellation_or_eof: %p g->state = %d, fd = %d\n", + g, g->state, fd); - if (g->msg_in_size <= g->msg_in_allocated) { - g->msg_in_allocated += 4096; - g->msg_in = safe_realloc (g, g->msg_in, g->msg_in_allocated); - } - n = read (g->sock, g->msg_in + g->msg_in_size, - g->msg_in_allocated - g->msg_in_size); + n = read (fd, buf, 4); if (n == 0) { - /* Disconnected. */ + /* Hopefully this indicates the qemu child process has died. */ child_cleanup (g); - return; + return -1; } if (n == -1) { - if (errno != EINTR && errno != EAGAIN) - perrorf (g, "read"); - return; - } - - g->msg_in_size += n; - - /* Have we got enough of a message to be able to process it yet? */ - again: - if (g->msg_in_size < 4) return; - - xdrmem_create (&xdr, g->msg_in, g->msg_in_size, XDR_DECODE); - if (!xdr_uint32_t (&xdr, &len)) { - error (g, _("can't decode length word")); - goto cleanup; - } - - /* Length is normally the length of the message, but when guestfsd - * starts up it sends a "magic" value (longer than any possible - * message). Check for this. - */ - if (len == GUESTFS_LAUNCH_FLAG) { - if (g->state != LAUNCHING) - error (g, _("received magic signature from guestfsd, but in state %d"), - g->state); - else if (g->msg_in_size != 4) - error (g, _("received magic signature from guestfsd, but msg size is %d"), - g->msg_in_size); - else { - g->state = READY; - if (g->launch_done_cb) - g->launch_done_cb (g, g->launch_done_cb_data); - } - - goto cleanup; - } - - /* This can happen if a cancellation happens right at the end - * of us sending a FileIn parameter to the daemon. Discard. The - * daemon should send us an error message next. - */ - if (len == GUESTFS_CANCEL_FLAG) { - g->msg_in_size -= 4; - memmove (g->msg_in, g->msg_in+4, g->msg_in_size); - goto again; - } + if (errno == EINTR || errno == EAGAIN) + return 0; - /* If this happens, it's pretty bad and we've probably lost - * synchronization. - */ - if (len > GUESTFS_MESSAGE_MAX) { - error (g, _("message length (%u) > maximum possible size (%d)"), - len, GUESTFS_MESSAGE_MAX); - goto cleanup; + perrorf (g, "read"); + return -1; } - if (g->msg_in_size-4 < len) return; /* Need more of this message. */ - - /* Got the full message, begin processing it. */ -#if 0 - if (g->verbose) { - int i, j; + xdrmem_create (&xdr, buf, 4, XDR_DECODE); + xdr_uint32_t (&xdr, &flag); + xdr_destroy (&xdr); - for (i = 0; i < g->msg_in_size; i += 16) { - printf ("%04x: ", i); - for (j = i; j < MIN (i+16, g->msg_in_size); ++j) - printf ("%02x ", (unsigned char) g->msg_in[j]); - for (; j < i+16; ++j) - printf (" "); - printf ("|"); - for (j = i; j < MIN (i+16, g->msg_in_size); ++j) - if (isprint (g->msg_in[j])) - printf ("%c", g->msg_in[j]); - else - printf ("."); - for (; j < i+16; ++j) - printf (" "); - printf ("|\n"); - } + if (flag != GUESTFS_CANCEL_FLAG) { + error (g, _("check_for_daemon_cancellation_or_eof: read 0x%x from daemon, expected 0x%x\n"), + flag, GUESTFS_CANCEL_FLAG); + return -1; } -#endif - - /* Not in the expected state. */ - if (g->state != BUSY) - error (g, _("state %d != BUSY"), g->state); - - /* Push the message up to the higher layer. */ - if (g->reply_cb) - g->reply_cb (g, g->reply_cb_data, &xdr); - else - /* This message (probably) should never be printed. */ - fprintf (stderr, "libguesfs: sock_read_event: !!! dropped message !!!\n"); - - g->msg_in_size -= len + 4; - memmove (g->msg_in, g->msg_in+len+4, g->msg_in_size); - if (g->msg_in_size > 0) goto again; - - cleanup: - /* Free the message buffer if it's grown excessively large. */ - if (g->msg_in_allocated > 65536) { - free (g->msg_in); - g->msg_in = NULL; - g->msg_in_size = g->msg_in_allocated = 0; - } else - g->msg_in_size = 0; - xdr_destroy (&xdr); + return -2; } -/* The function is called whenever we can write something on the - * guestfsd (daemon inside the guest) communication socket. +/* This writes the whole N bytes of BUF to the daemon socket. + * + * If the whole write is successful, it returns 0. + * If there was an error, it returns -1. + * If the daemon sent a cancellation message, it returns -2. + * + * It also checks qemu stdout for log messages and passes those up + * through log_message_cb. + * + * It also checks for EOF (qemu died) and passes that up through the + * child_cleanup function above. */ -static void -sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, - int watch, int fd, int events) +static int +send_to_daemon (guestfs_h *g, const void *v_buf, size_t n) { - int n, err; + const char *buf = v_buf; + fd_set rset, rset2; + fd_set wset, wset2; if (g->verbose) fprintf (stderr, - "sock_write_event: %p g->state = %d, fd = %d, events = 0x%x\n", - g, g->state, fd, events); + "send_to_daemon: %p g->state = %d, n = %zu\n", g, g->state, n); - if (g->sock != fd) { - error (g, _("sock_write_event: internal error: %d != %d"), g->sock, fd); - return; - } - - if (g->state != BUSY) { - error (g, _("sock_write_event: state %d != BUSY"), g->state); - return; - } - - if (g->verbose) - fprintf (stderr, "sock_write_event: writing %d bytes ...\n", - g->msg_out_size - g->msg_out_pos); - - n = write (g->sock, g->msg_out + g->msg_out_pos, - g->msg_out_size - g->msg_out_pos); - if (n == -1) { - err = errno; - if (err != EAGAIN) - perrorf (g, "write"); - if (err == EPIPE) /* Disconnected from guest (RHBZ#508713). */ - child_cleanup (g); - return; - } - - if (g->verbose) - fprintf (stderr, "sock_write_event: wrote %d bytes\n", n); + FD_ZERO (&rset); + FD_ZERO (&wset); - g->msg_out_pos += n; + FD_SET (g->fd[1], &rset); /* Read qemu stdout for log messages & EOF. */ + FD_SET (g->sock, &rset); /* Read socket for cancellation & EOF. */ + FD_SET (g->sock, &wset); /* Write to socket to send the data. */ - /* More to write? */ - if (g->msg_out_pos < g->msg_out_size) - return; + int max_fd = g->sock > g->fd[1] ? g->sock : g->fd[1]; - if (g->verbose) - fprintf (stderr, "sock_write_event: done writing, calling send_cb\n"); - - free (g->msg_out); - g->msg_out = NULL; - g->msg_out_pos = g->msg_out_size = 0; + while (n > 0) { + rset2 = rset; + wset2 = wset; + int r = select (max_fd+1, &rset2, &wset2, NULL, NULL); + if (r == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + perrorf (g, "select"); + return -1; + } - /* Done writing, call the higher layer. */ - if (g->send_cb) - g->send_cb (g, g->send_cb_data); -} + if (FD_ISSET (g->fd[1], &rset2)) { + if (read_log_message_or_eof (g, g->fd[1]) == -1) + return -1; + } + if (FD_ISSET (g->sock, &rset2)) { + r = check_for_daemon_cancellation_or_eof (g, g->sock); + if (r < 0) + return r; + } + if (FD_ISSET (g->sock, &wset2)) { + r = write (g->sock, buf, n); + if (r == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + perrorf (g, "write"); + if (errno == EPIPE) /* Disconnected from guest (RHBZ#508713). */ + child_cleanup (g); + return -1; + } + buf += r; + n -= r; + } + } -void -guestfs_set_send_callback (guestfs_h *g, - guestfs_send_cb cb, void *opaque) -{ - g->send_cb = cb; - g->send_cb_data = opaque; + return 0; } -void -guestfs_set_reply_callback (guestfs_h *g, - guestfs_reply_cb cb, void *opaque) +/* This reads a single message, file chunk, launch flag or + * cancellation flag from the daemon. If something was read, it + * returns 0, otherwise -1. + * + * Both size_rtn and buf_rtn must be passed by the caller as non-NULL. + * + * *size_rtn returns the size of the returned message or it may be + * GUESTFS_LAUNCH_FLAG or GUESTFS_CANCEL_FLAG. + * + * *buf_rtn is returned containing the message (if any) or will be set + * to NULL. *buf_rtn must be freed by the caller. + * + * It also checks qemu stdout for log messages and passes those up + * through log_message_cb. + * + * It also checks for EOF (qemu died) and passes that up through the + * child_cleanup function above. + */ +static int +recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn) { - g->reply_cb = cb; - g->reply_cb_data = opaque; -} + fd_set rset, rset2; -void -guestfs_set_log_message_callback (guestfs_h *g, - guestfs_log_message_cb cb, void *opaque) -{ - g->log_message_cb = cb; - g->log_message_cb_data = opaque; -} + if (g->verbose) + fprintf (stderr, + "recv_from_daemon: %p g->state = %d, size_rtn = %p, buf_rtn = %p\n", + g, g->state, size_rtn, buf_rtn); -void -guestfs_set_subprocess_quit_callback (guestfs_h *g, - guestfs_subprocess_quit_cb cb, void *opaque) -{ - g->subprocess_quit_cb = cb; - g->subprocess_quit_cb_data = opaque; -} + FD_ZERO (&rset); -void -guestfs_set_launch_done_callback (guestfs_h *g, - guestfs_launch_done_cb cb, void *opaque) -{ - g->launch_done_cb = cb; - g->launch_done_cb_data = opaque; -} + FD_SET (g->fd[1], &rset); /* Read qemu stdout for log messages & EOF. */ + FD_SET (g->sock, &rset); /* Read socket for data & EOF. */ -/* Access to the handle's main loop and the default main loop. */ -void -guestfs_set_main_loop (guestfs_h *g, guestfs_main_loop *main_loop) -{ - g->main_loop = main_loop; -} + int max_fd = g->sock > g->fd[1] ? g->sock : g->fd[1]; -guestfs_main_loop * -guestfs_get_main_loop (guestfs_h *g) -{ - return g->main_loop; -} + *size_rtn = 0; + *buf_rtn = NULL; -guestfs_main_loop * -guestfs_get_default_main_loop (void) -{ - return (guestfs_main_loop *) &default_main_loop; -} + char lenbuf[4]; + /* nr is the size of the message, but we prime it as -4 because we + * have to read the message length word first. + */ + ssize_t nr = -4; -/* Change the daemon socket handler so that we are now writing. - * This sets the handle to sock_write_event. - */ -int -guestfs__switch_to_sending (guestfs_h *g) -{ - if (g->sock_watch >= 0) { - if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { - error (g, _("remove_handle failed")); - g->sock_watch = -1; + while (nr < *size_rtn) { + rset2 = rset; + int r = select (max_fd+1, &rset2, NULL, NULL, NULL); + if (r == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + perrorf (g, "select"); + free (*buf_rtn); + *buf_rtn = NULL; return -1; } - } - g->sock_watch = - g->main_loop->add_handle (g->main_loop, g, g->sock, - GUESTFS_HANDLE_WRITABLE, - sock_write_event, NULL); - if (g->sock_watch == -1) { - error (g, _("add_handle failed")); - return -1; - } + if (FD_ISSET (g->fd[1], &rset2)) { + if (read_log_message_or_eof (g, g->fd[1]) == -1) { + free (*buf_rtn); + *buf_rtn = NULL; + return -1; + } + } + if (FD_ISSET (g->sock, &rset2)) { + if (nr < 0) { /* Have we read the message length word yet? */ + r = read (g->sock, lenbuf+nr+4, -nr); + if (r == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + int err = errno; + perrorf (g, "read"); + /* Under some circumstances we see "Connection reset by peer" + * here when the child dies suddenly. Catch this and call + * the cleanup function, same as for EOF. + */ + if (err == ECONNRESET) + child_cleanup (g); + return -1; + } + if (r == 0) { + error (g, _("unexpected end of file when reading from daemon")); + child_cleanup (g); + return -1; + } + nr += r; + + if (nr < 0) /* Still not got the whole length word. */ + continue; + + XDR xdr; + xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE); + xdr_uint32_t (&xdr, size_rtn); + xdr_destroy (&xdr); + + if (*size_rtn == GUESTFS_LAUNCH_FLAG) { + if (g->state != LAUNCHING) + error (g, _("received magic signature from guestfsd, but in state %d"), + g->state); + else { + g->state = READY; + if (g->launch_done_cb) + g->launch_done_cb (g, g->launch_done_cb_data); + } + return 0; + } + else if (*size_rtn == GUESTFS_CANCEL_FLAG) + return 0; + /* If this happens, it's pretty bad and we've probably lost + * synchronization. + */ + else if (*size_rtn > GUESTFS_MESSAGE_MAX) { + error (g, _("message length (%u) > maximum possible size (%d)"), + (unsigned) *size_rtn, GUESTFS_MESSAGE_MAX); + return -1; + } - return 0; -} + /* Allocate the complete buffer, size now known. */ + *buf_rtn = safe_malloc (g, *size_rtn); + /*FALLTHROUGH*/ + } -int -guestfs__switch_to_receiving (guestfs_h *g) -{ - if (g->sock_watch >= 0) { - if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { - error (g, _("remove_handle failed")); - g->sock_watch = -1; - return -1; + size_t sizetoread = *size_rtn - nr; + if (sizetoread > BUFSIZ) sizetoread = BUFSIZ; + + r = read (g->sock, (char *) (*buf_rtn) + nr, sizetoread); + if (r == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + perrorf (g, "read"); + free (*buf_rtn); + *buf_rtn = NULL; + return -1; + } + if (r == 0) { + error (g, _("unexpected end of file when reading from daemon")); + child_cleanup (g); + free (*buf_rtn); + *buf_rtn = NULL; + return -1; + } + nr += r; } } - g->sock_watch = - g->main_loop->add_handle (g->main_loop, g, g->sock, - GUESTFS_HANDLE_READABLE, - sock_read_event, NULL); - if (g->sock_watch == -1) { - error (g, _("add_handle failed")); - return -1; + /* Got the full message, caller can start processing it. */ +#if 0 + if (g->verbose) { + size_t i, j; + + for (i = 0; i < nr; i += 16) { + printf ("%04x: ", i); + for (j = i; j < MIN (i+16, nr); ++j) + printf ("%02x ", (unsigned char) (*buf_rtn)[j]); + for (; j < i+16; ++j) + printf (" "); + printf ("|"); + for (j = i; j < MIN (i+16, g->nr); ++j) + if (isprint ((*buf_rtn)[j])) + printf ("%c", (*buf_rtn)[j]); + else + printf ("."); + for (; j < i+16; ++j) + printf (" "); + printf ("|\n"); + } } +#endif return 0; } -/* Dispatch a call (len + header + args) to the remote daemon, - * synchronously (ie. using the guest's main loop to wait until - * it has been sent). Returns -1 for error, or the serial - * number of the message. - */ -static void -send_cb (guestfs_h *g, void *data) -{ - guestfs_main_loop *ml = guestfs_get_main_loop (g); - - *((int *)data) = 1; - ml->main_loop_quit (ml, g); -} - int -guestfs__send_sync (guestfs_h *g, int proc_nr, - xdrproc_t xdrp, char *args) +guestfs___send (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args) { struct guestfs_message_header hdr; XDR xdr; u_int32_t len; int serial = g->msg_next_serial++; - int sent; - guestfs_main_loop *ml = guestfs_get_main_loop (g); + int r; + char *msg_out; + size_t msg_out_size; if (g->state != BUSY) { - error (g, _("guestfs__send_sync: state %d != BUSY"), g->state); - return -1; - } - - /* This is probably an internal error. Or perhaps we should just - * free the buffer anyway? - */ - if (g->msg_out != NULL) { - error (g, _("guestfs__send_sync: msg_out should be NULL")); + error (g, _("guestfs___send: state %d != BUSY"), g->state); return -1; } @@ -2092,8 +1948,8 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, * we have quite limited stack space available, notably when * running in the JVM. */ - g->msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4); - xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE); + msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4); + xdrmem_create (&xdr, msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE); /* Serialize the header. */ hdr.prog = GUESTFS_PROGRAM; @@ -2124,48 +1980,41 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, len = xdr_getpos (&xdr); xdr_destroy (&xdr); - g->msg_out = safe_realloc (g, g->msg_out, len + 4); - g->msg_out_size = len + 4; - g->msg_out_pos = 0; + msg_out = safe_realloc (g, msg_out, len + 4); + msg_out_size = len + 4; - xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE); + xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE); xdr_uint32_t (&xdr, &len); - if (guestfs__switch_to_sending (g) == -1) - goto cleanup1; - - sent = 0; - guestfs_set_send_callback (g, send_cb, &sent); - if (ml->main_loop_run (ml, g) == -1) - goto cleanup1; - if (sent != 1) { - error (g, _("send failed, see earlier error messages")); + again: + r = send_to_daemon (g, msg_out, msg_out_size); + if (r == -2) /* Ignore stray daemon cancellations. */ + goto again; + if (r == -1) goto cleanup1; - } + free (msg_out); return serial; cleanup1: - free (g->msg_out); - g->msg_out = NULL; - g->msg_out_size = 0; + free (msg_out); return -1; } static int cancel = 0; /* XXX Implement file cancellation. */ -static int send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len); -static int send_file_data_sync (guestfs_h *g, const char *buf, size_t len); -static int send_file_cancellation_sync (guestfs_h *g); -static int send_file_complete_sync (guestfs_h *g); +static int send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t len); +static int send_file_data (guestfs_h *g, const char *buf, size_t len); +static int send_file_cancellation (guestfs_h *g); +static int send_file_complete (guestfs_h *g); -/* Synchronously send a file. +/* Send a file. * Returns: * 0 OK * -1 error * -2 daemon cancelled (we must read the error message) */ int -guestfs__send_file_sync (guestfs_h *g, const char *filename) +guestfs___send_file (guestfs_h *g, const char *filename) { char buf[GUESTFS_MAX_CHUNK_SIZE]; int fd, r, err; @@ -2173,7 +2022,7 @@ guestfs__send_file_sync (guestfs_h *g, const char *filename) fd = open (filename, O_RDONLY); if (fd == -1) { perrorf (g, "open: %s", filename); - send_file_cancellation_sync (g); + send_file_cancellation (g); /* Daemon sees cancellation and won't reply, so caller can * just return here. */ @@ -2186,22 +2035,22 @@ guestfs__send_file_sync (guestfs_h *g, const char *filename) if (r == -1 && (errno == EINTR || errno == EAGAIN)) continue; if (r <= 0) break; - err = send_file_data_sync (g, buf, r); + err = send_file_data (g, buf, r); if (err < 0) { if (err == -2) /* daemon sent cancellation */ - send_file_cancellation_sync (g); + send_file_cancellation (g); return err; } } if (cancel) { /* cancel from either end */ - send_file_cancellation_sync (g); + send_file_cancellation (g); return -1; } if (r == -1) { perrorf (g, "read: %s", filename); - send_file_cancellation_sync (g); + send_file_cancellation (g); return -1; } @@ -2210,74 +2059,55 @@ guestfs__send_file_sync (guestfs_h *g, const char *filename) */ if (close (fd) == -1) { perrorf (g, "close: %s", filename); - send_file_cancellation_sync (g); + send_file_cancellation (g); return -1; } - return send_file_complete_sync (g); + return send_file_complete (g); } /* Send a chunk of file data. */ static int -send_file_data_sync (guestfs_h *g, const char *buf, size_t len) +send_file_data (guestfs_h *g, const char *buf, size_t len) { - return send_file_chunk_sync (g, 0, buf, len); + return send_file_chunk (g, 0, buf, len); } /* Send a cancellation message. */ static int -send_file_cancellation_sync (guestfs_h *g) +send_file_cancellation (guestfs_h *g) { - return send_file_chunk_sync (g, 1, NULL, 0); + return send_file_chunk (g, 1, NULL, 0); } /* Send a file complete chunk. */ static int -send_file_complete_sync (guestfs_h *g) +send_file_complete (guestfs_h *g) { char buf[1]; - return send_file_chunk_sync (g, 0, buf, 0); + return send_file_chunk (g, 0, buf, 0); } -/* Send a chunk, cancellation or end of file, synchronously (ie. wait - * for it to go). - */ -static int check_for_daemon_cancellation (guestfs_h *g); - static int -send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen) +send_file_chunk (guestfs_h *g, int cancel, const char *buf, size_t buflen) { u_int32_t len; - int sent; + int r; guestfs_chunk chunk; XDR xdr; - guestfs_main_loop *ml = guestfs_get_main_loop (g); + char *msg_out; + size_t msg_out_size; if (g->state != BUSY) { - error (g, _("send_file_chunk_sync: state %d != READY"), g->state); + error (g, _("send_file_chunk: state %d != READY"), g->state); return -1; } - /* This is probably an internal error. Or perhaps we should just - * free the buffer anyway? - */ - if (g->msg_out != NULL) { - error (g, _("guestfs__send_sync: msg_out should be NULL")); - return -1; - } - - /* Did the daemon send a cancellation message? */ - if (check_for_daemon_cancellation (g)) { - if (g->verbose) - fprintf (stderr, "got daemon cancellation\n"); - return -2; - } - /* Allocate the chunk buffer. Don't use the stack to avoid * excessive stack usage and unnecessary copies. */ - g->msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48); - xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); + msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48); + xdrmem_create (&xdr, msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); /* Serialize the chunk. */ chunk.cancel = cancel; @@ -2295,87 +2125,98 @@ send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen) xdr_destroy (&xdr); /* Reduce the size of the outgoing message buffer to the real length. */ - g->msg_out = safe_realloc (g, g->msg_out, len + 4); - g->msg_out_size = len + 4; - g->msg_out_pos = 0; + msg_out = safe_realloc (g, msg_out, len + 4); + msg_out_size = len + 4; - xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE); + xdrmem_create (&xdr, msg_out, 4, XDR_ENCODE); xdr_uint32_t (&xdr, &len); - if (guestfs__switch_to_sending (g) == -1) - goto cleanup1; + r = send_to_daemon (g, msg_out, msg_out_size); - sent = 0; - guestfs_set_send_callback (g, send_cb, &sent); - if (ml->main_loop_run (ml, g) == -1) - goto cleanup1; - if (sent != 1) { - error (g, _("send file chunk failed, see earlier error messages")); - goto cleanup1; + /* Did the daemon send a cancellation message? */ + if (r == -2) { + if (g->verbose) + fprintf (stderr, "got daemon cancellation\n"); + return -2; } + if (r == -1) + goto cleanup1; + + free (msg_out); + return 0; cleanup1: - free (g->msg_out); - g->msg_out = NULL; - g->msg_out_size = 0; + free (msg_out); return -1; } -/* At this point we are sending FileIn file(s) to the guest, and not - * expecting to read anything, so if we do read anything, it must be - * a cancellation message. This checks for this case without blocking. - */ -static int -check_for_daemon_cancellation (guestfs_h *g) +/* Receive a reply. */ +int +guestfs___recv (guestfs_h *g, const char *fn, + guestfs_message_header *hdr, + guestfs_message_error *err, + xdrproc_t xdrp, char *ret) { - fd_set rset; - struct timeval tv; - int r; - char buf[4]; - uint32_t flag; XDR xdr; + void *buf; + uint32_t size; + int r; - FD_ZERO (&rset); - FD_SET (g->sock, &rset); - tv.tv_sec = 0; - tv.tv_usec = 0; - r = select (g->sock+1, &rset, NULL, NULL, &tv); - if (r == -1) { - perrorf (g, "select"); - return 0; - } - if (r == 0) - return 0; + again: + r = recv_from_daemon (g, &size, &buf); + if (r == -1) + return -1; - /* Read the message from the daemon. */ - r = xread (g->sock, buf, sizeof buf); - if (r == -1) { - perrorf (g, "read"); - return 0; + /* This can happen if a cancellation happens right at the end + * of us sending a FileIn parameter to the daemon. Discard. The + * daemon should send us an error message next. + */ + if (size == GUESTFS_CANCEL_FLAG) + goto again; + + if (size == GUESTFS_LAUNCH_FLAG) { + error (g, "%s: received unexpected launch flag from daemon when expecting reply", fn); + return -1; } - xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE); - xdr_uint32_t (&xdr, &flag); - xdr_destroy (&xdr); + xdrmem_create (&xdr, buf, size, XDR_DECODE); - if (flag != GUESTFS_CANCEL_FLAG) { - error (g, _("check_for_daemon_cancellation: read 0x%x from daemon, expected 0x%x\n"), - flag, GUESTFS_CANCEL_FLAG); - return 0; + if (!xdr_guestfs_message_header (&xdr, hdr)) { + error (g, "%s: failed to parse reply header", fn); + xdr_destroy (&xdr); + free (buf); + return -1; } + if (hdr->status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (&xdr, err)) { + error (g, "%s: failed to parse reply error", fn); + xdr_destroy (&xdr); + free (buf); + return -1; + } + } else { + if (xdrp && ret && !xdrp (&xdr, ret)) { + error (g, "%s: failed to parse reply", fn); + xdr_destroy (&xdr); + free (buf); + return -1; + } + } + xdr_destroy (&xdr); + free (buf); - return 1; + return 0; } -/* Synchronously receive a file. */ +/* Receive a file. */ -/* Returns -1 = error, 0 = EOF, 1 = more data */ -static int receive_file_data_sync (guestfs_h *g, void **buf, size_t *len); +/* Returns -1 = error, 0 = EOF, > 0 = more data */ +static ssize_t receive_file_data (guestfs_h *g, void **buf); int -guestfs__receive_file_sync (guestfs_h *g, const char *filename) +guestfs___recv_file (guestfs_h *g, const char *filename) { void *buf; int fd, r; @@ -2388,14 +2229,13 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename) } /* Receive the file in chunked encoding. */ - while ((r = receive_file_data_sync (g, &buf, &len)) >= 0) { - if (xwrite (fd, buf, len) == -1) { + while ((r = receive_file_data (g, &buf)) > 0) { + if (xwrite (fd, buf, r) == -1) { perrorf (g, "%s: write", filename); free (buf); goto cancel; } free (buf); - if (r == 0) break; /* End of file. */ } if (r == -1) { @@ -2431,304 +2271,59 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename) return -1; } - while (receive_file_data_sync (g, NULL, NULL) > 0) - ; /* just discard it */ + while (receive_file_data (g, 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 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")); - free_chunks (ctx); - ctx->chunks = NULL; - ctx->count = -1; - return; - } - - /* 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, size_t *len_r) -{ - struct receive_file_ctx ctx; - guestfs_main_loop *ml = guestfs_get_main_loop (g); - int i; - size_t len; - - 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 (ctx.count == 0) { - error (g, _("receive_file_data_sync: reply callback not called\n")); - return -1; - } - - if (ctx.count == -1) { - error (g, _("receive_file_data_sync: parse error in reply callback\n")); - /* callback already freed the chunks */ - return -1; - } - - 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 (((char *)*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). */ - -static int -select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events, - guestfs_handle_event_cb cb, void *data) +/* Returns -1 = error, 0 = EOF, > 0 = more data */ +static ssize_t +receive_file_data (guestfs_h *g, void **buf_r) { - struct select_main_loop *ml = (struct select_main_loop *) mlv; - - if (fd < 0 || fd >= FD_SETSIZE) { - error (g, _("fd %d is out of range"), fd); - return -1; - } - - if ((events & ~(GUESTFS_HANDLE_READABLE | - GUESTFS_HANDLE_WRITABLE | - GUESTFS_HANDLE_HANGUP | - GUESTFS_HANDLE_ERROR)) != 0) { - error (g, _("set of events (0x%x) contains unknown events"), events); - return -1; - } - - if (events == 0) { - error (g, _("set of events is empty")); - return -1; - } + int r; + void *buf; + uint32_t len; + XDR xdr; + guestfs_chunk chunk; - if (FD_ISSET (fd, &ml->rset) || - FD_ISSET (fd, &ml->wset) || - FD_ISSET (fd, &ml->xset)) { - error (g, _("fd %d is already registered"), fd); + r = recv_from_daemon (g, &len, &buf); + if (r == -1) { + error (g, _("receive_file_data: parse error in reply callback")); return -1; } - if (cb == NULL) { - error (g, _("callback is NULL")); + if (len == GUESTFS_LAUNCH_FLAG || len == GUESTFS_CANCEL_FLAG) { + error (g, _("receive_file_data: unexpected flag received when reading file chunks")); return -1; } - if ((events & GUESTFS_HANDLE_READABLE)) - FD_SET (fd, &ml->rset); - if ((events & GUESTFS_HANDLE_WRITABLE)) - FD_SET (fd, &ml->wset); - if ((events & GUESTFS_HANDLE_HANGUP) || (events & GUESTFS_HANDLE_ERROR)) - FD_SET (fd, &ml->xset); - - if (fd > ml->max_fd) { - ml->max_fd = fd; - ml->handle_cb_data = - safe_realloc (g, ml->handle_cb_data, - sizeof (struct select_handle_cb_data) * (ml->max_fd+1)); - } - ml->handle_cb_data[fd].cb = cb; - ml->handle_cb_data[fd].g = g; - ml->handle_cb_data[fd].data = data; - - ml->nr_fds++; - - /* Any integer >= 0 can be the handle, and this is as good as any ... */ - return fd; -} - -static int -select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd) -{ - struct select_main_loop *ml = (struct select_main_loop *) mlv; - - if (fd < 0 || fd >= FD_SETSIZE) { - error (g, _("fd %d is out of range"), fd); - return -1; - } + memset (&chunk, 0, sizeof chunk); - if (!FD_ISSET (fd, &ml->rset) && - !FD_ISSET (fd, &ml->wset) && - !FD_ISSET (fd, &ml->xset)) { - error (g, _("fd %d was not registered"), fd); + xdrmem_create (&xdr, buf, len, XDR_DECODE); + if (!xdr_guestfs_chunk (&xdr, &chunk)) { + error (g, _("failed to parse file chunk")); + free (buf); return -1; } + xdr_destroy (&xdr); + /* After decoding, the original buffer is no longer used. */ + free (buf); - FD_CLR (fd, &ml->rset); - FD_CLR (fd, &ml->wset); - FD_CLR (fd, &ml->xset); - - if (fd == ml->max_fd) { - ml->max_fd--; - ml->handle_cb_data = - safe_realloc (g, ml->handle_cb_data, - sizeof (struct select_handle_cb_data) * (ml->max_fd+1)); - } - - ml->nr_fds--; - - return 0; -} - -static int -__attribute__((noreturn)) -select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval, - guestfs_handle_timeout_cb cb, void *data) -{ - //struct select_main_loop *ml = (struct select_main_loop *) mlv; - - abort (); /* XXX not implemented yet */ -} - -static int -__attribute__((noreturn)) -select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer) -{ - //struct select_main_loop *ml = (struct select_main_loop *) mlv; - - abort (); /* XXX not implemented yet */ -} - -/* The 'g' parameter is just used for error reporting. Events - * for multiple handles can be dispatched by running the main - * loop. - */ -static int -select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g) -{ - struct select_main_loop *ml = (struct select_main_loop *) mlv; - int fd, r, events; - fd_set rset2, wset2, xset2; - - if (ml->is_running) { - error (g, _("select_main_loop_run: this cannot be called recursively")); + if (chunk.cancel) { + error (g, _("file receive cancelled by daemon")); + free (chunk.data.data_val); return -1; } - ml->is_running = 1; - - while (ml->is_running) { - if (ml->nr_fds == 0) - break; - - rset2 = ml->rset; - wset2 = ml->wset; - xset2 = ml->xset; - r = select (ml->max_fd+1, &rset2, &wset2, &xset2, NULL); - if (r == -1) { - if (errno == EINTR || errno == EAGAIN) - continue; - perrorf (g, "select"); - ml->is_running = 0; - return -1; - } - - for (fd = 0; r > 0 && fd <= ml->max_fd; ++fd) { - events = 0; - if (FD_ISSET (fd, &rset2)) - events |= GUESTFS_HANDLE_READABLE; - if (FD_ISSET (fd, &wset2)) - events |= GUESTFS_HANDLE_WRITABLE; - if (FD_ISSET (fd, &xset2)) - events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP; - if (events) { - r--; - ml->handle_cb_data[fd].cb ((guestfs_main_loop *) ml, - ml->handle_cb_data[fd].g, - ml->handle_cb_data[fd].data, - fd, fd, events); - } - } + if (chunk.data.data_len == 0) { /* end of transfer */ + free (chunk.data.data_val); + return 0; } - ml->is_running = 0; - return 0; -} - -static int -select_main_loop_quit (guestfs_main_loop *mlv, guestfs_h *g) -{ - struct select_main_loop *ml = (struct select_main_loop *) mlv; + if (buf_r) *buf_r = chunk.data.data_val; + else free (chunk.data.data_val); /* else caller frees */ - /* Note that legitimately ml->is_running can be zero when - * this function is called. - */ - - ml->is_running = 0; - return 0; + return chunk.data.data_len; } diff --git a/src/guestfs.h b/src/guestfs.h index 6412a53..35f995d 100644 --- a/src/guestfs.h +++ b/src/guestfs.h @@ -31,7 +31,6 @@ extern "C" { #endif typedef struct guestfs_h guestfs_h; -typedef struct guestfs_main_loop guestfs_main_loop; /* Connection management. */ extern guestfs_h *guestfs_create (void); @@ -52,19 +51,18 @@ extern guestfs_abort_cb guestfs_get_out_of_memory_handler (guestfs_h *g); #include #include -/* Low-level event API. */ -typedef void (*guestfs_send_cb) (guestfs_h *g, void *data); -typedef void (*guestfs_reply_cb) (guestfs_h *g, void *data, XDR *xdr); +/* Events. */ typedef void (*guestfs_log_message_cb) (guestfs_h *g, void *data, char *buf, int len); typedef void (*guestfs_subprocess_quit_cb) (guestfs_h *g, void *data); typedef void (*guestfs_launch_done_cb) (guestfs_h *g, void *data); -extern void guestfs_set_send_callback (guestfs_h *g, guestfs_send_cb cb, void *opaque); -extern void guestfs_set_reply_callback (guestfs_h *g, guestfs_reply_cb cb, void *opaque); extern void guestfs_set_log_message_callback (guestfs_h *g, guestfs_log_message_cb cb, void *opaque); extern void guestfs_set_subprocess_quit_callback (guestfs_h *g, guestfs_subprocess_quit_cb cb, void *opaque); extern void guestfs_set_launch_done_callback (guestfs_h *g, guestfs_launch_done_cb cb, void *opaque); +/* Private, for use only by the actions. */ +struct guestfs_message_header; +struct guestfs_message_error; extern void guestfs_error (guestfs_h *g, const char *fs, ...) __attribute__((format (printf,2,3))); extern void guestfs_perrorf (guestfs_h *g, const char *fs, ...) @@ -74,50 +72,12 @@ extern void *guestfs_safe_calloc (guestfs_h *g, size_t n, size_t s); extern void *guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes); extern char *guestfs_safe_strdup (guestfs_h *g, const char *str); extern void *guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size); - -extern int guestfs__switch_to_sending (guestfs_h *g); -extern int guestfs__switch_to_receiving (guestfs_h *g); - -/* These *_sync calls wait until the action is performed, using the - * main loop. We should implement asynchronous versions too. - */ -extern int guestfs__send_sync (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args); -extern int guestfs__send_file_sync (guestfs_h *g, const char *filename); -extern int guestfs__receive_file_sync (guestfs_h *g, const char *filename); - -/* Main loop. */ -#define GUESTFS_HANDLE_READABLE 0x1 -#define GUESTFS_HANDLE_WRITABLE 0x2 -#define GUESTFS_HANDLE_HANGUP 0x4 -#define GUESTFS_HANDLE_ERROR 0x8 - -typedef void (*guestfs_handle_event_cb) (guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); -typedef int (*guestfs_add_handle_cb) (guestfs_main_loop *ml, guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data); -typedef int (*guestfs_remove_handle_cb) (guestfs_main_loop *ml, guestfs_h *g, int watch); -typedef void (*guestfs_handle_timeout_cb) (guestfs_main_loop *ml, guestfs_h *g, void *data, int timer); -typedef int (*guestfs_add_timeout_cb) (guestfs_main_loop *ml, guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data); -typedef int (*guestfs_remove_timeout_cb) (guestfs_main_loop *ml, guestfs_h *g, int timer); -typedef int (*guestfs_main_loop_run_cb) (guestfs_main_loop *ml, guestfs_h *g); -typedef int (*guestfs_main_loop_quit_cb) (guestfs_main_loop *ml, guestfs_h *g); - -/* This is the head of the main loop structure. Concrete implementations - * use additional private data after this struct. - */ -struct guestfs_main_loop { - guestfs_add_handle_cb add_handle; - guestfs_remove_handle_cb remove_handle; - guestfs_add_timeout_cb add_timeout; - guestfs_remove_timeout_cb remove_timeout; - guestfs_main_loop_run_cb main_loop_run; - guestfs_main_loop_quit_cb main_loop_quit; -}; - -extern void guestfs_set_main_loop (guestfs_h *handle, guestfs_main_loop *main_loop); -extern guestfs_main_loop *guestfs_get_main_loop (guestfs_h *handle); -extern guestfs_main_loop *guestfs_get_default_main_loop (void); - -extern guestfs_main_loop *guestfs_create_main_loop (void); -extern void guestfs_free_main_loop (guestfs_main_loop *); +extern int guestfs___set_busy (guestfs_h *g); +extern int guestfs___end_busy (guestfs_h *g); +extern int guestfs___send (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args); +extern int guestfs___recv (guestfs_h *g, const char *fn, struct guestfs_message_header *hdr, struct guestfs_message_error *err, xdrproc_t xdrp, char *ret); +extern int guestfs___send_file (guestfs_h *g, const char *filename); +extern int guestfs___recv_file (guestfs_h *g, const char *filename); #ifdef __cplusplus }