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 }