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_procedure (XDR *xdrs, guestfs_procedure *objp)
1039 {
1040         register int32_t *buf;
1041
1042          if (!xdr_enum (xdrs, (enum_t *) objp))
1043                  return FALSE;
1044         return TRUE;
1045 }
1046
1047 bool_t
1048 xdr_guestfs_message_direction (XDR *xdrs, guestfs_message_direction *objp)
1049 {
1050         register int32_t *buf;
1051
1052          if (!xdr_enum (xdrs, (enum_t *) objp))
1053                  return FALSE;
1054         return TRUE;
1055 }
1056
1057 bool_t
1058 xdr_guestfs_message_status (XDR *xdrs, guestfs_message_status *objp)
1059 {
1060         register int32_t *buf;
1061
1062          if (!xdr_enum (xdrs, (enum_t *) objp))
1063                  return FALSE;
1064         return TRUE;
1065 }
1066
1067 bool_t
1068 xdr_guestfs_message_error (XDR *xdrs, guestfs_message_error *objp)
1069 {
1070         register int32_t *buf;
1071
1072          if (!xdr_string (xdrs, &objp->error, GUESTFS_ERROR_LEN))
1073                  return FALSE;
1074         return TRUE;
1075 }
1076
1077 bool_t
1078 xdr_guestfs_message_header (XDR *xdrs, guestfs_message_header *objp)
1079 {
1080         register int32_t *buf;
1081
1082          if (!xdr_u_int (xdrs, &objp->prog))
1083                  return FALSE;
1084          if (!xdr_u_int (xdrs, &objp->vers))
1085                  return FALSE;
1086          if (!xdr_guestfs_procedure (xdrs, &objp->proc))
1087                  return FALSE;
1088          if (!xdr_guestfs_message_direction (xdrs, &objp->direction))
1089                  return FALSE;
1090          if (!xdr_u_int (xdrs, &objp->serial))
1091                  return FALSE;
1092          if (!xdr_guestfs_message_status (xdrs, &objp->status))
1093                  return FALSE;
1094         return TRUE;
1095 }