37c74da49c9ef5c8c574ad36b300817bb9cb2046
[libguestfs.git] / src / guestfs_protocol.c
1 /*
2  * Please do not edit this file.
3  * It was generated using rpcgen.
4  */
5
6 #include "guestfs_protocol.h"
7
8 bool_t
9 xdr_str (XDR *xdrs, str *objp)
10 {
11         register int32_t *buf;
12
13          if (!xdr_string (xdrs, objp, ~0))
14                  return FALSE;
15         return TRUE;
16 }
17
18 bool_t
19 xdr_guestfs_lvm_int_pv (XDR *xdrs, guestfs_lvm_int_pv *objp)
20 {
21         register int32_t *buf;
22
23         int i;
24          if (!xdr_string (xdrs, &objp->pv_name, ~0))
25                  return FALSE;
26          if (!xdr_opaque (xdrs, objp->pv_uuid, 32))
27                  return FALSE;
28          if (!xdr_string (xdrs, &objp->pv_fmt, ~0))
29                  return FALSE;
30          if (!xdr_quad_t (xdrs, &objp->pv_size))
31                  return FALSE;
32          if (!xdr_quad_t (xdrs, &objp->dev_size))
33                  return FALSE;
34          if (!xdr_quad_t (xdrs, &objp->pv_free))
35                  return FALSE;
36          if (!xdr_quad_t (xdrs, &objp->pv_used))
37                  return FALSE;
38          if (!xdr_string (xdrs, &objp->pv_attr, ~0))
39                  return FALSE;
40          if (!xdr_quad_t (xdrs, &objp->pv_pe_count))
41                  return FALSE;
42          if (!xdr_quad_t (xdrs, &objp->pv_pe_alloc_count))
43                  return FALSE;
44          if (!xdr_string (xdrs, &objp->pv_tags, ~0))
45                  return FALSE;
46          if (!xdr_quad_t (xdrs, &objp->pe_start))
47                  return FALSE;
48          if (!xdr_quad_t (xdrs, &objp->pv_mda_count))
49                  return FALSE;
50          if (!xdr_quad_t (xdrs, &objp->pv_mda_free))
51                  return FALSE;
52         return TRUE;
53 }
54
55 bool_t
56 xdr_guestfs_lvm_int_pv_list (XDR *xdrs, guestfs_lvm_int_pv_list *objp)
57 {
58         register int32_t *buf;
59
60          if (!xdr_array (xdrs, (char **)&objp->guestfs_lvm_int_pv_list_val, (u_int *) &objp->guestfs_lvm_int_pv_list_len, ~0,
61                 sizeof (guestfs_lvm_int_pv), (xdrproc_t) xdr_guestfs_lvm_int_pv))
62                  return FALSE;
63         return TRUE;
64 }
65
66 bool_t
67 xdr_guestfs_lvm_int_vg (XDR *xdrs, guestfs_lvm_int_vg *objp)
68 {
69         register int32_t *buf;
70
71         int i;
72          if (!xdr_string (xdrs, &objp->vg_name, ~0))
73                  return FALSE;
74          if (!xdr_opaque (xdrs, objp->vg_uuid, 32))
75                  return FALSE;
76          if (!xdr_string (xdrs, &objp->vg_fmt, ~0))
77                  return FALSE;
78          if (!xdr_string (xdrs, &objp->vg_attr, ~0))
79                  return FALSE;
80          if (!xdr_quad_t (xdrs, &objp->vg_size))
81                  return FALSE;
82          if (!xdr_quad_t (xdrs, &objp->vg_free))
83                  return FALSE;
84          if (!xdr_string (xdrs, &objp->vg_sysid, ~0))
85                  return FALSE;
86          if (!xdr_quad_t (xdrs, &objp->vg_extent_size))
87                  return FALSE;
88          if (!xdr_quad_t (xdrs, &objp->vg_extent_count))
89                  return FALSE;
90          if (!xdr_quad_t (xdrs, &objp->vg_free_count))
91                  return FALSE;
92          if (!xdr_quad_t (xdrs, &objp->max_lv))
93                  return FALSE;
94          if (!xdr_quad_t (xdrs, &objp->max_pv))
95                  return FALSE;
96          if (!xdr_quad_t (xdrs, &objp->pv_count))
97                  return FALSE;
98          if (!xdr_quad_t (xdrs, &objp->lv_count))
99                  return FALSE;
100          if (!xdr_quad_t (xdrs, &objp->snap_count))
101                  return FALSE;
102          if (!xdr_quad_t (xdrs, &objp->vg_seqno))
103                  return FALSE;
104          if (!xdr_string (xdrs, &objp->vg_tags, ~0))
105                  return FALSE;
106          if (!xdr_quad_t (xdrs, &objp->vg_mda_count))
107                  return FALSE;
108          if (!xdr_quad_t (xdrs, &objp->vg_mda_free))
109                  return FALSE;
110         return TRUE;
111 }
112
113 bool_t
114 xdr_guestfs_lvm_int_vg_list (XDR *xdrs, guestfs_lvm_int_vg_list *objp)
115 {
116         register int32_t *buf;
117
118          if (!xdr_array (xdrs, (char **)&objp->guestfs_lvm_int_vg_list_val, (u_int *) &objp->guestfs_lvm_int_vg_list_len, ~0,
119                 sizeof (guestfs_lvm_int_vg), (xdrproc_t) xdr_guestfs_lvm_int_vg))
120                  return FALSE;
121         return TRUE;
122 }
123
124 bool_t
125 xdr_guestfs_lvm_int_lv (XDR *xdrs, guestfs_lvm_int_lv *objp)
126 {
127         register int32_t *buf;
128
129         int i;
130          if (!xdr_string (xdrs, &objp->lv_name, ~0))
131                  return FALSE;
132          if (!xdr_opaque (xdrs, objp->lv_uuid, 32))
133                  return FALSE;
134          if (!xdr_string (xdrs, &objp->lv_attr, ~0))
135                  return FALSE;
136          if (!xdr_quad_t (xdrs, &objp->lv_major))
137                  return FALSE;
138          if (!xdr_quad_t (xdrs, &objp->lv_minor))
139                  return FALSE;
140          if (!xdr_quad_t (xdrs, &objp->lv_kernel_major))
141                  return FALSE;
142          if (!xdr_quad_t (xdrs, &objp->lv_kernel_minor))
143                  return FALSE;
144          if (!xdr_quad_t (xdrs, &objp->lv_size))
145                  return FALSE;
146          if (!xdr_quad_t (xdrs, &objp->seg_count))
147                  return FALSE;
148          if (!xdr_string (xdrs, &objp->origin, ~0))
149                  return FALSE;
150          if (!xdr_float (xdrs, &objp->snap_percent))
151                  return FALSE;
152          if (!xdr_float (xdrs, &objp->copy_percent))
153                  return FALSE;
154          if (!xdr_string (xdrs, &objp->move_pv, ~0))
155                  return FALSE;
156          if (!xdr_string (xdrs, &objp->lv_tags, ~0))
157                  return FALSE;
158          if (!xdr_string (xdrs, &objp->mirror_log, ~0))
159                  return FALSE;
160          if (!xdr_string (xdrs, &objp->modules, ~0))
161                  return FALSE;
162         return TRUE;
163 }
164
165 bool_t
166 xdr_guestfs_lvm_int_lv_list (XDR *xdrs, guestfs_lvm_int_lv_list *objp)
167 {
168         register int32_t *buf;
169
170          if (!xdr_array (xdrs, (char **)&objp->guestfs_lvm_int_lv_list_val, (u_int *) &objp->guestfs_lvm_int_lv_list_len, ~0,
171                 sizeof (guestfs_lvm_int_lv), (xdrproc_t) xdr_guestfs_lvm_int_lv))
172                  return FALSE;
173         return TRUE;
174 }
175
176 bool_t
177 xdr_guestfs_int_stat (XDR *xdrs, guestfs_int_stat *objp)
178 {
179         register int32_t *buf;
180
181          if (!xdr_quad_t (xdrs, &objp->dev))
182                  return FALSE;
183          if (!xdr_quad_t (xdrs, &objp->ino))
184                  return FALSE;
185          if (!xdr_quad_t (xdrs, &objp->mode))
186                  return FALSE;
187          if (!xdr_quad_t (xdrs, &objp->nlink))
188                  return FALSE;
189          if (!xdr_quad_t (xdrs, &objp->uid))
190                  return FALSE;
191          if (!xdr_quad_t (xdrs, &objp->gid))
192                  return FALSE;
193          if (!xdr_quad_t (xdrs, &objp->rdev))
194                  return FALSE;
195          if (!xdr_quad_t (xdrs, &objp->size))
196                  return FALSE;
197          if (!xdr_quad_t (xdrs, &objp->blksize))
198                  return FALSE;
199          if (!xdr_quad_t (xdrs, &objp->blocks))
200                  return FALSE;
201          if (!xdr_quad_t (xdrs, &objp->atime))
202                  return FALSE;
203          if (!xdr_quad_t (xdrs, &objp->mtime))
204                  return FALSE;
205          if (!xdr_quad_t (xdrs, &objp->ctime))
206                  return FALSE;
207         return TRUE;
208 }
209
210 bool_t
211 xdr_guestfs_int_statvfs (XDR *xdrs, guestfs_int_statvfs *objp)
212 {
213         register int32_t *buf;
214
215          if (!xdr_quad_t (xdrs, &objp->bsize))
216                  return FALSE;
217          if (!xdr_quad_t (xdrs, &objp->frsize))
218                  return FALSE;
219          if (!xdr_quad_t (xdrs, &objp->blocks))
220                  return FALSE;
221          if (!xdr_quad_t (xdrs, &objp->bfree))
222                  return FALSE;
223          if (!xdr_quad_t (xdrs, &objp->bavail))
224                  return FALSE;
225          if (!xdr_quad_t (xdrs, &objp->files))
226                  return FALSE;
227          if (!xdr_quad_t (xdrs, &objp->ffree))
228                  return FALSE;
229          if (!xdr_quad_t (xdrs, &objp->favail))
230                  return FALSE;
231          if (!xdr_quad_t (xdrs, &objp->fsid))
232                  return FALSE;
233          if (!xdr_quad_t (xdrs, &objp->flag))
234                  return FALSE;
235          if (!xdr_quad_t (xdrs, &objp->namemax))
236                  return FALSE;
237         return TRUE;
238 }
239
240 bool_t
241 xdr_guestfs_mount_args (XDR *xdrs, guestfs_mount_args *objp)
242 {
243         register int32_t *buf;
244
245          if (!xdr_string (xdrs, &objp->device, ~0))
246                  return FALSE;
247          if (!xdr_string (xdrs, &objp->mountpoint, ~0))
248                  return FALSE;
249         return TRUE;
250 }
251
252 bool_t
253 xdr_guestfs_touch_args (XDR *xdrs, guestfs_touch_args *objp)
254 {
255         register int32_t *buf;
256
257          if (!xdr_string (xdrs, &objp->path, ~0))
258                  return FALSE;
259         return TRUE;
260 }
261
262 bool_t
263 xdr_guestfs_cat_args (XDR *xdrs, guestfs_cat_args *objp)
264 {
265         register int32_t *buf;
266
267          if (!xdr_string (xdrs, &objp->path, ~0))
268                  return FALSE;
269         return TRUE;
270 }
271
272 bool_t
273 xdr_guestfs_cat_ret (XDR *xdrs, guestfs_cat_ret *objp)
274 {
275         register int32_t *buf;
276
277          if (!xdr_string (xdrs, &objp->content, ~0))
278                  return FALSE;
279         return TRUE;
280 }
281
282 bool_t
283 xdr_guestfs_ll_args (XDR *xdrs, guestfs_ll_args *objp)
284 {
285         register int32_t *buf;
286
287          if (!xdr_string (xdrs, &objp->directory, ~0))
288                  return FALSE;
289         return TRUE;
290 }
291
292 bool_t
293 xdr_guestfs_ll_ret (XDR *xdrs, guestfs_ll_ret *objp)
294 {
295         register int32_t *buf;
296
297          if (!xdr_string (xdrs, &objp->listing, ~0))
298                  return FALSE;
299         return TRUE;
300 }
301
302 bool_t
303 xdr_guestfs_ls_args (XDR *xdrs, guestfs_ls_args *objp)
304 {
305         register int32_t *buf;
306
307          if (!xdr_string (xdrs, &objp->directory, ~0))
308                  return FALSE;
309         return TRUE;
310 }
311
312 bool_t
313 xdr_guestfs_ls_ret (XDR *xdrs, guestfs_ls_ret *objp)
314 {
315         register int32_t *buf;
316
317          if (!xdr_array (xdrs, (char **)&objp->listing.listing_val, (u_int *) &objp->listing.listing_len, ~0,
318                 sizeof (str), (xdrproc_t) xdr_str))
319                  return FALSE;
320         return TRUE;
321 }
322
323 bool_t
324 xdr_guestfs_list_devices_ret (XDR *xdrs, guestfs_list_devices_ret *objp)
325 {
326         register int32_t *buf;
327
328          if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
329                 sizeof (str), (xdrproc_t) xdr_str))
330                  return FALSE;
331         return TRUE;
332 }
333
334 bool_t
335 xdr_guestfs_list_partitions_ret (XDR *xdrs, guestfs_list_partitions_ret *objp)
336 {
337         register int32_t *buf;
338
339          if (!xdr_array (xdrs, (char **)&objp->partitions.partitions_val, (u_int *) &objp->partitions.partitions_len, ~0,
340                 sizeof (str), (xdrproc_t) xdr_str))
341                  return FALSE;
342         return TRUE;
343 }
344
345 bool_t
346 xdr_guestfs_pvs_ret (XDR *xdrs, guestfs_pvs_ret *objp)
347 {
348         register int32_t *buf;
349
350          if (!xdr_array (xdrs, (char **)&objp->physvols.physvols_val, (u_int *) &objp->physvols.physvols_len, ~0,
351                 sizeof (str), (xdrproc_t) xdr_str))
352                  return FALSE;
353         return TRUE;
354 }
355
356 bool_t
357 xdr_guestfs_vgs_ret (XDR *xdrs, guestfs_vgs_ret *objp)
358 {
359         register int32_t *buf;
360
361          if (!xdr_array (xdrs, (char **)&objp->volgroups.volgroups_val, (u_int *) &objp->volgroups.volgroups_len, ~0,
362                 sizeof (str), (xdrproc_t) xdr_str))
363                  return FALSE;
364         return TRUE;
365 }
366
367 bool_t
368 xdr_guestfs_lvs_ret (XDR *xdrs, guestfs_lvs_ret *objp)
369 {
370         register int32_t *buf;
371
372          if (!xdr_array (xdrs, (char **)&objp->logvols.logvols_val, (u_int *) &objp->logvols.logvols_len, ~0,
373                 sizeof (str), (xdrproc_t) xdr_str))
374                  return FALSE;
375         return TRUE;
376 }
377
378 bool_t
379 xdr_guestfs_pvs_full_ret (XDR *xdrs, guestfs_pvs_full_ret *objp)
380 {
381         register int32_t *buf;
382
383          if (!xdr_guestfs_lvm_int_pv_list (xdrs, &objp->physvols))
384                  return FALSE;
385         return TRUE;
386 }
387
388 bool_t
389 xdr_guestfs_vgs_full_ret (XDR *xdrs, guestfs_vgs_full_ret *objp)
390 {
391         register int32_t *buf;
392
393          if (!xdr_guestfs_lvm_int_vg_list (xdrs, &objp->volgroups))
394                  return FALSE;
395         return TRUE;
396 }
397
398 bool_t
399 xdr_guestfs_lvs_full_ret (XDR *xdrs, guestfs_lvs_full_ret *objp)
400 {
401         register int32_t *buf;
402
403          if (!xdr_guestfs_lvm_int_lv_list (xdrs, &objp->logvols))
404                  return FALSE;
405         return TRUE;
406 }
407
408 bool_t
409 xdr_guestfs_read_lines_args (XDR *xdrs, guestfs_read_lines_args *objp)
410 {
411         register int32_t *buf;
412
413          if (!xdr_string (xdrs, &objp->path, ~0))
414                  return FALSE;
415         return TRUE;
416 }
417
418 bool_t
419 xdr_guestfs_read_lines_ret (XDR *xdrs, guestfs_read_lines_ret *objp)
420 {
421         register int32_t *buf;
422
423          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
424                 sizeof (str), (xdrproc_t) xdr_str))
425                  return FALSE;
426         return TRUE;
427 }
428
429 bool_t
430 xdr_guestfs_aug_init_args (XDR *xdrs, guestfs_aug_init_args *objp)
431 {
432         register int32_t *buf;
433
434          if (!xdr_string (xdrs, &objp->root, ~0))
435                  return FALSE;
436          if (!xdr_int (xdrs, &objp->flags))
437                  return FALSE;
438         return TRUE;
439 }
440
441 bool_t
442 xdr_guestfs_aug_defvar_args (XDR *xdrs, guestfs_aug_defvar_args *objp)
443 {
444         register int32_t *buf;
445
446          if (!xdr_string (xdrs, &objp->name, ~0))
447                  return FALSE;
448          if (!xdr_pointer (xdrs, (char **)&objp->expr, sizeof (str), (xdrproc_t) xdr_str))
449                  return FALSE;
450         return TRUE;
451 }
452
453 bool_t
454 xdr_guestfs_aug_defvar_ret (XDR *xdrs, guestfs_aug_defvar_ret *objp)
455 {
456         register int32_t *buf;
457
458          if (!xdr_int (xdrs, &objp->nrnodes))
459                  return FALSE;
460         return TRUE;
461 }
462
463 bool_t
464 xdr_guestfs_aug_defnode_args (XDR *xdrs, guestfs_aug_defnode_args *objp)
465 {
466         register int32_t *buf;
467
468          if (!xdr_string (xdrs, &objp->name, ~0))
469                  return FALSE;
470          if (!xdr_string (xdrs, &objp->expr, ~0))
471                  return FALSE;
472          if (!xdr_string (xdrs, &objp->val, ~0))
473                  return FALSE;
474         return TRUE;
475 }
476
477 bool_t
478 xdr_guestfs_aug_defnode_ret (XDR *xdrs, guestfs_aug_defnode_ret *objp)
479 {
480         register int32_t *buf;
481
482          if (!xdr_int (xdrs, &objp->nrnodes))
483                  return FALSE;
484          if (!xdr_bool (xdrs, &objp->created))
485                  return FALSE;
486         return TRUE;
487 }
488
489 bool_t
490 xdr_guestfs_aug_get_args (XDR *xdrs, guestfs_aug_get_args *objp)
491 {
492         register int32_t *buf;
493
494          if (!xdr_string (xdrs, &objp->path, ~0))
495                  return FALSE;
496         return TRUE;
497 }
498
499 bool_t
500 xdr_guestfs_aug_get_ret (XDR *xdrs, guestfs_aug_get_ret *objp)
501 {
502         register int32_t *buf;
503
504          if (!xdr_string (xdrs, &objp->val, ~0))
505                  return FALSE;
506         return TRUE;
507 }
508
509 bool_t
510 xdr_guestfs_aug_set_args (XDR *xdrs, guestfs_aug_set_args *objp)
511 {
512         register int32_t *buf;
513
514          if (!xdr_string (xdrs, &objp->path, ~0))
515                  return FALSE;
516          if (!xdr_string (xdrs, &objp->val, ~0))
517                  return FALSE;
518         return TRUE;
519 }
520
521 bool_t
522 xdr_guestfs_aug_insert_args (XDR *xdrs, guestfs_aug_insert_args *objp)
523 {
524         register int32_t *buf;
525
526          if (!xdr_string (xdrs, &objp->path, ~0))
527                  return FALSE;
528          if (!xdr_string (xdrs, &objp->label, ~0))
529                  return FALSE;
530          if (!xdr_bool (xdrs, &objp->before))
531                  return FALSE;
532         return TRUE;
533 }
534
535 bool_t
536 xdr_guestfs_aug_rm_args (XDR *xdrs, guestfs_aug_rm_args *objp)
537 {
538         register int32_t *buf;
539
540          if (!xdr_string (xdrs, &objp->path, ~0))
541                  return FALSE;
542         return TRUE;
543 }
544
545 bool_t
546 xdr_guestfs_aug_rm_ret (XDR *xdrs, guestfs_aug_rm_ret *objp)
547 {
548         register int32_t *buf;
549
550          if (!xdr_int (xdrs, &objp->nrnodes))
551                  return FALSE;
552         return TRUE;
553 }
554
555 bool_t
556 xdr_guestfs_aug_mv_args (XDR *xdrs, guestfs_aug_mv_args *objp)
557 {
558         register int32_t *buf;
559
560          if (!xdr_string (xdrs, &objp->src, ~0))
561                  return FALSE;
562          if (!xdr_string (xdrs, &objp->dest, ~0))
563                  return FALSE;
564         return TRUE;
565 }
566
567 bool_t
568 xdr_guestfs_aug_match_args (XDR *xdrs, guestfs_aug_match_args *objp)
569 {
570         register int32_t *buf;
571
572          if (!xdr_string (xdrs, &objp->path, ~0))
573                  return FALSE;
574         return TRUE;
575 }
576
577 bool_t
578 xdr_guestfs_aug_match_ret (XDR *xdrs, guestfs_aug_match_ret *objp)
579 {
580         register int32_t *buf;
581
582          if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
583                 sizeof (str), (xdrproc_t) xdr_str))
584                  return FALSE;
585         return TRUE;
586 }
587
588 bool_t
589 xdr_guestfs_aug_ls_args (XDR *xdrs, guestfs_aug_ls_args *objp)
590 {
591         register int32_t *buf;
592
593          if (!xdr_string (xdrs, &objp->path, ~0))
594                  return FALSE;
595         return TRUE;
596 }
597
598 bool_t
599 xdr_guestfs_aug_ls_ret (XDR *xdrs, guestfs_aug_ls_ret *objp)
600 {
601         register int32_t *buf;
602
603          if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
604                 sizeof (str), (xdrproc_t) xdr_str))
605                  return FALSE;
606         return TRUE;
607 }
608
609 bool_t
610 xdr_guestfs_rm_args (XDR *xdrs, guestfs_rm_args *objp)
611 {
612         register int32_t *buf;
613
614          if (!xdr_string (xdrs, &objp->path, ~0))
615                  return FALSE;
616         return TRUE;
617 }
618
619 bool_t
620 xdr_guestfs_rmdir_args (XDR *xdrs, guestfs_rmdir_args *objp)
621 {
622         register int32_t *buf;
623
624          if (!xdr_string (xdrs, &objp->path, ~0))
625                  return FALSE;
626         return TRUE;
627 }
628
629 bool_t
630 xdr_guestfs_rm_rf_args (XDR *xdrs, guestfs_rm_rf_args *objp)
631 {
632         register int32_t *buf;
633
634          if (!xdr_string (xdrs, &objp->path, ~0))
635                  return FALSE;
636         return TRUE;
637 }
638
639 bool_t
640 xdr_guestfs_mkdir_args (XDR *xdrs, guestfs_mkdir_args *objp)
641 {
642         register int32_t *buf;
643
644          if (!xdr_string (xdrs, &objp->path, ~0))
645                  return FALSE;
646         return TRUE;
647 }
648
649 bool_t
650 xdr_guestfs_mkdir_p_args (XDR *xdrs, guestfs_mkdir_p_args *objp)
651 {
652         register int32_t *buf;
653
654          if (!xdr_string (xdrs, &objp->path, ~0))
655                  return FALSE;
656         return TRUE;
657 }
658
659 bool_t
660 xdr_guestfs_chmod_args (XDR *xdrs, guestfs_chmod_args *objp)
661 {
662         register int32_t *buf;
663
664          if (!xdr_int (xdrs, &objp->mode))
665                  return FALSE;
666          if (!xdr_string (xdrs, &objp->path, ~0))
667                  return FALSE;
668         return TRUE;
669 }
670
671 bool_t
672 xdr_guestfs_chown_args (XDR *xdrs, guestfs_chown_args *objp)
673 {
674         register int32_t *buf;
675
676          if (!xdr_int (xdrs, &objp->owner))
677                  return FALSE;
678          if (!xdr_int (xdrs, &objp->group))
679                  return FALSE;
680          if (!xdr_string (xdrs, &objp->path, ~0))
681                  return FALSE;
682         return TRUE;
683 }
684
685 bool_t
686 xdr_guestfs_exists_args (XDR *xdrs, guestfs_exists_args *objp)
687 {
688         register int32_t *buf;
689
690          if (!xdr_string (xdrs, &objp->path, ~0))
691                  return FALSE;
692         return TRUE;
693 }
694
695 bool_t
696 xdr_guestfs_exists_ret (XDR *xdrs, guestfs_exists_ret *objp)
697 {
698         register int32_t *buf;
699
700          if (!xdr_bool (xdrs, &objp->existsflag))
701                  return FALSE;
702         return TRUE;
703 }
704
705 bool_t
706 xdr_guestfs_is_file_args (XDR *xdrs, guestfs_is_file_args *objp)
707 {
708         register int32_t *buf;
709
710          if (!xdr_string (xdrs, &objp->path, ~0))
711                  return FALSE;
712         return TRUE;
713 }
714
715 bool_t
716 xdr_guestfs_is_file_ret (XDR *xdrs, guestfs_is_file_ret *objp)
717 {
718         register int32_t *buf;
719
720          if (!xdr_bool (xdrs, &objp->fileflag))
721                  return FALSE;
722         return TRUE;
723 }
724
725 bool_t
726 xdr_guestfs_is_dir_args (XDR *xdrs, guestfs_is_dir_args *objp)
727 {
728         register int32_t *buf;
729
730          if (!xdr_string (xdrs, &objp->path, ~0))
731                  return FALSE;
732         return TRUE;
733 }
734
735 bool_t
736 xdr_guestfs_is_dir_ret (XDR *xdrs, guestfs_is_dir_ret *objp)
737 {
738         register int32_t *buf;
739
740          if (!xdr_bool (xdrs, &objp->dirflag))
741                  return FALSE;
742         return TRUE;
743 }
744
745 bool_t
746 xdr_guestfs_pvcreate_args (XDR *xdrs, guestfs_pvcreate_args *objp)
747 {
748         register int32_t *buf;
749
750          if (!xdr_string (xdrs, &objp->device, ~0))
751                  return FALSE;
752         return TRUE;
753 }
754
755 bool_t
756 xdr_guestfs_vgcreate_args (XDR *xdrs, guestfs_vgcreate_args *objp)
757 {
758         register int32_t *buf;
759
760          if (!xdr_string (xdrs, &objp->volgroup, ~0))
761                  return FALSE;
762          if (!xdr_array (xdrs, (char **)&objp->physvols.physvols_val, (u_int *) &objp->physvols.physvols_len, ~0,
763                 sizeof (str), (xdrproc_t) xdr_str))
764                  return FALSE;
765         return TRUE;
766 }
767
768 bool_t
769 xdr_guestfs_lvcreate_args (XDR *xdrs, guestfs_lvcreate_args *objp)
770 {
771         register int32_t *buf;
772
773          if (!xdr_string (xdrs, &objp->logvol, ~0))
774                  return FALSE;
775          if (!xdr_string (xdrs, &objp->volgroup, ~0))
776                  return FALSE;
777          if (!xdr_int (xdrs, &objp->mbytes))
778                  return FALSE;
779         return TRUE;
780 }
781
782 bool_t
783 xdr_guestfs_mkfs_args (XDR *xdrs, guestfs_mkfs_args *objp)
784 {
785         register int32_t *buf;
786
787          if (!xdr_string (xdrs, &objp->fstype, ~0))
788                  return FALSE;
789          if (!xdr_string (xdrs, &objp->device, ~0))
790                  return FALSE;
791         return TRUE;
792 }
793
794 bool_t
795 xdr_guestfs_sfdisk_args (XDR *xdrs, guestfs_sfdisk_args *objp)
796 {
797         register int32_t *buf;
798
799
800         if (xdrs->x_op == XDR_ENCODE) {
801                  if (!xdr_string (xdrs, &objp->device, ~0))
802                          return FALSE;
803                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
804                 if (buf == NULL) {
805                          if (!xdr_int (xdrs, &objp->cyls))
806                                  return FALSE;
807                          if (!xdr_int (xdrs, &objp->heads))
808                                  return FALSE;
809                          if (!xdr_int (xdrs, &objp->sectors))
810                                  return FALSE;
811
812                 } else {
813                 IXDR_PUT_LONG(buf, objp->cyls);
814                 IXDR_PUT_LONG(buf, objp->heads);
815                 IXDR_PUT_LONG(buf, objp->sectors);
816                 }
817                  if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
818                         sizeof (str), (xdrproc_t) xdr_str))
819                          return FALSE;
820                 return TRUE;
821         } else if (xdrs->x_op == XDR_DECODE) {
822                  if (!xdr_string (xdrs, &objp->device, ~0))
823                          return FALSE;
824                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
825                 if (buf == NULL) {
826                          if (!xdr_int (xdrs, &objp->cyls))
827                                  return FALSE;
828                          if (!xdr_int (xdrs, &objp->heads))
829                                  return FALSE;
830                          if (!xdr_int (xdrs, &objp->sectors))
831                                  return FALSE;
832
833                 } else {
834                 objp->cyls = IXDR_GET_LONG(buf);
835                 objp->heads = IXDR_GET_LONG(buf);
836                 objp->sectors = IXDR_GET_LONG(buf);
837                 }
838                  if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
839                         sizeof (str), (xdrproc_t) xdr_str))
840                          return FALSE;
841          return TRUE;
842         }
843
844          if (!xdr_string (xdrs, &objp->device, ~0))
845                  return FALSE;
846          if (!xdr_int (xdrs, &objp->cyls))
847                  return FALSE;
848          if (!xdr_int (xdrs, &objp->heads))
849                  return FALSE;
850          if (!xdr_int (xdrs, &objp->sectors))
851                  return FALSE;
852          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
853                 sizeof (str), (xdrproc_t) xdr_str))
854                  return FALSE;
855         return TRUE;
856 }
857
858 bool_t
859 xdr_guestfs_write_file_args (XDR *xdrs, guestfs_write_file_args *objp)
860 {
861         register int32_t *buf;
862
863          if (!xdr_string (xdrs, &objp->path, ~0))
864                  return FALSE;
865          if (!xdr_string (xdrs, &objp->content, ~0))
866                  return FALSE;
867          if (!xdr_int (xdrs, &objp->size))
868                  return FALSE;
869         return TRUE;
870 }
871
872 bool_t
873 xdr_guestfs_umount_args (XDR *xdrs, guestfs_umount_args *objp)
874 {
875         register int32_t *buf;
876
877          if (!xdr_string (xdrs, &objp->pathordevice, ~0))
878                  return FALSE;
879         return TRUE;
880 }
881
882 bool_t
883 xdr_guestfs_mounts_ret (XDR *xdrs, guestfs_mounts_ret *objp)
884 {
885         register int32_t *buf;
886
887          if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
888                 sizeof (str), (xdrproc_t) xdr_str))
889                  return FALSE;
890         return TRUE;
891 }
892
893 bool_t
894 xdr_guestfs_file_args (XDR *xdrs, guestfs_file_args *objp)
895 {
896         register int32_t *buf;
897
898          if (!xdr_string (xdrs, &objp->path, ~0))
899                  return FALSE;
900         return TRUE;
901 }
902
903 bool_t
904 xdr_guestfs_file_ret (XDR *xdrs, guestfs_file_ret *objp)
905 {
906         register int32_t *buf;
907
908          if (!xdr_string (xdrs, &objp->description, ~0))
909                  return FALSE;
910         return TRUE;
911 }
912
913 bool_t
914 xdr_guestfs_command_args (XDR *xdrs, guestfs_command_args *objp)
915 {
916         register int32_t *buf;
917
918          if (!xdr_array (xdrs, (char **)&objp->arguments.arguments_val, (u_int *) &objp->arguments.arguments_len, ~0,
919                 sizeof (str), (xdrproc_t) xdr_str))
920                  return FALSE;
921         return TRUE;
922 }
923
924 bool_t
925 xdr_guestfs_command_ret (XDR *xdrs, guestfs_command_ret *objp)
926 {
927         register int32_t *buf;
928
929          if (!xdr_string (xdrs, &objp->output, ~0))
930                  return FALSE;
931         return TRUE;
932 }
933
934 bool_t
935 xdr_guestfs_command_lines_args (XDR *xdrs, guestfs_command_lines_args *objp)
936 {
937         register int32_t *buf;
938
939          if (!xdr_array (xdrs, (char **)&objp->arguments.arguments_val, (u_int *) &objp->arguments.arguments_len, ~0,
940                 sizeof (str), (xdrproc_t) xdr_str))
941                  return FALSE;
942         return TRUE;
943 }
944
945 bool_t
946 xdr_guestfs_command_lines_ret (XDR *xdrs, guestfs_command_lines_ret *objp)
947 {
948         register int32_t *buf;
949
950          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
951                 sizeof (str), (xdrproc_t) xdr_str))
952                  return FALSE;
953         return TRUE;
954 }
955
956 bool_t
957 xdr_guestfs_stat_args (XDR *xdrs, guestfs_stat_args *objp)
958 {
959         register int32_t *buf;
960
961          if (!xdr_string (xdrs, &objp->path, ~0))
962                  return FALSE;
963         return TRUE;
964 }
965
966 bool_t
967 xdr_guestfs_stat_ret (XDR *xdrs, guestfs_stat_ret *objp)
968 {
969         register int32_t *buf;
970
971          if (!xdr_guestfs_int_stat (xdrs, &objp->statbuf))
972                  return FALSE;
973         return TRUE;
974 }
975
976 bool_t
977 xdr_guestfs_lstat_args (XDR *xdrs, guestfs_lstat_args *objp)
978 {
979         register int32_t *buf;
980
981          if (!xdr_string (xdrs, &objp->path, ~0))
982                  return FALSE;
983         return TRUE;
984 }
985
986 bool_t
987 xdr_guestfs_lstat_ret (XDR *xdrs, guestfs_lstat_ret *objp)
988 {
989         register int32_t *buf;
990
991          if (!xdr_guestfs_int_stat (xdrs, &objp->statbuf))
992                  return FALSE;
993         return TRUE;
994 }
995
996 bool_t
997 xdr_guestfs_statvfs_args (XDR *xdrs, guestfs_statvfs_args *objp)
998 {
999         register int32_t *buf;
1000
1001          if (!xdr_string (xdrs, &objp->path, ~0))
1002                  return FALSE;
1003         return TRUE;
1004 }
1005
1006 bool_t
1007 xdr_guestfs_statvfs_ret (XDR *xdrs, guestfs_statvfs_ret *objp)
1008 {
1009         register int32_t *buf;
1010
1011          if (!xdr_guestfs_int_statvfs (xdrs, &objp->statbuf))
1012                  return FALSE;
1013         return TRUE;
1014 }
1015
1016 bool_t
1017 xdr_guestfs_tune2fs_l_args (XDR *xdrs, guestfs_tune2fs_l_args *objp)
1018 {
1019         register int32_t *buf;
1020
1021          if (!xdr_string (xdrs, &objp->device, ~0))
1022                  return FALSE;
1023         return TRUE;
1024 }
1025
1026 bool_t
1027 xdr_guestfs_tune2fs_l_ret (XDR *xdrs, guestfs_tune2fs_l_ret *objp)
1028 {
1029         register int32_t *buf;
1030
1031          if (!xdr_array (xdrs, (char **)&objp->superblock.superblock_val, (u_int *) &objp->superblock.superblock_len, ~0,
1032                 sizeof (str), (xdrproc_t) xdr_str))
1033                  return FALSE;
1034         return TRUE;
1035 }
1036
1037 bool_t
1038 xdr_guestfs_blockdev_setro_args (XDR *xdrs, guestfs_blockdev_setro_args *objp)
1039 {
1040         register int32_t *buf;
1041
1042          if (!xdr_string (xdrs, &objp->device, ~0))
1043                  return FALSE;
1044         return TRUE;
1045 }
1046
1047 bool_t
1048 xdr_guestfs_blockdev_setrw_args (XDR *xdrs, guestfs_blockdev_setrw_args *objp)
1049 {
1050         register int32_t *buf;
1051
1052          if (!xdr_string (xdrs, &objp->device, ~0))
1053                  return FALSE;
1054         return TRUE;
1055 }
1056
1057 bool_t
1058 xdr_guestfs_blockdev_getro_args (XDR *xdrs, guestfs_blockdev_getro_args *objp)
1059 {
1060         register int32_t *buf;
1061
1062          if (!xdr_string (xdrs, &objp->device, ~0))
1063                  return FALSE;
1064         return TRUE;
1065 }
1066
1067 bool_t
1068 xdr_guestfs_blockdev_getro_ret (XDR *xdrs, guestfs_blockdev_getro_ret *objp)
1069 {
1070         register int32_t *buf;
1071
1072          if (!xdr_bool (xdrs, &objp->ro))
1073                  return FALSE;
1074         return TRUE;
1075 }
1076
1077 bool_t
1078 xdr_guestfs_blockdev_getss_args (XDR *xdrs, guestfs_blockdev_getss_args *objp)
1079 {
1080         register int32_t *buf;
1081
1082          if (!xdr_string (xdrs, &objp->device, ~0))
1083                  return FALSE;
1084         return TRUE;
1085 }
1086
1087 bool_t
1088 xdr_guestfs_blockdev_getss_ret (XDR *xdrs, guestfs_blockdev_getss_ret *objp)
1089 {
1090         register int32_t *buf;
1091
1092          if (!xdr_int (xdrs, &objp->sectorsize))
1093                  return FALSE;
1094         return TRUE;
1095 }
1096
1097 bool_t
1098 xdr_guestfs_blockdev_getbsz_args (XDR *xdrs, guestfs_blockdev_getbsz_args *objp)
1099 {
1100         register int32_t *buf;
1101
1102          if (!xdr_string (xdrs, &objp->device, ~0))
1103                  return FALSE;
1104         return TRUE;
1105 }
1106
1107 bool_t
1108 xdr_guestfs_blockdev_getbsz_ret (XDR *xdrs, guestfs_blockdev_getbsz_ret *objp)
1109 {
1110         register int32_t *buf;
1111
1112          if (!xdr_int (xdrs, &objp->blocksize))
1113                  return FALSE;
1114         return TRUE;
1115 }
1116
1117 bool_t
1118 xdr_guestfs_blockdev_setbsz_args (XDR *xdrs, guestfs_blockdev_setbsz_args *objp)
1119 {
1120         register int32_t *buf;
1121
1122          if (!xdr_string (xdrs, &objp->device, ~0))
1123                  return FALSE;
1124          if (!xdr_int (xdrs, &objp->blocksize))
1125                  return FALSE;
1126         return TRUE;
1127 }
1128
1129 bool_t
1130 xdr_guestfs_blockdev_getsz_args (XDR *xdrs, guestfs_blockdev_getsz_args *objp)
1131 {
1132         register int32_t *buf;
1133
1134          if (!xdr_string (xdrs, &objp->device, ~0))
1135                  return FALSE;
1136         return TRUE;
1137 }
1138
1139 bool_t
1140 xdr_guestfs_blockdev_getsz_ret (XDR *xdrs, guestfs_blockdev_getsz_ret *objp)
1141 {
1142         register int32_t *buf;
1143
1144          if (!xdr_quad_t (xdrs, &objp->sizeinsectors))
1145                  return FALSE;
1146         return TRUE;
1147 }
1148
1149 bool_t
1150 xdr_guestfs_blockdev_getsize64_args (XDR *xdrs, guestfs_blockdev_getsize64_args *objp)
1151 {
1152         register int32_t *buf;
1153
1154          if (!xdr_string (xdrs, &objp->device, ~0))
1155                  return FALSE;
1156         return TRUE;
1157 }
1158
1159 bool_t
1160 xdr_guestfs_blockdev_getsize64_ret (XDR *xdrs, guestfs_blockdev_getsize64_ret *objp)
1161 {
1162         register int32_t *buf;
1163
1164          if (!xdr_quad_t (xdrs, &objp->sizeinbytes))
1165                  return FALSE;
1166         return TRUE;
1167 }
1168
1169 bool_t
1170 xdr_guestfs_blockdev_flushbufs_args (XDR *xdrs, guestfs_blockdev_flushbufs_args *objp)
1171 {
1172         register int32_t *buf;
1173
1174          if (!xdr_string (xdrs, &objp->device, ~0))
1175                  return FALSE;
1176         return TRUE;
1177 }
1178
1179 bool_t
1180 xdr_guestfs_blockdev_rereadpt_args (XDR *xdrs, guestfs_blockdev_rereadpt_args *objp)
1181 {
1182         register int32_t *buf;
1183
1184          if (!xdr_string (xdrs, &objp->device, ~0))
1185                  return FALSE;
1186         return TRUE;
1187 }
1188
1189 bool_t
1190 xdr_guestfs_upload_args (XDR *xdrs, guestfs_upload_args *objp)
1191 {
1192         register int32_t *buf;
1193
1194          if (!xdr_string (xdrs, &objp->remotefilename, ~0))
1195                  return FALSE;
1196         return TRUE;
1197 }
1198
1199 bool_t
1200 xdr_guestfs_download_args (XDR *xdrs, guestfs_download_args *objp)
1201 {
1202         register int32_t *buf;
1203
1204          if (!xdr_string (xdrs, &objp->remotefilename, ~0))
1205                  return FALSE;
1206         return TRUE;
1207 }
1208
1209 bool_t
1210 xdr_guestfs_checksum_args (XDR *xdrs, guestfs_checksum_args *objp)
1211 {
1212         register int32_t *buf;
1213
1214          if (!xdr_string (xdrs, &objp->csumtype, ~0))
1215                  return FALSE;
1216          if (!xdr_string (xdrs, &objp->path, ~0))
1217                  return FALSE;
1218         return TRUE;
1219 }
1220
1221 bool_t
1222 xdr_guestfs_checksum_ret (XDR *xdrs, guestfs_checksum_ret *objp)
1223 {
1224         register int32_t *buf;
1225
1226          if (!xdr_string (xdrs, &objp->checksum, ~0))
1227                  return FALSE;
1228         return TRUE;
1229 }
1230
1231 bool_t
1232 xdr_guestfs_tar_in_args (XDR *xdrs, guestfs_tar_in_args *objp)
1233 {
1234         register int32_t *buf;
1235
1236          if (!xdr_string (xdrs, &objp->directory, ~0))
1237                  return FALSE;
1238         return TRUE;
1239 }
1240
1241 bool_t
1242 xdr_guestfs_tar_out_args (XDR *xdrs, guestfs_tar_out_args *objp)
1243 {
1244         register int32_t *buf;
1245
1246          if (!xdr_string (xdrs, &objp->directory, ~0))
1247                  return FALSE;
1248         return TRUE;
1249 }
1250
1251 bool_t
1252 xdr_guestfs_tgz_in_args (XDR *xdrs, guestfs_tgz_in_args *objp)
1253 {
1254         register int32_t *buf;
1255
1256          if (!xdr_string (xdrs, &objp->directory, ~0))
1257                  return FALSE;
1258         return TRUE;
1259 }
1260
1261 bool_t
1262 xdr_guestfs_tgz_out_args (XDR *xdrs, guestfs_tgz_out_args *objp)
1263 {
1264         register int32_t *buf;
1265
1266          if (!xdr_string (xdrs, &objp->directory, ~0))
1267                  return FALSE;
1268         return TRUE;
1269 }
1270
1271 bool_t
1272 xdr_guestfs_mount_ro_args (XDR *xdrs, guestfs_mount_ro_args *objp)
1273 {
1274         register int32_t *buf;
1275
1276          if (!xdr_string (xdrs, &objp->device, ~0))
1277                  return FALSE;
1278          if (!xdr_string (xdrs, &objp->mountpoint, ~0))
1279                  return FALSE;
1280         return TRUE;
1281 }
1282
1283 bool_t
1284 xdr_guestfs_mount_options_args (XDR *xdrs, guestfs_mount_options_args *objp)
1285 {
1286         register int32_t *buf;
1287
1288          if (!xdr_string (xdrs, &objp->options, ~0))
1289                  return FALSE;
1290          if (!xdr_string (xdrs, &objp->device, ~0))
1291                  return FALSE;
1292          if (!xdr_string (xdrs, &objp->mountpoint, ~0))
1293                  return FALSE;
1294         return TRUE;
1295 }
1296
1297 bool_t
1298 xdr_guestfs_mount_vfs_args (XDR *xdrs, guestfs_mount_vfs_args *objp)
1299 {
1300         register int32_t *buf;
1301
1302          if (!xdr_string (xdrs, &objp->options, ~0))
1303                  return FALSE;
1304          if (!xdr_string (xdrs, &objp->vfstype, ~0))
1305                  return FALSE;
1306          if (!xdr_string (xdrs, &objp->device, ~0))
1307                  return FALSE;
1308          if (!xdr_string (xdrs, &objp->mountpoint, ~0))
1309                  return FALSE;
1310         return TRUE;
1311 }
1312
1313 bool_t
1314 xdr_guestfs_debug_args (XDR *xdrs, guestfs_debug_args *objp)
1315 {
1316         register int32_t *buf;
1317
1318          if (!xdr_string (xdrs, &objp->subcmd, ~0))
1319                  return FALSE;
1320          if (!xdr_array (xdrs, (char **)&objp->extraargs.extraargs_val, (u_int *) &objp->extraargs.extraargs_len, ~0,
1321                 sizeof (str), (xdrproc_t) xdr_str))
1322                  return FALSE;
1323         return TRUE;
1324 }
1325
1326 bool_t
1327 xdr_guestfs_debug_ret (XDR *xdrs, guestfs_debug_ret *objp)
1328 {
1329         register int32_t *buf;
1330
1331          if (!xdr_string (xdrs, &objp->result, ~0))
1332                  return FALSE;
1333         return TRUE;
1334 }
1335
1336 bool_t
1337 xdr_guestfs_lvremove_args (XDR *xdrs, guestfs_lvremove_args *objp)
1338 {
1339         register int32_t *buf;
1340
1341          if (!xdr_string (xdrs, &objp->device, ~0))
1342                  return FALSE;
1343         return TRUE;
1344 }
1345
1346 bool_t
1347 xdr_guestfs_vgremove_args (XDR *xdrs, guestfs_vgremove_args *objp)
1348 {
1349         register int32_t *buf;
1350
1351          if (!xdr_string (xdrs, &objp->vgname, ~0))
1352                  return FALSE;
1353         return TRUE;
1354 }
1355
1356 bool_t
1357 xdr_guestfs_pvremove_args (XDR *xdrs, guestfs_pvremove_args *objp)
1358 {
1359         register int32_t *buf;
1360
1361          if (!xdr_string (xdrs, &objp->device, ~0))
1362                  return FALSE;
1363         return TRUE;
1364 }
1365
1366 bool_t
1367 xdr_guestfs_set_e2label_args (XDR *xdrs, guestfs_set_e2label_args *objp)
1368 {
1369         register int32_t *buf;
1370
1371          if (!xdr_string (xdrs, &objp->device, ~0))
1372                  return FALSE;
1373          if (!xdr_string (xdrs, &objp->label, ~0))
1374                  return FALSE;
1375         return TRUE;
1376 }
1377
1378 bool_t
1379 xdr_guestfs_get_e2label_args (XDR *xdrs, guestfs_get_e2label_args *objp)
1380 {
1381         register int32_t *buf;
1382
1383          if (!xdr_string (xdrs, &objp->device, ~0))
1384                  return FALSE;
1385         return TRUE;
1386 }
1387
1388 bool_t
1389 xdr_guestfs_get_e2label_ret (XDR *xdrs, guestfs_get_e2label_ret *objp)
1390 {
1391         register int32_t *buf;
1392
1393          if (!xdr_string (xdrs, &objp->label, ~0))
1394                  return FALSE;
1395         return TRUE;
1396 }
1397
1398 bool_t
1399 xdr_guestfs_set_e2uuid_args (XDR *xdrs, guestfs_set_e2uuid_args *objp)
1400 {
1401         register int32_t *buf;
1402
1403          if (!xdr_string (xdrs, &objp->device, ~0))
1404                  return FALSE;
1405          if (!xdr_string (xdrs, &objp->uuid, ~0))
1406                  return FALSE;
1407         return TRUE;
1408 }
1409
1410 bool_t
1411 xdr_guestfs_get_e2uuid_args (XDR *xdrs, guestfs_get_e2uuid_args *objp)
1412 {
1413         register int32_t *buf;
1414
1415          if (!xdr_string (xdrs, &objp->device, ~0))
1416                  return FALSE;
1417         return TRUE;
1418 }
1419
1420 bool_t
1421 xdr_guestfs_get_e2uuid_ret (XDR *xdrs, guestfs_get_e2uuid_ret *objp)
1422 {
1423         register int32_t *buf;
1424
1425          if (!xdr_string (xdrs, &objp->uuid, ~0))
1426                  return FALSE;
1427         return TRUE;
1428 }
1429
1430 bool_t
1431 xdr_guestfs_fsck_args (XDR *xdrs, guestfs_fsck_args *objp)
1432 {
1433         register int32_t *buf;
1434
1435          if (!xdr_string (xdrs, &objp->fstype, ~0))
1436                  return FALSE;
1437          if (!xdr_string (xdrs, &objp->device, ~0))
1438                  return FALSE;
1439         return TRUE;
1440 }
1441
1442 bool_t
1443 xdr_guestfs_fsck_ret (XDR *xdrs, guestfs_fsck_ret *objp)
1444 {
1445         register int32_t *buf;
1446
1447          if (!xdr_int (xdrs, &objp->status))
1448                  return FALSE;
1449         return TRUE;
1450 }
1451
1452 bool_t
1453 xdr_guestfs_zero_args (XDR *xdrs, guestfs_zero_args *objp)
1454 {
1455         register int32_t *buf;
1456
1457          if (!xdr_string (xdrs, &objp->device, ~0))
1458                  return FALSE;
1459         return TRUE;
1460 }
1461
1462 bool_t
1463 xdr_guestfs_grub_install_args (XDR *xdrs, guestfs_grub_install_args *objp)
1464 {
1465         register int32_t *buf;
1466
1467          if (!xdr_string (xdrs, &objp->root, ~0))
1468                  return FALSE;
1469          if (!xdr_string (xdrs, &objp->device, ~0))
1470                  return FALSE;
1471         return TRUE;
1472 }
1473
1474 bool_t
1475 xdr_guestfs_cp_args (XDR *xdrs, guestfs_cp_args *objp)
1476 {
1477         register int32_t *buf;
1478
1479          if (!xdr_string (xdrs, &objp->src, ~0))
1480                  return FALSE;
1481          if (!xdr_string (xdrs, &objp->dest, ~0))
1482                  return FALSE;
1483         return TRUE;
1484 }
1485
1486 bool_t
1487 xdr_guestfs_cp_a_args (XDR *xdrs, guestfs_cp_a_args *objp)
1488 {
1489         register int32_t *buf;
1490
1491          if (!xdr_string (xdrs, &objp->src, ~0))
1492                  return FALSE;
1493          if (!xdr_string (xdrs, &objp->dest, ~0))
1494                  return FALSE;
1495         return TRUE;
1496 }
1497
1498 bool_t
1499 xdr_guestfs_mv_args (XDR *xdrs, guestfs_mv_args *objp)
1500 {
1501         register int32_t *buf;
1502
1503          if (!xdr_string (xdrs, &objp->src, ~0))
1504                  return FALSE;
1505          if (!xdr_string (xdrs, &objp->dest, ~0))
1506                  return FALSE;
1507         return TRUE;
1508 }
1509
1510 bool_t
1511 xdr_guestfs_drop_caches_args (XDR *xdrs, guestfs_drop_caches_args *objp)
1512 {
1513         register int32_t *buf;
1514
1515          if (!xdr_int (xdrs, &objp->whattodrop))
1516                  return FALSE;
1517         return TRUE;
1518 }
1519
1520 bool_t
1521 xdr_guestfs_dmesg_ret (XDR *xdrs, guestfs_dmesg_ret *objp)
1522 {
1523         register int32_t *buf;
1524
1525          if (!xdr_string (xdrs, &objp->kmsgs, ~0))
1526                  return FALSE;
1527         return TRUE;
1528 }
1529
1530 bool_t
1531 xdr_guestfs_equal_args (XDR *xdrs, guestfs_equal_args *objp)
1532 {
1533         register int32_t *buf;
1534
1535          if (!xdr_string (xdrs, &objp->file1, ~0))
1536                  return FALSE;
1537          if (!xdr_string (xdrs, &objp->file2, ~0))
1538                  return FALSE;
1539         return TRUE;
1540 }
1541
1542 bool_t
1543 xdr_guestfs_equal_ret (XDR *xdrs, guestfs_equal_ret *objp)
1544 {
1545         register int32_t *buf;
1546
1547          if (!xdr_bool (xdrs, &objp->equality))
1548                  return FALSE;
1549         return TRUE;
1550 }
1551
1552 bool_t
1553 xdr_guestfs_strings_args (XDR *xdrs, guestfs_strings_args *objp)
1554 {
1555         register int32_t *buf;
1556
1557          if (!xdr_string (xdrs, &objp->path, ~0))
1558                  return FALSE;
1559         return TRUE;
1560 }
1561
1562 bool_t
1563 xdr_guestfs_strings_ret (XDR *xdrs, guestfs_strings_ret *objp)
1564 {
1565         register int32_t *buf;
1566
1567          if (!xdr_array (xdrs, (char **)&objp->stringsout.stringsout_val, (u_int *) &objp->stringsout.stringsout_len, ~0,
1568                 sizeof (str), (xdrproc_t) xdr_str))
1569                  return FALSE;
1570         return TRUE;
1571 }
1572
1573 bool_t
1574 xdr_guestfs_strings_e_args (XDR *xdrs, guestfs_strings_e_args *objp)
1575 {
1576         register int32_t *buf;
1577
1578          if (!xdr_string (xdrs, &objp->encoding, ~0))
1579                  return FALSE;
1580          if (!xdr_string (xdrs, &objp->path, ~0))
1581                  return FALSE;
1582         return TRUE;
1583 }
1584
1585 bool_t
1586 xdr_guestfs_strings_e_ret (XDR *xdrs, guestfs_strings_e_ret *objp)
1587 {
1588         register int32_t *buf;
1589
1590          if (!xdr_array (xdrs, (char **)&objp->stringsout.stringsout_val, (u_int *) &objp->stringsout.stringsout_len, ~0,
1591                 sizeof (str), (xdrproc_t) xdr_str))
1592                  return FALSE;
1593         return TRUE;
1594 }
1595
1596 bool_t
1597 xdr_guestfs_hexdump_args (XDR *xdrs, guestfs_hexdump_args *objp)
1598 {
1599         register int32_t *buf;
1600
1601          if (!xdr_string (xdrs, &objp->path, ~0))
1602                  return FALSE;
1603         return TRUE;
1604 }
1605
1606 bool_t
1607 xdr_guestfs_hexdump_ret (XDR *xdrs, guestfs_hexdump_ret *objp)
1608 {
1609         register int32_t *buf;
1610
1611          if (!xdr_string (xdrs, &objp->dump, ~0))
1612                  return FALSE;
1613         return TRUE;
1614 }
1615
1616 bool_t
1617 xdr_guestfs_zerofree_args (XDR *xdrs, guestfs_zerofree_args *objp)
1618 {
1619         register int32_t *buf;
1620
1621          if (!xdr_string (xdrs, &objp->device, ~0))
1622                  return FALSE;
1623         return TRUE;
1624 }
1625
1626 bool_t
1627 xdr_guestfs_pvresize_args (XDR *xdrs, guestfs_pvresize_args *objp)
1628 {
1629         register int32_t *buf;
1630
1631          if (!xdr_string (xdrs, &objp->device, ~0))
1632                  return FALSE;
1633         return TRUE;
1634 }
1635
1636 bool_t
1637 xdr_guestfs_sfdisk_N_args (XDR *xdrs, guestfs_sfdisk_N_args *objp)
1638 {
1639         register int32_t *buf;
1640
1641
1642         if (xdrs->x_op == XDR_ENCODE) {
1643                  if (!xdr_string (xdrs, &objp->device, ~0))
1644                          return FALSE;
1645                 buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
1646                 if (buf == NULL) {
1647                          if (!xdr_int (xdrs, &objp->partnum))
1648                                  return FALSE;
1649                          if (!xdr_int (xdrs, &objp->cyls))
1650                                  return FALSE;
1651                          if (!xdr_int (xdrs, &objp->heads))
1652                                  return FALSE;
1653                          if (!xdr_int (xdrs, &objp->sectors))
1654                                  return FALSE;
1655
1656                 } else {
1657                 IXDR_PUT_LONG(buf, objp->partnum);
1658                 IXDR_PUT_LONG(buf, objp->cyls);
1659                 IXDR_PUT_LONG(buf, objp->heads);
1660                 IXDR_PUT_LONG(buf, objp->sectors);
1661                 }
1662                  if (!xdr_string (xdrs, &objp->line, ~0))
1663                          return FALSE;
1664                 return TRUE;
1665         } else if (xdrs->x_op == XDR_DECODE) {
1666                  if (!xdr_string (xdrs, &objp->device, ~0))
1667                          return FALSE;
1668                 buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
1669                 if (buf == NULL) {
1670                          if (!xdr_int (xdrs, &objp->partnum))
1671                                  return FALSE;
1672                          if (!xdr_int (xdrs, &objp->cyls))
1673                                  return FALSE;
1674                          if (!xdr_int (xdrs, &objp->heads))
1675                                  return FALSE;
1676                          if (!xdr_int (xdrs, &objp->sectors))
1677                                  return FALSE;
1678
1679                 } else {
1680                 objp->partnum = IXDR_GET_LONG(buf);
1681                 objp->cyls = IXDR_GET_LONG(buf);
1682                 objp->heads = IXDR_GET_LONG(buf);
1683                 objp->sectors = IXDR_GET_LONG(buf);
1684                 }
1685                  if (!xdr_string (xdrs, &objp->line, ~0))
1686                          return FALSE;
1687          return TRUE;
1688         }
1689
1690          if (!xdr_string (xdrs, &objp->device, ~0))
1691                  return FALSE;
1692          if (!xdr_int (xdrs, &objp->partnum))
1693                  return FALSE;
1694          if (!xdr_int (xdrs, &objp->cyls))
1695                  return FALSE;
1696          if (!xdr_int (xdrs, &objp->heads))
1697                  return FALSE;
1698          if (!xdr_int (xdrs, &objp->sectors))
1699                  return FALSE;
1700          if (!xdr_string (xdrs, &objp->line, ~0))
1701                  return FALSE;
1702         return TRUE;
1703 }
1704
1705 bool_t
1706 xdr_guestfs_sfdisk_l_args (XDR *xdrs, guestfs_sfdisk_l_args *objp)
1707 {
1708         register int32_t *buf;
1709
1710          if (!xdr_string (xdrs, &objp->device, ~0))
1711                  return FALSE;
1712         return TRUE;
1713 }
1714
1715 bool_t
1716 xdr_guestfs_sfdisk_l_ret (XDR *xdrs, guestfs_sfdisk_l_ret *objp)
1717 {
1718         register int32_t *buf;
1719
1720          if (!xdr_string (xdrs, &objp->partitions, ~0))
1721                  return FALSE;
1722         return TRUE;
1723 }
1724
1725 bool_t
1726 xdr_guestfs_sfdisk_kernel_geometry_args (XDR *xdrs, guestfs_sfdisk_kernel_geometry_args *objp)
1727 {
1728         register int32_t *buf;
1729
1730          if (!xdr_string (xdrs, &objp->device, ~0))
1731                  return FALSE;
1732         return TRUE;
1733 }
1734
1735 bool_t
1736 xdr_guestfs_sfdisk_kernel_geometry_ret (XDR *xdrs, guestfs_sfdisk_kernel_geometry_ret *objp)
1737 {
1738         register int32_t *buf;
1739
1740          if (!xdr_string (xdrs, &objp->partitions, ~0))
1741                  return FALSE;
1742         return TRUE;
1743 }
1744
1745 bool_t
1746 xdr_guestfs_sfdisk_disk_geometry_args (XDR *xdrs, guestfs_sfdisk_disk_geometry_args *objp)
1747 {
1748         register int32_t *buf;
1749
1750          if (!xdr_string (xdrs, &objp->device, ~0))
1751                  return FALSE;
1752         return TRUE;
1753 }
1754
1755 bool_t
1756 xdr_guestfs_sfdisk_disk_geometry_ret (XDR *xdrs, guestfs_sfdisk_disk_geometry_ret *objp)
1757 {
1758         register int32_t *buf;
1759
1760          if (!xdr_string (xdrs, &objp->partitions, ~0))
1761                  return FALSE;
1762         return TRUE;
1763 }
1764
1765 bool_t
1766 xdr_guestfs_vg_activate_all_args (XDR *xdrs, guestfs_vg_activate_all_args *objp)
1767 {
1768         register int32_t *buf;
1769
1770          if (!xdr_bool (xdrs, &objp->activate))
1771                  return FALSE;
1772         return TRUE;
1773 }
1774
1775 bool_t
1776 xdr_guestfs_vg_activate_args (XDR *xdrs, guestfs_vg_activate_args *objp)
1777 {
1778         register int32_t *buf;
1779
1780          if (!xdr_bool (xdrs, &objp->activate))
1781                  return FALSE;
1782          if (!xdr_array (xdrs, (char **)&objp->volgroups.volgroups_val, (u_int *) &objp->volgroups.volgroups_len, ~0,
1783                 sizeof (str), (xdrproc_t) xdr_str))
1784                  return FALSE;
1785         return TRUE;
1786 }
1787
1788 bool_t
1789 xdr_guestfs_lvresize_args (XDR *xdrs, guestfs_lvresize_args *objp)
1790 {
1791         register int32_t *buf;
1792
1793          if (!xdr_string (xdrs, &objp->device, ~0))
1794                  return FALSE;
1795          if (!xdr_int (xdrs, &objp->mbytes))
1796                  return FALSE;
1797         return TRUE;
1798 }
1799
1800 bool_t
1801 xdr_guestfs_resize2fs_args (XDR *xdrs, guestfs_resize2fs_args *objp)
1802 {
1803         register int32_t *buf;
1804
1805          if (!xdr_string (xdrs, &objp->device, ~0))
1806                  return FALSE;
1807         return TRUE;
1808 }
1809
1810 bool_t
1811 xdr_guestfs_find_args (XDR *xdrs, guestfs_find_args *objp)
1812 {
1813         register int32_t *buf;
1814
1815          if (!xdr_string (xdrs, &objp->directory, ~0))
1816                  return FALSE;
1817         return TRUE;
1818 }
1819
1820 bool_t
1821 xdr_guestfs_find_ret (XDR *xdrs, guestfs_find_ret *objp)
1822 {
1823         register int32_t *buf;
1824
1825          if (!xdr_array (xdrs, (char **)&objp->names.names_val, (u_int *) &objp->names.names_len, ~0,
1826                 sizeof (str), (xdrproc_t) xdr_str))
1827                  return FALSE;
1828         return TRUE;
1829 }
1830
1831 bool_t
1832 xdr_guestfs_e2fsck_f_args (XDR *xdrs, guestfs_e2fsck_f_args *objp)
1833 {
1834         register int32_t *buf;
1835
1836          if (!xdr_string (xdrs, &objp->device, ~0))
1837                  return FALSE;
1838         return TRUE;
1839 }
1840
1841 bool_t
1842 xdr_guestfs_sleep_args (XDR *xdrs, guestfs_sleep_args *objp)
1843 {
1844         register int32_t *buf;
1845
1846          if (!xdr_int (xdrs, &objp->secs))
1847                  return FALSE;
1848         return TRUE;
1849 }
1850
1851 bool_t
1852 xdr_guestfs_ntfs_3g_probe_args (XDR *xdrs, guestfs_ntfs_3g_probe_args *objp)
1853 {
1854         register int32_t *buf;
1855
1856          if (!xdr_bool (xdrs, &objp->rw))
1857                  return FALSE;
1858          if (!xdr_string (xdrs, &objp->device, ~0))
1859                  return FALSE;
1860         return TRUE;
1861 }
1862
1863 bool_t
1864 xdr_guestfs_ntfs_3g_probe_ret (XDR *xdrs, guestfs_ntfs_3g_probe_ret *objp)
1865 {
1866         register int32_t *buf;
1867
1868          if (!xdr_int (xdrs, &objp->status))
1869                  return FALSE;
1870         return TRUE;
1871 }
1872
1873 bool_t
1874 xdr_guestfs_sh_args (XDR *xdrs, guestfs_sh_args *objp)
1875 {
1876         register int32_t *buf;
1877
1878          if (!xdr_string (xdrs, &objp->command, ~0))
1879                  return FALSE;
1880         return TRUE;
1881 }
1882
1883 bool_t
1884 xdr_guestfs_sh_ret (XDR *xdrs, guestfs_sh_ret *objp)
1885 {
1886         register int32_t *buf;
1887
1888          if (!xdr_string (xdrs, &objp->output, ~0))
1889                  return FALSE;
1890         return TRUE;
1891 }
1892
1893 bool_t
1894 xdr_guestfs_sh_lines_args (XDR *xdrs, guestfs_sh_lines_args *objp)
1895 {
1896         register int32_t *buf;
1897
1898          if (!xdr_string (xdrs, &objp->command, ~0))
1899                  return FALSE;
1900         return TRUE;
1901 }
1902
1903 bool_t
1904 xdr_guestfs_sh_lines_ret (XDR *xdrs, guestfs_sh_lines_ret *objp)
1905 {
1906         register int32_t *buf;
1907
1908          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
1909                 sizeof (str), (xdrproc_t) xdr_str))
1910                  return FALSE;
1911         return TRUE;
1912 }
1913
1914 bool_t
1915 xdr_guestfs_glob_expand_args (XDR *xdrs, guestfs_glob_expand_args *objp)
1916 {
1917         register int32_t *buf;
1918
1919          if (!xdr_string (xdrs, &objp->pattern, ~0))
1920                  return FALSE;
1921         return TRUE;
1922 }
1923
1924 bool_t
1925 xdr_guestfs_glob_expand_ret (XDR *xdrs, guestfs_glob_expand_ret *objp)
1926 {
1927         register int32_t *buf;
1928
1929          if (!xdr_array (xdrs, (char **)&objp->paths.paths_val, (u_int *) &objp->paths.paths_len, ~0,
1930                 sizeof (str), (xdrproc_t) xdr_str))
1931                  return FALSE;
1932         return TRUE;
1933 }
1934
1935 bool_t
1936 xdr_guestfs_scrub_device_args (XDR *xdrs, guestfs_scrub_device_args *objp)
1937 {
1938         register int32_t *buf;
1939
1940          if (!xdr_string (xdrs, &objp->device, ~0))
1941                  return FALSE;
1942         return TRUE;
1943 }
1944
1945 bool_t
1946 xdr_guestfs_scrub_file_args (XDR *xdrs, guestfs_scrub_file_args *objp)
1947 {
1948         register int32_t *buf;
1949
1950          if (!xdr_string (xdrs, &objp->file, ~0))
1951                  return FALSE;
1952         return TRUE;
1953 }
1954
1955 bool_t
1956 xdr_guestfs_scrub_freespace_args (XDR *xdrs, guestfs_scrub_freespace_args *objp)
1957 {
1958         register int32_t *buf;
1959
1960          if (!xdr_string (xdrs, &objp->dir, ~0))
1961                  return FALSE;
1962         return TRUE;
1963 }
1964
1965 bool_t
1966 xdr_guestfs_mkdtemp_args (XDR *xdrs, guestfs_mkdtemp_args *objp)
1967 {
1968         register int32_t *buf;
1969
1970          if (!xdr_string (xdrs, &objp->template, ~0))
1971                  return FALSE;
1972         return TRUE;
1973 }
1974
1975 bool_t
1976 xdr_guestfs_mkdtemp_ret (XDR *xdrs, guestfs_mkdtemp_ret *objp)
1977 {
1978         register int32_t *buf;
1979
1980          if (!xdr_string (xdrs, &objp->dir, ~0))
1981                  return FALSE;
1982         return TRUE;
1983 }
1984
1985 bool_t
1986 xdr_guestfs_wc_l_args (XDR *xdrs, guestfs_wc_l_args *objp)
1987 {
1988         register int32_t *buf;
1989
1990          if (!xdr_string (xdrs, &objp->path, ~0))
1991                  return FALSE;
1992         return TRUE;
1993 }
1994
1995 bool_t
1996 xdr_guestfs_wc_l_ret (XDR *xdrs, guestfs_wc_l_ret *objp)
1997 {
1998         register int32_t *buf;
1999
2000          if (!xdr_int (xdrs, &objp->lines))
2001                  return FALSE;
2002         return TRUE;
2003 }
2004
2005 bool_t
2006 xdr_guestfs_wc_w_args (XDR *xdrs, guestfs_wc_w_args *objp)
2007 {
2008         register int32_t *buf;
2009
2010          if (!xdr_string (xdrs, &objp->path, ~0))
2011                  return FALSE;
2012         return TRUE;
2013 }
2014
2015 bool_t
2016 xdr_guestfs_wc_w_ret (XDR *xdrs, guestfs_wc_w_ret *objp)
2017 {
2018         register int32_t *buf;
2019
2020          if (!xdr_int (xdrs, &objp->words))
2021                  return FALSE;
2022         return TRUE;
2023 }
2024
2025 bool_t
2026 xdr_guestfs_wc_c_args (XDR *xdrs, guestfs_wc_c_args *objp)
2027 {
2028         register int32_t *buf;
2029
2030          if (!xdr_string (xdrs, &objp->path, ~0))
2031                  return FALSE;
2032         return TRUE;
2033 }
2034
2035 bool_t
2036 xdr_guestfs_wc_c_ret (XDR *xdrs, guestfs_wc_c_ret *objp)
2037 {
2038         register int32_t *buf;
2039
2040          if (!xdr_int (xdrs, &objp->chars))
2041                  return FALSE;
2042         return TRUE;
2043 }
2044
2045 bool_t
2046 xdr_guestfs_head_args (XDR *xdrs, guestfs_head_args *objp)
2047 {
2048         register int32_t *buf;
2049
2050          if (!xdr_string (xdrs, &objp->path, ~0))
2051                  return FALSE;
2052         return TRUE;
2053 }
2054
2055 bool_t
2056 xdr_guestfs_head_ret (XDR *xdrs, guestfs_head_ret *objp)
2057 {
2058         register int32_t *buf;
2059
2060          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
2061                 sizeof (str), (xdrproc_t) xdr_str))
2062                  return FALSE;
2063         return TRUE;
2064 }
2065
2066 bool_t
2067 xdr_guestfs_head_n_args (XDR *xdrs, guestfs_head_n_args *objp)
2068 {
2069         register int32_t *buf;
2070
2071          if (!xdr_int (xdrs, &objp->nrlines))
2072                  return FALSE;
2073          if (!xdr_string (xdrs, &objp->path, ~0))
2074                  return FALSE;
2075         return TRUE;
2076 }
2077
2078 bool_t
2079 xdr_guestfs_head_n_ret (XDR *xdrs, guestfs_head_n_ret *objp)
2080 {
2081         register int32_t *buf;
2082
2083          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
2084                 sizeof (str), (xdrproc_t) xdr_str))
2085                  return FALSE;
2086         return TRUE;
2087 }
2088
2089 bool_t
2090 xdr_guestfs_tail_args (XDR *xdrs, guestfs_tail_args *objp)
2091 {
2092         register int32_t *buf;
2093
2094          if (!xdr_string (xdrs, &objp->path, ~0))
2095                  return FALSE;
2096         return TRUE;
2097 }
2098
2099 bool_t
2100 xdr_guestfs_tail_ret (XDR *xdrs, guestfs_tail_ret *objp)
2101 {
2102         register int32_t *buf;
2103
2104          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
2105                 sizeof (str), (xdrproc_t) xdr_str))
2106                  return FALSE;
2107         return TRUE;
2108 }
2109
2110 bool_t
2111 xdr_guestfs_tail_n_args (XDR *xdrs, guestfs_tail_n_args *objp)
2112 {
2113         register int32_t *buf;
2114
2115          if (!xdr_int (xdrs, &objp->nrlines))
2116                  return FALSE;
2117          if (!xdr_string (xdrs, &objp->path, ~0))
2118                  return FALSE;
2119         return TRUE;
2120 }
2121
2122 bool_t
2123 xdr_guestfs_tail_n_ret (XDR *xdrs, guestfs_tail_n_ret *objp)
2124 {
2125         register int32_t *buf;
2126
2127          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
2128                 sizeof (str), (xdrproc_t) xdr_str))
2129                  return FALSE;
2130         return TRUE;
2131 }
2132
2133 bool_t
2134 xdr_guestfs_df_ret (XDR *xdrs, guestfs_df_ret *objp)
2135 {
2136         register int32_t *buf;
2137
2138          if (!xdr_string (xdrs, &objp->output, ~0))
2139                  return FALSE;
2140         return TRUE;
2141 }
2142
2143 bool_t
2144 xdr_guestfs_df_h_ret (XDR *xdrs, guestfs_df_h_ret *objp)
2145 {
2146         register int32_t *buf;
2147
2148          if (!xdr_string (xdrs, &objp->output, ~0))
2149                  return FALSE;
2150         return TRUE;
2151 }
2152
2153 bool_t
2154 xdr_guestfs_du_args (XDR *xdrs, guestfs_du_args *objp)
2155 {
2156         register int32_t *buf;
2157
2158          if (!xdr_string (xdrs, &objp->path, ~0))
2159                  return FALSE;
2160         return TRUE;
2161 }
2162
2163 bool_t
2164 xdr_guestfs_du_ret (XDR *xdrs, guestfs_du_ret *objp)
2165 {
2166         register int32_t *buf;
2167
2168          if (!xdr_quad_t (xdrs, &objp->sizekb))
2169                  return FALSE;
2170         return TRUE;
2171 }
2172
2173 bool_t
2174 xdr_guestfs_initrd_list_args (XDR *xdrs, guestfs_initrd_list_args *objp)
2175 {
2176         register int32_t *buf;
2177
2178          if (!xdr_string (xdrs, &objp->path, ~0))
2179                  return FALSE;
2180         return TRUE;
2181 }
2182
2183 bool_t
2184 xdr_guestfs_initrd_list_ret (XDR *xdrs, guestfs_initrd_list_ret *objp)
2185 {
2186         register int32_t *buf;
2187
2188          if (!xdr_array (xdrs, (char **)&objp->filenames.filenames_val, (u_int *) &objp->filenames.filenames_len, ~0,
2189                 sizeof (str), (xdrproc_t) xdr_str))
2190                  return FALSE;
2191         return TRUE;
2192 }
2193
2194 bool_t
2195 xdr_guestfs_mount_loop_args (XDR *xdrs, guestfs_mount_loop_args *objp)
2196 {
2197         register int32_t *buf;
2198
2199          if (!xdr_string (xdrs, &objp->file, ~0))
2200                  return FALSE;
2201          if (!xdr_string (xdrs, &objp->mountpoint, ~0))
2202                  return FALSE;
2203         return TRUE;
2204 }
2205
2206 bool_t
2207 xdr_guestfs_mkswap_args (XDR *xdrs, guestfs_mkswap_args *objp)
2208 {
2209         register int32_t *buf;
2210
2211          if (!xdr_string (xdrs, &objp->device, ~0))
2212                  return FALSE;
2213         return TRUE;
2214 }
2215
2216 bool_t
2217 xdr_guestfs_mkswap_L_args (XDR *xdrs, guestfs_mkswap_L_args *objp)
2218 {
2219         register int32_t *buf;
2220
2221          if (!xdr_string (xdrs, &objp->label, ~0))
2222                  return FALSE;
2223          if (!xdr_string (xdrs, &objp->device, ~0))
2224                  return FALSE;
2225         return TRUE;
2226 }
2227
2228 bool_t
2229 xdr_guestfs_mkswap_U_args (XDR *xdrs, guestfs_mkswap_U_args *objp)
2230 {
2231         register int32_t *buf;
2232
2233          if (!xdr_string (xdrs, &objp->uuid, ~0))
2234                  return FALSE;
2235          if (!xdr_string (xdrs, &objp->device, ~0))
2236                  return FALSE;
2237         return TRUE;
2238 }
2239
2240 bool_t
2241 xdr_guestfs_procedure (XDR *xdrs, guestfs_procedure *objp)
2242 {
2243         register int32_t *buf;
2244
2245          if (!xdr_enum (xdrs, (enum_t *) objp))
2246                  return FALSE;
2247         return TRUE;
2248 }
2249
2250 bool_t
2251 xdr_guestfs_message_direction (XDR *xdrs, guestfs_message_direction *objp)
2252 {
2253         register int32_t *buf;
2254
2255          if (!xdr_enum (xdrs, (enum_t *) objp))
2256                  return FALSE;
2257         return TRUE;
2258 }
2259
2260 bool_t
2261 xdr_guestfs_message_status (XDR *xdrs, guestfs_message_status *objp)
2262 {
2263         register int32_t *buf;
2264
2265          if (!xdr_enum (xdrs, (enum_t *) objp))
2266                  return FALSE;
2267         return TRUE;
2268 }
2269
2270 bool_t
2271 xdr_guestfs_message_error (XDR *xdrs, guestfs_message_error *objp)
2272 {
2273         register int32_t *buf;
2274
2275          if (!xdr_string (xdrs, &objp->error_message, GUESTFS_ERROR_LEN))
2276                  return FALSE;
2277         return TRUE;
2278 }
2279
2280 bool_t
2281 xdr_guestfs_message_header (XDR *xdrs, guestfs_message_header *objp)
2282 {
2283         register int32_t *buf;
2284
2285          if (!xdr_u_int (xdrs, &objp->prog))
2286                  return FALSE;
2287          if (!xdr_u_int (xdrs, &objp->vers))
2288                  return FALSE;
2289          if (!xdr_guestfs_procedure (xdrs, &objp->proc))
2290                  return FALSE;
2291          if (!xdr_guestfs_message_direction (xdrs, &objp->direction))
2292                  return FALSE;
2293          if (!xdr_u_int (xdrs, &objp->serial))
2294                  return FALSE;
2295          if (!xdr_guestfs_message_status (xdrs, &objp->status))
2296                  return FALSE;
2297         return TRUE;
2298 }
2299
2300 bool_t
2301 xdr_guestfs_chunk (XDR *xdrs, guestfs_chunk *objp)
2302 {
2303         register int32_t *buf;
2304
2305          if (!xdr_int (xdrs, &objp->cancel))
2306                  return FALSE;
2307          if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, GUESTFS_MAX_CHUNK_SIZE))
2308                  return FALSE;
2309         return TRUE;
2310 }