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