X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=daemon%2Fstubs.c;h=48f16c2881a51c3db6139902aebbcb4726bf7675;hb=f850e1f065fb04df7cc87a921ab3c658741cc393;hp=dba086304f8626a6235f07802a241911f01743d3;hpb=0574eab8bc7d8e72db862ec36815835938a5fdf1;p=libguestfs.git diff --git a/daemon/stubs.c b/daemon/stubs.c index dba0863..48f16c2 100644 --- a/daemon/stubs.c +++ b/daemon/stubs.c @@ -2450,7 +2450,7 @@ static void sfdisk_N_stub (XDR *xdr_in) int r; struct guestfs_sfdisk_N_args args; char *device; - int n; + int partnum; int cyls; int heads; int sectors; @@ -2463,13 +2463,13 @@ static void sfdisk_N_stub (XDR *xdr_in) return; } device = args.device; - n = args.n; + partnum = args.partnum; cyls = args.cyls; heads = args.heads; sectors = args.sectors; line = args.line; - r = do_sfdisk_N (device, n, cyls, heads, sectors, line); + r = do_sfdisk_N (device, partnum, cyls, heads, sectors, line); if (r == -1) /* do_sfdisk_N has already called reply_with_error */ goto done; @@ -2953,6 +2953,388 @@ done: xdr_free ((xdrproc_t) xdr_guestfs_mkdtemp_args, (char *) &args); } +static void wc_l_stub (XDR *xdr_in) +{ + int r; + struct guestfs_wc_l_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_wc_l_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "wc_l"); + return; + } + path = args.path; + + r = do_wc_l (path); + if (r == -1) + /* do_wc_l has already called reply_with_error */ + goto done; + + struct guestfs_wc_l_ret ret; + ret.lines = r; + reply ((xdrproc_t) &xdr_guestfs_wc_l_ret, (char *) &ret); +done: + xdr_free ((xdrproc_t) xdr_guestfs_wc_l_args, (char *) &args); +} + +static void wc_w_stub (XDR *xdr_in) +{ + int r; + struct guestfs_wc_w_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_wc_w_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "wc_w"); + return; + } + path = args.path; + + r = do_wc_w (path); + if (r == -1) + /* do_wc_w has already called reply_with_error */ + goto done; + + struct guestfs_wc_w_ret ret; + ret.words = r; + reply ((xdrproc_t) &xdr_guestfs_wc_w_ret, (char *) &ret); +done: + xdr_free ((xdrproc_t) xdr_guestfs_wc_w_args, (char *) &args); +} + +static void wc_c_stub (XDR *xdr_in) +{ + int r; + struct guestfs_wc_c_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_wc_c_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "wc_c"); + return; + } + path = args.path; + + r = do_wc_c (path); + if (r == -1) + /* do_wc_c has already called reply_with_error */ + goto done; + + struct guestfs_wc_c_ret ret; + ret.chars = r; + reply ((xdrproc_t) &xdr_guestfs_wc_c_ret, (char *) &ret); +done: + xdr_free ((xdrproc_t) xdr_guestfs_wc_c_args, (char *) &args); +} + +static void head_stub (XDR *xdr_in) +{ + char **r; + struct guestfs_head_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_head_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "head"); + return; + } + path = args.path; + + r = do_head (path); + if (r == NULL) + /* do_head has already called reply_with_error */ + goto done; + + struct guestfs_head_ret ret; + ret.lines.lines_len = count_strings (r); + ret.lines.lines_val = r; + reply ((xdrproc_t) &xdr_guestfs_head_ret, (char *) &ret); + free_strings (r); +done: + xdr_free ((xdrproc_t) xdr_guestfs_head_args, (char *) &args); +} + +static void head_n_stub (XDR *xdr_in) +{ + char **r; + struct guestfs_head_n_args args; + int nrlines; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_head_n_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "head_n"); + return; + } + nrlines = args.nrlines; + path = args.path; + + r = do_head_n (nrlines, path); + if (r == NULL) + /* do_head_n has already called reply_with_error */ + goto done; + + struct guestfs_head_n_ret ret; + ret.lines.lines_len = count_strings (r); + ret.lines.lines_val = r; + reply ((xdrproc_t) &xdr_guestfs_head_n_ret, (char *) &ret); + free_strings (r); +done: + xdr_free ((xdrproc_t) xdr_guestfs_head_n_args, (char *) &args); +} + +static void tail_stub (XDR *xdr_in) +{ + char **r; + struct guestfs_tail_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_tail_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "tail"); + return; + } + path = args.path; + + r = do_tail (path); + if (r == NULL) + /* do_tail has already called reply_with_error */ + goto done; + + struct guestfs_tail_ret ret; + ret.lines.lines_len = count_strings (r); + ret.lines.lines_val = r; + reply ((xdrproc_t) &xdr_guestfs_tail_ret, (char *) &ret); + free_strings (r); +done: + xdr_free ((xdrproc_t) xdr_guestfs_tail_args, (char *) &args); +} + +static void tail_n_stub (XDR *xdr_in) +{ + char **r; + struct guestfs_tail_n_args args; + int nrlines; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_tail_n_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "tail_n"); + return; + } + nrlines = args.nrlines; + path = args.path; + + r = do_tail_n (nrlines, path); + if (r == NULL) + /* do_tail_n has already called reply_with_error */ + goto done; + + struct guestfs_tail_n_ret ret; + ret.lines.lines_len = count_strings (r); + ret.lines.lines_val = r; + reply ((xdrproc_t) &xdr_guestfs_tail_n_ret, (char *) &ret); + free_strings (r); +done: + xdr_free ((xdrproc_t) xdr_guestfs_tail_n_args, (char *) &args); +} + +static void df_stub (XDR *xdr_in) +{ + char *r; + + r = do_df (); + if (r == NULL) + /* do_df has already called reply_with_error */ + goto done; + + struct guestfs_df_ret ret; + ret.output = r; + reply ((xdrproc_t) &xdr_guestfs_df_ret, (char *) &ret); + free (r); +done: ; +} + +static void df_h_stub (XDR *xdr_in) +{ + char *r; + + r = do_df_h (); + if (r == NULL) + /* do_df_h has already called reply_with_error */ + goto done; + + struct guestfs_df_h_ret ret; + ret.output = r; + reply ((xdrproc_t) &xdr_guestfs_df_h_ret, (char *) &ret); + free (r); +done: ; +} + +static void du_stub (XDR *xdr_in) +{ + int64_t r; + struct guestfs_du_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_du_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "du"); + return; + } + path = args.path; + + r = do_du (path); + if (r == -1) + /* do_du has already called reply_with_error */ + goto done; + + struct guestfs_du_ret ret; + ret.sizekb = r; + reply ((xdrproc_t) &xdr_guestfs_du_ret, (char *) &ret); +done: + xdr_free ((xdrproc_t) xdr_guestfs_du_args, (char *) &args); +} + +static void initrd_list_stub (XDR *xdr_in) +{ + char **r; + struct guestfs_initrd_list_args args; + char *path; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_initrd_list_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "initrd_list"); + return; + } + path = args.path; + + r = do_initrd_list (path); + if (r == NULL) + /* do_initrd_list has already called reply_with_error */ + goto done; + + struct guestfs_initrd_list_ret ret; + ret.filenames.filenames_len = count_strings (r); + ret.filenames.filenames_val = r; + reply ((xdrproc_t) &xdr_guestfs_initrd_list_ret, (char *) &ret); + free_strings (r); +done: + xdr_free ((xdrproc_t) xdr_guestfs_initrd_list_args, (char *) &args); +} + +static void mount_loop_stub (XDR *xdr_in) +{ + int r; + struct guestfs_mount_loop_args args; + char *file; + char *mountpoint; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_mount_loop_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "mount_loop"); + return; + } + file = args.file; + mountpoint = args.mountpoint; + + r = do_mount_loop (file, mountpoint); + if (r == -1) + /* do_mount_loop has already called reply_with_error */ + goto done; + + reply (NULL, NULL); +done: + xdr_free ((xdrproc_t) xdr_guestfs_mount_loop_args, (char *) &args); +} + +static void mkswap_stub (XDR *xdr_in) +{ + int r; + struct guestfs_mkswap_args args; + char *device; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_mkswap_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "mkswap"); + return; + } + device = args.device; + + r = do_mkswap (device); + if (r == -1) + /* do_mkswap has already called reply_with_error */ + goto done; + + reply (NULL, NULL); +done: + xdr_free ((xdrproc_t) xdr_guestfs_mkswap_args, (char *) &args); +} + +static void mkswap_L_stub (XDR *xdr_in) +{ + int r; + struct guestfs_mkswap_L_args args; + char *label; + char *device; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_mkswap_L_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "mkswap_L"); + return; + } + label = args.label; + device = args.device; + + r = do_mkswap_L (label, device); + if (r == -1) + /* do_mkswap_L has already called reply_with_error */ + goto done; + + reply (NULL, NULL); +done: + xdr_free ((xdrproc_t) xdr_guestfs_mkswap_L_args, (char *) &args); +} + +static void mkswap_U_stub (XDR *xdr_in) +{ + int r; + struct guestfs_mkswap_U_args args; + char *uuid; + char *device; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_mkswap_U_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "mkswap_U"); + return; + } + uuid = args.uuid; + device = args.device; + + r = do_mkswap_U (uuid, device); + if (r == -1) + /* do_mkswap_U has already called reply_with_error */ + goto done; + + reply (NULL, NULL); +done: + xdr_free ((xdrproc_t) xdr_guestfs_mkswap_U_args, (char *) &args); +} + void dispatch_incoming_message (XDR *xdr_in) { switch (proc_nr) { @@ -3307,6 +3689,51 @@ void dispatch_incoming_message (XDR *xdr_in) case GUESTFS_PROC_MKDTEMP: mkdtemp_stub (xdr_in); break; + case GUESTFS_PROC_WC_L: + wc_l_stub (xdr_in); + break; + case GUESTFS_PROC_WC_W: + wc_w_stub (xdr_in); + break; + case GUESTFS_PROC_WC_C: + wc_c_stub (xdr_in); + break; + case GUESTFS_PROC_HEAD: + head_stub (xdr_in); + break; + case GUESTFS_PROC_HEAD_N: + head_n_stub (xdr_in); + break; + case GUESTFS_PROC_TAIL: + tail_stub (xdr_in); + break; + case GUESTFS_PROC_TAIL_N: + tail_n_stub (xdr_in); + break; + case GUESTFS_PROC_DF: + df_stub (xdr_in); + break; + case GUESTFS_PROC_DF_H: + df_h_stub (xdr_in); + break; + case GUESTFS_PROC_DU: + du_stub (xdr_in); + break; + case GUESTFS_PROC_INITRD_LIST: + initrd_list_stub (xdr_in); + break; + case GUESTFS_PROC_MOUNT_LOOP: + mount_loop_stub (xdr_in); + break; + case GUESTFS_PROC_MKSWAP: + mkswap_stub (xdr_in); + break; + case GUESTFS_PROC_MKSWAP_L: + mkswap_L_stub (xdr_in); + break; + case GUESTFS_PROC_MKSWAP_U: + mkswap_U_stub (xdr_in); + break; default: reply_with_error ("dispatch_incoming_message: unknown procedure number %d, set LIBGUESTFS_PATH to point to the matching libguestfs appliance directory", proc_nr); }