src/guestfs_protocol.c

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