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_mount_args (XDR *xdrs, guestfs_mount_args *objp)
 178 {
 179         register int32_t *buf;
 180
 181          if (!xdr_string (xdrs, &objp->device, ~0))
 182                  return FALSE;
 183          if (!xdr_string (xdrs, &objp->mountpoint, ~0))
 184                  return FALSE;
 185         return TRUE;
 186 }
 187
 188 bool_t
 189 xdr_guestfs_touch_args (XDR *xdrs, guestfs_touch_args *objp)
 190 {
 191         register int32_t *buf;
 192
 193          if (!xdr_string (xdrs, &objp->path, ~0))
 194                  return FALSE;
 195         return TRUE;
 196 }
 197
 198 bool_t
 199 xdr_guestfs_cat_args (XDR *xdrs, guestfs_cat_args *objp)
 200 {
 201         register int32_t *buf;
 202
 203          if (!xdr_string (xdrs, &objp->path, ~0))
 204                  return FALSE;
 205         return TRUE;
 206 }
 207
 208 bool_t
 209 xdr_guestfs_cat_ret (XDR *xdrs, guestfs_cat_ret *objp)
 210 {
 211         register int32_t *buf;
 212
 213          if (!xdr_string (xdrs, &objp->content, ~0))
 214                  return FALSE;
 215         return TRUE;
 216 }
 217
 218 bool_t
 219 xdr_guestfs_ll_args (XDR *xdrs, guestfs_ll_args *objp)
 220 {
 221         register int32_t *buf;
 222
 223          if (!xdr_string (xdrs, &objp->directory, ~0))
 224                  return FALSE;
 225         return TRUE;
 226 }
 227
 228 bool_t
 229 xdr_guestfs_ll_ret (XDR *xdrs, guestfs_ll_ret *objp)
 230 {
 231         register int32_t *buf;
 232
 233          if (!xdr_string (xdrs, &objp->listing, ~0))
 234                  return FALSE;
 235         return TRUE;
 236 }
 237
 238 bool_t
 239 xdr_guestfs_ls_args (XDR *xdrs, guestfs_ls_args *objp)
 240 {
 241         register int32_t *buf;
 242
 243          if (!xdr_string (xdrs, &objp->directory, ~0))
 244                  return FALSE;
 245         return TRUE;
 246 }
 247
 248 bool_t
 249 xdr_guestfs_ls_ret (XDR *xdrs, guestfs_ls_ret *objp)
 250 {
 251         register int32_t *buf;
 252
 253          if (!xdr_array (xdrs, (char **)&objp->listing.listing_val, (u_int *) &objp->listing.listing_len, ~0,
 254                 sizeof (str), (xdrproc_t) xdr_str))
 255                  return FALSE;
 256         return TRUE;
 257 }
 258
 259 bool_t
 260 xdr_guestfs_list_devices_ret (XDR *xdrs, guestfs_list_devices_ret *objp)
 261 {
 262         register int32_t *buf;
 263
 264          if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
 265                 sizeof (str), (xdrproc_t) xdr_str))
 266                  return FALSE;
 267         return TRUE;
 268 }
 269
 270 bool_t
 271 xdr_guestfs_list_partitions_ret (XDR *xdrs, guestfs_list_partitions_ret *objp)
 272 {
 273         register int32_t *buf;
 274
 275          if (!xdr_array (xdrs, (char **)&objp->partitions.partitions_val, (u_int *) &objp->partitions.partitions_len, ~0,
 276                 sizeof (str), (xdrproc_t) xdr_str))
 277                  return FALSE;
 278         return TRUE;
 279 }
 280
 281 bool_t
 282 xdr_guestfs_pvs_ret (XDR *xdrs, guestfs_pvs_ret *objp)
 283 {
 284         register int32_t *buf;
 285
 286          if (!xdr_array (xdrs, (char **)&objp->physvols.physvols_val, (u_int *) &objp->physvols.physvols_len, ~0,
 287                 sizeof (str), (xdrproc_t) xdr_str))
 288                  return FALSE;
 289         return TRUE;
 290 }
 291
 292 bool_t
 293 xdr_guestfs_vgs_ret (XDR *xdrs, guestfs_vgs_ret *objp)
 294 {
 295         register int32_t *buf;
 296
 297          if (!xdr_array (xdrs, (char **)&objp->volgroups.volgroups_val, (u_int *) &objp->volgroups.volgroups_len, ~0,
 298                 sizeof (str), (xdrproc_t) xdr_str))
 299                  return FALSE;
 300         return TRUE;
 301 }
 302
 303 bool_t
 304 xdr_guestfs_lvs_ret (XDR *xdrs, guestfs_lvs_ret *objp)
 305 {
 306         register int32_t *buf;
 307
 308          if (!xdr_array (xdrs, (char **)&objp->logvols.logvols_val, (u_int *) &objp->logvols.logvols_len, ~0,
 309                 sizeof (str), (xdrproc_t) xdr_str))
 310                  return FALSE;
 311         return TRUE;
 312 }
 313
 314 bool_t
 315 xdr_guestfs_pvs_full_ret (XDR *xdrs, guestfs_pvs_full_ret *objp)
 316 {
 317         register int32_t *buf;
 318
 319          if (!xdr_guestfs_lvm_int_pv_list (xdrs, &objp->physvols))
 320                  return FALSE;
 321         return TRUE;
 322 }
 323
 324 bool_t
 325 xdr_guestfs_vgs_full_ret (XDR *xdrs, guestfs_vgs_full_ret *objp)
 326 {
 327         register int32_t *buf;
 328
 329          if (!xdr_guestfs_lvm_int_vg_list (xdrs, &objp->volgroups))
 330                  return FALSE;
 331         return TRUE;
 332 }
 333
 334 bool_t
 335 xdr_guestfs_lvs_full_ret (XDR *xdrs, guestfs_lvs_full_ret *objp)
 336 {
 337         register int32_t *buf;
 338
 339          if (!xdr_guestfs_lvm_int_lv_list (xdrs, &objp->logvols))
 340                  return FALSE;
 341         return TRUE;
 342 }
 343
 344 bool_t
 345 xdr_guestfs_read_lines_args (XDR *xdrs, guestfs_read_lines_args *objp)
 346 {
 347         register int32_t *buf;
 348
 349          if (!xdr_string (xdrs, &objp->path, ~0))
 350                  return FALSE;
 351         return TRUE;
 352 }
 353
 354 bool_t
 355 xdr_guestfs_read_lines_ret (XDR *xdrs, guestfs_read_lines_ret *objp)
 356 {
 357         register int32_t *buf;
 358
 359          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
 360                 sizeof (str), (xdrproc_t) xdr_str))
 361                  return FALSE;
 362         return TRUE;
 363 }
 364
 365 bool_t
 366 xdr_guestfs_aug_init_args (XDR *xdrs, guestfs_aug_init_args *objp)
 367 {
 368         register int32_t *buf;
 369
 370          if (!xdr_string (xdrs, &objp->root, ~0))
 371                  return FALSE;
 372          if (!xdr_int (xdrs, &objp->flags))
 373                  return FALSE;
 374         return TRUE;
 375 }
 376
 377 bool_t
 378 xdr_guestfs_aug_defvar_args (XDR *xdrs, guestfs_aug_defvar_args *objp)
 379 {
 380         register int32_t *buf;
 381
 382          if (!xdr_string (xdrs, &objp->name, ~0))
 383                  return FALSE;
 384          if (!xdr_pointer (xdrs, (char **)&objp->expr, sizeof (str), (xdrproc_t) xdr_str))
 385                  return FALSE;
 386         return TRUE;
 387 }
 388
 389 bool_t
 390 xdr_guestfs_aug_defvar_ret (XDR *xdrs, guestfs_aug_defvar_ret *objp)
 391 {
 392         register int32_t *buf;
 393
 394          if (!xdr_int (xdrs, &objp->nrnodes))
 395                  return FALSE;
 396         return TRUE;
 397 }
 398
 399 bool_t
 400 xdr_guestfs_aug_defnode_args (XDR *xdrs, guestfs_aug_defnode_args *objp)
 401 {
 402         register int32_t *buf;
 403
 404          if (!xdr_string (xdrs, &objp->name, ~0))
 405                  return FALSE;
 406          if (!xdr_string (xdrs, &objp->expr, ~0))
 407                  return FALSE;
 408          if (!xdr_string (xdrs, &objp->val, ~0))
 409                  return FALSE;
 410         return TRUE;
 411 }
 412
 413 bool_t
 414 xdr_guestfs_aug_defnode_ret (XDR *xdrs, guestfs_aug_defnode_ret *objp)
 415 {
 416         register int32_t *buf;
 417
 418          if (!xdr_int (xdrs, &objp->nrnodes))
 419                  return FALSE;
 420          if (!xdr_bool (xdrs, &objp->created))
 421                  return FALSE;
 422         return TRUE;
 423 }
 424
 425 bool_t
 426 xdr_guestfs_aug_get_args (XDR *xdrs, guestfs_aug_get_args *objp)
 427 {
 428         register int32_t *buf;
 429
 430          if (!xdr_string (xdrs, &objp->path, ~0))
 431                  return FALSE;
 432         return TRUE;
 433 }
 434
 435 bool_t
 436 xdr_guestfs_aug_get_ret (XDR *xdrs, guestfs_aug_get_ret *objp)
 437 {
 438         register int32_t *buf;
 439
 440          if (!xdr_string (xdrs, &objp->val, ~0))
 441                  return FALSE;
 442         return TRUE;
 443 }
 444
 445 bool_t
 446 xdr_guestfs_aug_set_args (XDR *xdrs, guestfs_aug_set_args *objp)
 447 {
 448         register int32_t *buf;
 449
 450          if (!xdr_string (xdrs, &objp->path, ~0))
 451                  return FALSE;
 452          if (!xdr_string (xdrs, &objp->val, ~0))
 453                  return FALSE;
 454         return TRUE;
 455 }
 456
 457 bool_t
 458 xdr_guestfs_aug_insert_args (XDR *xdrs, guestfs_aug_insert_args *objp)
 459 {
 460         register int32_t *buf;
 461
 462          if (!xdr_string (xdrs, &objp->path, ~0))
 463                  return FALSE;
 464          if (!xdr_string (xdrs, &objp->label, ~0))
 465                  return FALSE;
 466          if (!xdr_bool (xdrs, &objp->before))
 467                  return FALSE;
 468         return TRUE;
 469 }
 470
 471 bool_t
 472 xdr_guestfs_aug_rm_args (XDR *xdrs, guestfs_aug_rm_args *objp)
 473 {
 474         register int32_t *buf;
 475
 476          if (!xdr_string (xdrs, &objp->path, ~0))
 477                  return FALSE;
 478         return TRUE;
 479 }
 480
 481 bool_t
 482 xdr_guestfs_aug_rm_ret (XDR *xdrs, guestfs_aug_rm_ret *objp)
 483 {
 484         register int32_t *buf;
 485
 486          if (!xdr_int (xdrs, &objp->nrnodes))
 487                  return FALSE;
 488         return TRUE;
 489 }
 490
 491 bool_t
 492 xdr_guestfs_aug_mv_args (XDR *xdrs, guestfs_aug_mv_args *objp)
 493 {
 494         register int32_t *buf;
 495
 496          if (!xdr_string (xdrs, &objp->src, ~0))
 497                  return FALSE;
 498          if (!xdr_string (xdrs, &objp->dest, ~0))
 499                  return FALSE;
 500         return TRUE;
 501 }
 502
 503 bool_t
 504 xdr_guestfs_aug_match_args (XDR *xdrs, guestfs_aug_match_args *objp)
 505 {
 506         register int32_t *buf;
 507
 508          if (!xdr_string (xdrs, &objp->path, ~0))
 509                  return FALSE;
 510         return TRUE;
 511 }
 512
 513 bool_t
 514 xdr_guestfs_aug_match_ret (XDR *xdrs, guestfs_aug_match_ret *objp)
 515 {
 516         register int32_t *buf;
 517
 518          if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
 519                 sizeof (str), (xdrproc_t) xdr_str))
 520                  return FALSE;
 521         return TRUE;
 522 }
 523
 524 bool_t
 525 xdr_guestfs_aug_ls_args (XDR *xdrs, guestfs_aug_ls_args *objp)
 526 {
 527         register int32_t *buf;
 528
 529          if (!xdr_string (xdrs, &objp->path, ~0))
 530                  return FALSE;
 531         return TRUE;
 532 }
 533
 534 bool_t
 535 xdr_guestfs_aug_ls_ret (XDR *xdrs, guestfs_aug_ls_ret *objp)
 536 {
 537         register int32_t *buf;
 538
 539          if (!xdr_array (xdrs, (char **)&objp->matches.matches_val, (u_int *) &objp->matches.matches_len, ~0,
 540                 sizeof (str), (xdrproc_t) xdr_str))
 541                  return FALSE;
 542         return TRUE;
 543 }
 544
 545 bool_t
 546 xdr_guestfs_rm_args (XDR *xdrs, guestfs_rm_args *objp)
 547 {
 548         register int32_t *buf;
 549
 550          if (!xdr_string (xdrs, &objp->path, ~0))
 551                  return FALSE;
 552         return TRUE;
 553 }
 554
 555 bool_t
 556 xdr_guestfs_rmdir_args (XDR *xdrs, guestfs_rmdir_args *objp)
 557 {
 558         register int32_t *buf;
 559
 560          if (!xdr_string (xdrs, &objp->path, ~0))
 561                  return FALSE;
 562         return TRUE;
 563 }
 564
 565 bool_t
 566 xdr_guestfs_rm_rf_args (XDR *xdrs, guestfs_rm_rf_args *objp)
 567 {
 568         register int32_t *buf;
 569
 570          if (!xdr_string (xdrs, &objp->path, ~0))
 571                  return FALSE;
 572         return TRUE;
 573 }
 574
 575 bool_t
 576 xdr_guestfs_mkdir_args (XDR *xdrs, guestfs_mkdir_args *objp)
 577 {
 578         register int32_t *buf;
 579
 580          if (!xdr_string (xdrs, &objp->path, ~0))
 581                  return FALSE;
 582         return TRUE;
 583 }
 584
 585 bool_t
 586 xdr_guestfs_mkdir_p_args (XDR *xdrs, guestfs_mkdir_p_args *objp)
 587 {
 588         register int32_t *buf;
 589
 590          if (!xdr_string (xdrs, &objp->path, ~0))
 591                  return FALSE;
 592         return TRUE;
 593 }
 594
 595 bool_t
 596 xdr_guestfs_chmod_args (XDR *xdrs, guestfs_chmod_args *objp)
 597 {
 598         register int32_t *buf;
 599
 600          if (!xdr_int (xdrs, &objp->mode))
 601                  return FALSE;
 602          if (!xdr_string (xdrs, &objp->path, ~0))
 603                  return FALSE;
 604         return TRUE;
 605 }
 606
 607 bool_t
 608 xdr_guestfs_chown_args (XDR *xdrs, guestfs_chown_args *objp)
 609 {
 610         register int32_t *buf;
 611
 612          if (!xdr_int (xdrs, &objp->owner))
 613                  return FALSE;
 614          if (!xdr_int (xdrs, &objp->group))
 615                  return FALSE;
 616          if (!xdr_string (xdrs, &objp->path, ~0))
 617                  return FALSE;
 618         return TRUE;
 619 }
 620
 621 bool_t
 622 xdr_guestfs_exists_args (XDR *xdrs, guestfs_exists_args *objp)
 623 {
 624         register int32_t *buf;
 625
 626          if (!xdr_string (xdrs, &objp->path, ~0))
 627                  return FALSE;
 628         return TRUE;
 629 }
 630
 631 bool_t
 632 xdr_guestfs_exists_ret (XDR *xdrs, guestfs_exists_ret *objp)
 633 {
 634         register int32_t *buf;
 635
 636          if (!xdr_bool (xdrs, &objp->existsflag))
 637                  return FALSE;
 638         return TRUE;
 639 }
 640
 641 bool_t
 642 xdr_guestfs_is_file_args (XDR *xdrs, guestfs_is_file_args *objp)
 643 {
 644         register int32_t *buf;
 645
 646          if (!xdr_string (xdrs, &objp->path, ~0))
 647                  return FALSE;
 648         return TRUE;
 649 }
 650
 651 bool_t
 652 xdr_guestfs_is_file_ret (XDR *xdrs, guestfs_is_file_ret *objp)
 653 {
 654         register int32_t *buf;
 655
 656          if (!xdr_bool (xdrs, &objp->fileflag))
 657                  return FALSE;
 658         return TRUE;
 659 }
 660
 661 bool_t
 662 xdr_guestfs_is_dir_args (XDR *xdrs, guestfs_is_dir_args *objp)
 663 {
 664         register int32_t *buf;
 665
 666          if (!xdr_string (xdrs, &objp->path, ~0))
 667                  return FALSE;
 668         return TRUE;
 669 }
 670
 671 bool_t
 672 xdr_guestfs_is_dir_ret (XDR *xdrs, guestfs_is_dir_ret *objp)
 673 {
 674         register int32_t *buf;
 675
 676          if (!xdr_bool (xdrs, &objp->dirflag))
 677                  return FALSE;
 678         return TRUE;
 679 }
 680
 681 bool_t
 682 xdr_guestfs_pvcreate_args (XDR *xdrs, guestfs_pvcreate_args *objp)
 683 {
 684         register int32_t *buf;
 685
 686          if (!xdr_string (xdrs, &objp->device, ~0))
 687                  return FALSE;
 688         return TRUE;
 689 }
 690
 691 bool_t
 692 xdr_guestfs_vgcreate_args (XDR *xdrs, guestfs_vgcreate_args *objp)
 693 {
 694         register int32_t *buf;
 695
 696          if (!xdr_string (xdrs, &objp->volgroup, ~0))
 697                  return FALSE;
 698          if (!xdr_array (xdrs, (char **)&objp->physvols.physvols_val, (u_int *) &objp->physvols.physvols_len, ~0,
 699                 sizeof (str), (xdrproc_t) xdr_str))
 700                  return FALSE;
 701         return TRUE;
 702 }
 703
 704 bool_t
 705 xdr_guestfs_lvcreate_args (XDR *xdrs, guestfs_lvcreate_args *objp)
 706 {
 707         register int32_t *buf;
 708
 709          if (!xdr_string (xdrs, &objp->logvol, ~0))
 710                  return FALSE;
 711          if (!xdr_string (xdrs, &objp->volgroup, ~0))
 712                  return FALSE;
 713          if (!xdr_int (xdrs, &objp->mbytes))
 714                  return FALSE;
 715         return TRUE;
 716 }
 717
 718 bool_t
 719 xdr_guestfs_mkfs_args (XDR *xdrs, guestfs_mkfs_args *objp)
 720 {
 721         register int32_t *buf;
 722
 723          if (!xdr_string (xdrs, &objp->fstype, ~0))
 724                  return FALSE;
 725          if (!xdr_string (xdrs, &objp->device, ~0))
 726                  return FALSE;
 727         return TRUE;
 728 }
 729
 730 bool_t
 731 xdr_guestfs_sfdisk_args (XDR *xdrs, guestfs_sfdisk_args *objp)
 732 {
 733         register int32_t *buf;
 734
 735
 736         if (xdrs->x_op == XDR_ENCODE) {
 737                  if (!xdr_string (xdrs, &objp->device, ~0))
 738                          return FALSE;
 739                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
 740                 if (buf == NULL) {
 741                          if (!xdr_int (xdrs, &objp->cyls))
 742                                  return FALSE;
 743                          if (!xdr_int (xdrs, &objp->heads))
 744                                  return FALSE;
 745                          if (!xdr_int (xdrs, &objp->sectors))
 746                                  return FALSE;
 747
 748                 } else {
 749                 IXDR_PUT_LONG(buf, objp->cyls);
 750                 IXDR_PUT_LONG(buf, objp->heads);
 751                 IXDR_PUT_LONG(buf, objp->sectors);
 752                 }
 753                  if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
 754                         sizeof (str), (xdrproc_t) xdr_str))
 755                          return FALSE;
 756                 return TRUE;
 757         } else if (xdrs->x_op == XDR_DECODE) {
 758                  if (!xdr_string (xdrs, &objp->device, ~0))
 759                          return FALSE;
 760                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
 761                 if (buf == NULL) {
 762                          if (!xdr_int (xdrs, &objp->cyls))
 763                                  return FALSE;
 764                          if (!xdr_int (xdrs, &objp->heads))
 765                                  return FALSE;
 766                          if (!xdr_int (xdrs, &objp->sectors))
 767                                  return FALSE;
 768
 769                 } else {
 770                 objp->cyls = IXDR_GET_LONG(buf);
 771                 objp->heads = IXDR_GET_LONG(buf);
 772                 objp->sectors = IXDR_GET_LONG(buf);
 773                 }
 774                  if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
 775                         sizeof (str), (xdrproc_t) xdr_str))
 776                          return FALSE;
 777          return TRUE;
 778         }
 779
 780          if (!xdr_string (xdrs, &objp->device, ~0))
 781                  return FALSE;
 782          if (!xdr_int (xdrs, &objp->cyls))
 783                  return FALSE;
 784          if (!xdr_int (xdrs, &objp->heads))
 785                  return FALSE;
 786          if (!xdr_int (xdrs, &objp->sectors))
 787                  return FALSE;
 788          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
 789                 sizeof (str), (xdrproc_t) xdr_str))
 790                  return FALSE;
 791         return TRUE;
 792 }
 793
 794 bool_t
 795 xdr_guestfs_write_file_args (XDR *xdrs, guestfs_write_file_args *objp)
 796 {
 797         register int32_t *buf;
 798
 799          if (!xdr_string (xdrs, &objp->path, ~0))
 800                  return FALSE;
 801          if (!xdr_string (xdrs, &objp->content, ~0))
 802                  return FALSE;
 803          if (!xdr_int (xdrs, &objp->size))
 804                  return FALSE;
 805         return TRUE;
 806 }
 807
 808 bool_t
 809 xdr_guestfs_umount_args (XDR *xdrs, guestfs_umount_args *objp)
 810 {
 811         register int32_t *buf;
 812
 813          if (!xdr_string (xdrs, &objp->pathordevice, ~0))
 814                  return FALSE;
 815         return TRUE;
 816 }
 817
 818 bool_t
 819 xdr_guestfs_mounts_ret (XDR *xdrs, guestfs_mounts_ret *objp)
 820 {
 821         register int32_t *buf;
 822
 823          if (!xdr_array (xdrs, (char **)&objp->devices.devices_val, (u_int *) &objp->devices.devices_len, ~0,
 824                 sizeof (str), (xdrproc_t) xdr_str))
 825                  return FALSE;
 826         return TRUE;
 827 }
 828
 829 bool_t
 830 xdr_guestfs_file_args (XDR *xdrs, guestfs_file_args *objp)
 831 {
 832         register int32_t *buf;
 833
 834          if (!xdr_string (xdrs, &objp->path, ~0))
 835                  return FALSE;
 836         return TRUE;
 837 }
 838
 839 bool_t
 840 xdr_guestfs_file_ret (XDR *xdrs, guestfs_file_ret *objp)
 841 {
 842         register int32_t *buf;
 843
 844          if (!xdr_string (xdrs, &objp->description, ~0))
 845                  return FALSE;
 846         return TRUE;
 847 }
 848
 849 bool_t
 850 xdr_guestfs_command_args (XDR *xdrs, guestfs_command_args *objp)
 851 {
 852         register int32_t *buf;
 853
 854          if (!xdr_array (xdrs, (char **)&objp->arguments.arguments_val, (u_int *) &objp->arguments.arguments_len, ~0,
 855                 sizeof (str), (xdrproc_t) xdr_str))
 856                  return FALSE;
 857         return TRUE;
 858 }
 859
 860 bool_t
 861 xdr_guestfs_command_ret (XDR *xdrs, guestfs_command_ret *objp)
 862 {
 863         register int32_t *buf;
 864
 865          if (!xdr_string (xdrs, &objp->output, ~0))
 866                  return FALSE;
 867         return TRUE;
 868 }
 869
 870 bool_t
 871 xdr_guestfs_command_lines_args (XDR *xdrs, guestfs_command_lines_args *objp)
 872 {
 873         register int32_t *buf;
 874
 875          if (!xdr_array (xdrs, (char **)&objp->arguments.arguments_val, (u_int *) &objp->arguments.arguments_len, ~0,
 876                 sizeof (str), (xdrproc_t) xdr_str))
 877                  return FALSE;
 878         return TRUE;
 879 }
 880
 881 bool_t
 882 xdr_guestfs_command_lines_ret (XDR *xdrs, guestfs_command_lines_ret *objp)
 883 {
 884         register int32_t *buf;
 885
 886          if (!xdr_array (xdrs, (char **)&objp->lines.lines_val, (u_int *) &objp->lines.lines_len, ~0,
 887                 sizeof (str), (xdrproc_t) xdr_str))
 888                  return FALSE;
 889         return TRUE;
 890 }
 891
 892 bool_t
 893 xdr_guestfs_procedure (XDR *xdrs, guestfs_procedure *objp)
 894 {
 895         register int32_t *buf;
 896
 897          if (!xdr_enum (xdrs, (enum_t *) objp))
 898                  return FALSE;
 899         return TRUE;
 900 }
 901
 902 bool_t
 903 xdr_guestfs_message_direction (XDR *xdrs, guestfs_message_direction *objp)
 904 {
 905         register int32_t *buf;
 906
 907          if (!xdr_enum (xdrs, (enum_t *) objp))
 908                  return FALSE;
 909         return TRUE;
 910 }
 911
 912 bool_t
 913 xdr_guestfs_message_status (XDR *xdrs, guestfs_message_status *objp)
 914 {
 915         register int32_t *buf;
 916
 917          if (!xdr_enum (xdrs, (enum_t *) objp))
 918                  return FALSE;
 919         return TRUE;
 920 }
 921
 922 bool_t
 923 xdr_guestfs_message_error (XDR *xdrs, guestfs_message_error *objp)
 924 {
 925         register int32_t *buf;
 926
 927          if (!xdr_string (xdrs, &objp->error, GUESTFS_ERROR_LEN))
 928                  return FALSE;
 929         return TRUE;
 930 }
 931
 932 bool_t
 933 xdr_guestfs_message_header (XDR *xdrs, guestfs_message_header *objp)
 934 {
 935         register int32_t *buf;
 936
 937          if (!xdr_u_int (xdrs, &objp->prog))
 938                  return FALSE;
 939          if (!xdr_u_int (xdrs, &objp->vers))
 940                  return FALSE;
 941          if (!xdr_guestfs_procedure (xdrs, &objp->proc))
 942                  return FALSE;
 943          if (!xdr_guestfs_message_direction (xdrs, &objp->direction))
 944                  return FALSE;
 945          if (!xdr_u_int (xdrs, &objp->serial))
 946                  return FALSE;
 947          if (!xdr_guestfs_message_status (xdrs, &objp->status))
 948                  return FALSE;
 949         return TRUE;
 950 }