git.gag.com Git - debian/amanda/blob - ndmp-src/ndmp4_xdr.c

   1 /*
   2  * Please do not edit this file.
   3  * It was generated using rpcgen.
   4  */
   5
   6 #include "ndmp4.h"
   7 #ifndef NDMOS_OPTION_NO_NDMP4
   8 #define ndmp4_u_quad unsigned long long
   9 extern bool_t xdr_ndmp4_u_quad();
  10
  11 bool_t
  12 xdr__ndmp4_u_quad (XDR *xdrs, _ndmp4_u_quad *objp)
  13 {
  14         register int32_t *buf;
  15
  16          if (!xdr_u_long (xdrs, &objp->high))
  17                  return FALSE;
  18          if (!xdr_u_long (xdrs, &objp->low))
  19                  return FALSE;
  20         return TRUE;
  21 }
  22
  23 bool_t
  24 xdr_ndmp4_header_message_type (XDR *xdrs, ndmp4_header_message_type *objp)
  25 {
  26         register int32_t *buf;
  27
  28          if (!xdr_enum (xdrs, (enum_t *) objp))
  29                  return FALSE;
  30         return TRUE;
  31 }
  32
  33 bool_t
  34 xdr_ndmp4_error (XDR *xdrs, ndmp4_error *objp)
  35 {
  36         register int32_t *buf;
  37
  38          if (!xdr_enum (xdrs, (enum_t *) objp))
  39                  return FALSE;
  40         return TRUE;
  41 }
  42
  43 bool_t
  44 xdr_ndmp4_message (XDR *xdrs, ndmp4_message *objp)
  45 {
  46         register int32_t *buf;
  47
  48          if (!xdr_enum (xdrs, (enum_t *) objp))
  49                  return FALSE;
  50         return TRUE;
  51 }
  52
  53 bool_t
  54 xdr_ndmp4_header (XDR *xdrs, ndmp4_header *objp)
  55 {
  56         register int32_t *buf;
  57
  58          if (!xdr_u_long (xdrs, &objp->sequence))
  59                  return FALSE;
  60          if (!xdr_u_long (xdrs, &objp->time_stamp))
  61                  return FALSE;
  62          if (!xdr_ndmp4_header_message_type (xdrs, &objp->message_type))
  63                  return FALSE;
  64          if (!xdr_ndmp4_message (xdrs, &objp->message_code))
  65                  return FALSE;
  66          if (!xdr_u_long (xdrs, &objp->reply_sequence))
  67                  return FALSE;
  68          if (!xdr_ndmp4_error (xdrs, &objp->error_code))
  69                  return FALSE;
  70         return TRUE;
  71 }
  72
  73 bool_t
  74 xdr_ndmp4_pval (XDR *xdrs, ndmp4_pval *objp)
  75 {
  76         register int32_t *buf;
  77
  78          if (!xdr_string (xdrs, &objp->name, ~0))
  79                  return FALSE;
  80          if (!xdr_string (xdrs, &objp->value, ~0))
  81                  return FALSE;
  82         return TRUE;
  83 }
  84
  85 bool_t
  86 xdr_ndmp4_connect_open_request (XDR *xdrs, ndmp4_connect_open_request *objp)
  87 {
  88         register int32_t *buf;
  89
  90          if (!xdr_u_short (xdrs, &objp->protocol_version))
  91                  return FALSE;
  92         return TRUE;
  93 }
  94
  95 bool_t
  96 xdr_ndmp4_connect_open_reply (XDR *xdrs, ndmp4_connect_open_reply *objp)
  97 {
  98         register int32_t *buf;
  99
 100          if (!xdr_ndmp4_error (xdrs, &objp->error))
 101                  return FALSE;
 102         return TRUE;
 103 }
 104
 105 bool_t
 106 xdr_ndmp4_auth_type (XDR *xdrs, ndmp4_auth_type *objp)
 107 {
 108         register int32_t *buf;
 109
 110          if (!xdr_enum (xdrs, (enum_t *) objp))
 111                  return FALSE;
 112         return TRUE;
 113 }
 114
 115 bool_t
 116 xdr_ndmp4_auth_text (XDR *xdrs, ndmp4_auth_text *objp)
 117 {
 118         register int32_t *buf;
 119
 120          if (!xdr_string (xdrs, &objp->auth_id, ~0))
 121                  return FALSE;
 122          if (!xdr_string (xdrs, &objp->auth_password, ~0))
 123                  return FALSE;
 124         return TRUE;
 125 }
 126
 127 bool_t
 128 xdr_ndmp4_auth_md5 (XDR *xdrs, ndmp4_auth_md5 *objp)
 129 {
 130         register int32_t *buf;
 131
 132         int i;
 133          if (!xdr_string (xdrs, &objp->auth_id, ~0))
 134                  return FALSE;
 135          if (!xdr_opaque (xdrs, objp->auth_digest, 16))
 136                  return FALSE;
 137         return TRUE;
 138 }
 139
 140 bool_t
 141 xdr_ndmp4_auth_data (XDR *xdrs, ndmp4_auth_data *objp)
 142 {
 143         register int32_t *buf;
 144
 145          if (!xdr_ndmp4_auth_type (xdrs, &objp->auth_type))
 146                  return FALSE;
 147         switch (objp->auth_type) {
 148         case NDMP4_AUTH_NONE:
 149                 break;
 150         case NDMP4_AUTH_TEXT:
 151                  if (!xdr_ndmp4_auth_text (xdrs, &objp->ndmp4_auth_data_u.auth_text))
 152                          return FALSE;
 153                 break;
 154         case NDMP4_AUTH_MD5:
 155                  if (!xdr_ndmp4_auth_md5 (xdrs, &objp->ndmp4_auth_data_u.auth_md5))
 156                          return FALSE;
 157                 break;
 158         default:
 159                 return FALSE;
 160         }
 161         return TRUE;
 162 }
 163
 164 bool_t
 165 xdr_ndmp4_auth_attr (XDR *xdrs, ndmp4_auth_attr *objp)
 166 {
 167         register int32_t *buf;
 168
 169          if (!xdr_ndmp4_auth_type (xdrs, &objp->auth_type))
 170                  return FALSE;
 171         switch (objp->auth_type) {
 172         case NDMP4_AUTH_NONE:
 173                 break;
 174         case NDMP4_AUTH_TEXT:
 175                 break;
 176         case NDMP4_AUTH_MD5:
 177                  if (!xdr_opaque (xdrs, objp->ndmp4_auth_attr_u.challenge, 64))
 178                          return FALSE;
 179                 break;
 180         default:
 181                 return FALSE;
 182         }
 183         return TRUE;
 184 }
 185
 186 bool_t
 187 xdr_ndmp4_connect_client_auth_request (XDR *xdrs, ndmp4_connect_client_auth_request *objp)
 188 {
 189         register int32_t *buf;
 190
 191          if (!xdr_ndmp4_auth_data (xdrs, &objp->auth_data))
 192                  return FALSE;
 193         return TRUE;
 194 }
 195
 196 bool_t
 197 xdr_ndmp4_connect_client_auth_reply (XDR *xdrs, ndmp4_connect_client_auth_reply *objp)
 198 {
 199         register int32_t *buf;
 200
 201          if (!xdr_ndmp4_error (xdrs, &objp->error))
 202                  return FALSE;
 203         return TRUE;
 204 }
 205
 206 bool_t
 207 xdr_ndmp4_connect_server_auth_request (XDR *xdrs, ndmp4_connect_server_auth_request *objp)
 208 {
 209         register int32_t *buf;
 210
 211          if (!xdr_ndmp4_auth_attr (xdrs, &objp->client_attr))
 212                  return FALSE;
 213         return TRUE;
 214 }
 215
 216 bool_t
 217 xdr_ndmp4_connect_server_auth_reply (XDR *xdrs, ndmp4_connect_server_auth_reply *objp)
 218 {
 219         register int32_t *buf;
 220
 221          if (!xdr_ndmp4_error (xdrs, &objp->error))
 222                  return FALSE;
 223          if (!xdr_ndmp4_auth_data (xdrs, &objp->server_result))
 224                  return FALSE;
 225         return TRUE;
 226 }
 227
 228 bool_t
 229 xdr_ndmp4_config_get_host_info_reply (XDR *xdrs, ndmp4_config_get_host_info_reply *objp)
 230 {
 231         register int32_t *buf;
 232
 233          if (!xdr_ndmp4_error (xdrs, &objp->error))
 234                  return FALSE;
 235          if (!xdr_string (xdrs, &objp->hostname, ~0))
 236                  return FALSE;
 237          if (!xdr_string (xdrs, &objp->os_type, ~0))
 238                  return FALSE;
 239          if (!xdr_string (xdrs, &objp->os_vers, ~0))
 240                  return FALSE;
 241          if (!xdr_string (xdrs, &objp->hostid, ~0))
 242                  return FALSE;
 243         return TRUE;
 244 }
 245
 246 bool_t
 247 xdr_ndmp4_config_get_server_info_reply (XDR *xdrs, ndmp4_config_get_server_info_reply *objp)
 248 {
 249         register int32_t *buf;
 250
 251          if (!xdr_ndmp4_error (xdrs, &objp->error))
 252                  return FALSE;
 253          if (!xdr_string (xdrs, &objp->vendor_name, ~0))
 254                  return FALSE;
 255          if (!xdr_string (xdrs, &objp->product_name, ~0))
 256                  return FALSE;
 257          if (!xdr_string (xdrs, &objp->revision_number, ~0))
 258                  return FALSE;
 259          if (!xdr_array (xdrs, (char **)&objp->auth_type.auth_type_val, (u_int *) &objp->auth_type.auth_type_len, ~0,
 260                 sizeof (ndmp4_auth_type), (xdrproc_t) xdr_ndmp4_auth_type))
 261                  return FALSE;
 262         return TRUE;
 263 }
 264
 265 bool_t
 266 xdr_ndmp4_addr_type (XDR *xdrs, ndmp4_addr_type *objp)
 267 {
 268         register int32_t *buf;
 269
 270          if (!xdr_enum (xdrs, (enum_t *) objp))
 271                  return FALSE;
 272         return TRUE;
 273 }
 274
 275 bool_t
 276 xdr_ndmp4_config_get_connection_type_reply (XDR *xdrs, ndmp4_config_get_connection_type_reply *objp)
 277 {
 278         register int32_t *buf;
 279
 280          if (!xdr_ndmp4_error (xdrs, &objp->error))
 281                  return FALSE;
 282          if (!xdr_array (xdrs, (char **)&objp->addr_types.addr_types_val, (u_int *) &objp->addr_types.addr_types_len, ~0,
 283                 sizeof (ndmp4_addr_type), (xdrproc_t) xdr_ndmp4_addr_type))
 284                  return FALSE;
 285         return TRUE;
 286 }
 287
 288 bool_t
 289 xdr_ndmp4_config_get_auth_attr_request (XDR *xdrs, ndmp4_config_get_auth_attr_request *objp)
 290 {
 291         register int32_t *buf;
 292
 293          if (!xdr_ndmp4_auth_type (xdrs, &objp->auth_type))
 294                  return FALSE;
 295         return TRUE;
 296 }
 297
 298 bool_t
 299 xdr_ndmp4_config_get_auth_attr_reply (XDR *xdrs, ndmp4_config_get_auth_attr_reply *objp)
 300 {
 301         register int32_t *buf;
 302
 303          if (!xdr_ndmp4_error (xdrs, &objp->error))
 304                  return FALSE;
 305          if (!xdr_ndmp4_auth_attr (xdrs, &objp->server_attr))
 306                  return FALSE;
 307         return TRUE;
 308 }
 309
 310 bool_t
 311 xdr_ndmp4_butype_info (XDR *xdrs, ndmp4_butype_info *objp)
 312 {
 313         register int32_t *buf;
 314
 315          if (!xdr_string (xdrs, &objp->butype_name, ~0))
 316                  return FALSE;
 317          if (!xdr_array (xdrs, (char **)&objp->default_env.default_env_val, (u_int *) &objp->default_env.default_env_len, ~0,
 318                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
 319                  return FALSE;
 320          if (!xdr_u_long (xdrs, &objp->attrs))
 321                  return FALSE;
 322         return TRUE;
 323 }
 324
 325 bool_t
 326 xdr_ndmp4_config_get_butype_info_reply (XDR *xdrs, ndmp4_config_get_butype_info_reply *objp)
 327 {
 328         register int32_t *buf;
 329
 330          if (!xdr_ndmp4_error (xdrs, &objp->error))
 331                  return FALSE;
 332          if (!xdr_array (xdrs, (char **)&objp->butype_info.butype_info_val, (u_int *) &objp->butype_info.butype_info_len, ~0,
 333                 sizeof (ndmp4_butype_info), (xdrproc_t) xdr_ndmp4_butype_info))
 334                  return FALSE;
 335         return TRUE;
 336 }
 337
 338 bool_t
 339 xdr_ndmp4_fs_info (XDR *xdrs, ndmp4_fs_info *objp)
 340 {
 341         register int32_t *buf;
 342
 343          if (!xdr_u_long (xdrs, &objp->unsupported))
 344                  return FALSE;
 345          if (!xdr_string (xdrs, &objp->fs_type, ~0))
 346                  return FALSE;
 347          if (!xdr_string (xdrs, &objp->fs_logical_device, ~0))
 348                  return FALSE;
 349          if (!xdr_string (xdrs, &objp->fs_physical_device, ~0))
 350                  return FALSE;
 351          if (!xdr_ndmp4_u_quad (xdrs, &objp->total_size))
 352                  return FALSE;
 353          if (!xdr_ndmp4_u_quad (xdrs, &objp->used_size))
 354                  return FALSE;
 355          if (!xdr_ndmp4_u_quad (xdrs, &objp->avail_size))
 356                  return FALSE;
 357          if (!xdr_ndmp4_u_quad (xdrs, &objp->total_inodes))
 358                  return FALSE;
 359          if (!xdr_ndmp4_u_quad (xdrs, &objp->used_inodes))
 360                  return FALSE;
 361          if (!xdr_array (xdrs, (char **)&objp->fs_env.fs_env_val, (u_int *) &objp->fs_env.fs_env_len, ~0,
 362                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
 363                  return FALSE;
 364          if (!xdr_string (xdrs, &objp->fs_status, ~0))
 365                  return FALSE;
 366         return TRUE;
 367 }
 368
 369 bool_t
 370 xdr_ndmp4_config_get_fs_info_reply (XDR *xdrs, ndmp4_config_get_fs_info_reply *objp)
 371 {
 372         register int32_t *buf;
 373
 374          if (!xdr_ndmp4_error (xdrs, &objp->error))
 375                  return FALSE;
 376          if (!xdr_array (xdrs, (char **)&objp->fs_info.fs_info_val, (u_int *) &objp->fs_info.fs_info_len, ~0,
 377                 sizeof (ndmp4_fs_info), (xdrproc_t) xdr_ndmp4_fs_info))
 378                  return FALSE;
 379         return TRUE;
 380 }
 381
 382 bool_t
 383 xdr_ndmp4_device_capability (XDR *xdrs, ndmp4_device_capability *objp)
 384 {
 385         register int32_t *buf;
 386
 387          if (!xdr_string (xdrs, &objp->device, ~0))
 388                  return FALSE;
 389          if (!xdr_u_long (xdrs, &objp->attr))
 390                  return FALSE;
 391          if (!xdr_array (xdrs, (char **)&objp->capability.capability_val, (u_int *) &objp->capability.capability_len, ~0,
 392                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
 393                  return FALSE;
 394         return TRUE;
 395 }
 396
 397 bool_t
 398 xdr_ndmp4_device_info (XDR *xdrs, ndmp4_device_info *objp)
 399 {
 400         register int32_t *buf;
 401
 402          if (!xdr_string (xdrs, &objp->model, ~0))
 403                  return FALSE;
 404          if (!xdr_array (xdrs, (char **)&objp->caplist.caplist_val, (u_int *) &objp->caplist.caplist_len, ~0,
 405                 sizeof (ndmp4_device_capability), (xdrproc_t) xdr_ndmp4_device_capability))
 406                  return FALSE;
 407         return TRUE;
 408 }
 409
 410 bool_t
 411 xdr_ndmp4_config_get_tape_info_reply (XDR *xdrs, ndmp4_config_get_tape_info_reply *objp)
 412 {
 413         register int32_t *buf;
 414
 415          if (!xdr_ndmp4_error (xdrs, &objp->error))
 416                  return FALSE;
 417          if (!xdr_array (xdrs, (char **)&objp->tape_info.tape_info_val, (u_int *) &objp->tape_info.tape_info_len, ~0,
 418                 sizeof (ndmp4_device_info), (xdrproc_t) xdr_ndmp4_device_info))
 419                  return FALSE;
 420         return TRUE;
 421 }
 422
 423 bool_t
 424 xdr_ndmp4_config_get_scsi_info_reply (XDR *xdrs, ndmp4_config_get_scsi_info_reply *objp)
 425 {
 426         register int32_t *buf;
 427
 428          if (!xdr_ndmp4_error (xdrs, &objp->error))
 429                  return FALSE;
 430          if (!xdr_array (xdrs, (char **)&objp->scsi_info.scsi_info_val, (u_int *) &objp->scsi_info.scsi_info_len, ~0,
 431                 sizeof (ndmp4_device_info), (xdrproc_t) xdr_ndmp4_device_info))
 432                  return FALSE;
 433         return TRUE;
 434 }
 435
 436 bool_t
 437 xdr_ndmp4_class_list (XDR *xdrs, ndmp4_class_list *objp)
 438 {
 439         register int32_t *buf;
 440
 441          if (!xdr_u_short (xdrs, &objp->class_id))
 442                  return FALSE;
 443          if (!xdr_array (xdrs, (char **)&objp->class_version.class_version_val, (u_int *) &objp->class_version.class_version_len, ~0,
 444                 sizeof (u_short), (xdrproc_t) xdr_u_short))
 445                  return FALSE;
 446         return TRUE;
 447 }
 448
 449 bool_t
 450 xdr_ndmp4_class_version (XDR *xdrs, ndmp4_class_version *objp)
 451 {
 452         register int32_t *buf;
 453
 454          if (!xdr_u_short (xdrs, &objp->class_id))
 455                  return FALSE;
 456          if (!xdr_u_short (xdrs, &objp->class_version))
 457                  return FALSE;
 458         return TRUE;
 459 }
 460
 461 bool_t
 462 xdr_ndmp4_config_get_ext_list_reply (XDR *xdrs, ndmp4_config_get_ext_list_reply *objp)
 463 {
 464         register int32_t *buf;
 465
 466          if (!xdr_ndmp4_error (xdrs, &objp->error))
 467                  return FALSE;
 468          if (!xdr_array (xdrs, (char **)&objp->class_list.class_list_val, (u_int *) &objp->class_list.class_list_len, ~0,
 469                 sizeof (ndmp4_class_list), (xdrproc_t) xdr_ndmp4_class_list))
 470                  return FALSE;
 471         return TRUE;
 472 }
 473
 474 bool_t
 475 xdr_ndmp4_config_set_ext_list_request (XDR *xdrs, ndmp4_config_set_ext_list_request *objp)
 476 {
 477         register int32_t *buf;
 478
 479          if (!xdr_ndmp4_error (xdrs, &objp->error))
 480                  return FALSE;
 481          if (!xdr_array (xdrs, (char **)&objp->ndmp4_accepted_ext.ndmp4_accepted_ext_val, (u_int *) &objp->ndmp4_accepted_ext.ndmp4_accepted_ext_len, ~0,
 482                 sizeof (ndmp4_class_list), (xdrproc_t) xdr_ndmp4_class_list))
 483                  return FALSE;
 484         return TRUE;
 485 }
 486
 487 bool_t
 488 xdr_ndmp4_config_set_ext_list_reply (XDR *xdrs, ndmp4_config_set_ext_list_reply *objp)
 489 {
 490         register int32_t *buf;
 491
 492          if (!xdr_ndmp4_error (xdrs, &objp->error))
 493                  return FALSE;
 494         return TRUE;
 495 }
 496
 497 bool_t
 498 xdr_ndmp4_scsi_open_request (XDR *xdrs, ndmp4_scsi_open_request *objp)
 499 {
 500         register int32_t *buf;
 501
 502          if (!xdr_string (xdrs, &objp->device, ~0))
 503                  return FALSE;
 504         return TRUE;
 505 }
 506
 507 bool_t
 508 xdr_ndmp4_scsi_open_reply (XDR *xdrs, ndmp4_scsi_open_reply *objp)
 509 {
 510         register int32_t *buf;
 511
 512          if (!xdr_ndmp4_error (xdrs, &objp->error))
 513                  return FALSE;
 514         return TRUE;
 515 }
 516
 517 bool_t
 518 xdr_ndmp4_scsi_close_reply (XDR *xdrs, ndmp4_scsi_close_reply *objp)
 519 {
 520         register int32_t *buf;
 521
 522          if (!xdr_ndmp4_error (xdrs, &objp->error))
 523                  return FALSE;
 524         return TRUE;
 525 }
 526
 527 bool_t
 528 xdr_ndmp4_scsi_get_state_reply (XDR *xdrs, ndmp4_scsi_get_state_reply *objp)
 529 {
 530         register int32_t *buf;
 531
 532          if (!xdr_ndmp4_error (xdrs, &objp->error))
 533                  return FALSE;
 534          if (!xdr_short (xdrs, &objp->target_controller))
 535                  return FALSE;
 536          if (!xdr_short (xdrs, &objp->target_id))
 537                  return FALSE;
 538          if (!xdr_short (xdrs, &objp->target_lun))
 539                  return FALSE;
 540         return TRUE;
 541 }
 542
 543 bool_t
 544 xdr_ndmp4_scsi_reset_device_reply (XDR *xdrs, ndmp4_scsi_reset_device_reply *objp)
 545 {
 546         register int32_t *buf;
 547
 548          if (!xdr_ndmp4_error (xdrs, &objp->error))
 549                  return FALSE;
 550         return TRUE;
 551 }
 552
 553 bool_t
 554 xdr_ndmp4_execute_cdb_request (XDR *xdrs, ndmp4_execute_cdb_request *objp)
 555 {
 556         register int32_t *buf;
 557
 558
 559         if (xdrs->x_op == XDR_ENCODE) {
 560                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
 561                 if (buf == NULL) {
 562                          if (!xdr_u_long (xdrs, &objp->flags))
 563                                  return FALSE;
 564                          if (!xdr_u_long (xdrs, &objp->timeout))
 565                                  return FALSE;
 566                          if (!xdr_u_long (xdrs, &objp->datain_len))
 567                                  return FALSE;
 568
 569                 } else {
 570                 IXDR_PUT_U_LONG(buf, objp->flags);
 571                 IXDR_PUT_U_LONG(buf, objp->timeout);
 572                 IXDR_PUT_U_LONG(buf, objp->datain_len);
 573                 }
 574                  if (!xdr_bytes (xdrs, (char **)&objp->cdb.cdb_val, (u_int *) &objp->cdb.cdb_len, ~0))
 575                          return FALSE;
 576                  if (!xdr_bytes (xdrs, (char **)&objp->dataout.dataout_val, (u_int *) &objp->dataout.dataout_len, ~0))
 577                          return FALSE;
 578                 return TRUE;
 579         } else if (xdrs->x_op == XDR_DECODE) {
 580                 buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
 581                 if (buf == NULL) {
 582                          if (!xdr_u_long (xdrs, &objp->flags))
 583                                  return FALSE;
 584                          if (!xdr_u_long (xdrs, &objp->timeout))
 585                                  return FALSE;
 586                          if (!xdr_u_long (xdrs, &objp->datain_len))
 587                                  return FALSE;
 588
 589                 } else {
 590                 objp->flags = IXDR_GET_U_LONG(buf);
 591                 objp->timeout = IXDR_GET_U_LONG(buf);
 592                 objp->datain_len = IXDR_GET_U_LONG(buf);
 593                 }
 594                  if (!xdr_bytes (xdrs, (char **)&objp->cdb.cdb_val, (u_int *) &objp->cdb.cdb_len, ~0))
 595                          return FALSE;
 596                  if (!xdr_bytes (xdrs, (char **)&objp->dataout.dataout_val, (u_int *) &objp->dataout.dataout_len, ~0))
 597                          return FALSE;
 598          return TRUE;
 599         }
 600
 601          if (!xdr_u_long (xdrs, &objp->flags))
 602                  return FALSE;
 603          if (!xdr_u_long (xdrs, &objp->timeout))
 604                  return FALSE;
 605          if (!xdr_u_long (xdrs, &objp->datain_len))
 606                  return FALSE;
 607          if (!xdr_bytes (xdrs, (char **)&objp->cdb.cdb_val, (u_int *) &objp->cdb.cdb_len, ~0))
 608                  return FALSE;
 609          if (!xdr_bytes (xdrs, (char **)&objp->dataout.dataout_val, (u_int *) &objp->dataout.dataout_len, ~0))
 610                  return FALSE;
 611         return TRUE;
 612 }
 613
 614 bool_t
 615 xdr_ndmp4_execute_cdb_reply (XDR *xdrs, ndmp4_execute_cdb_reply *objp)
 616 {
 617         register int32_t *buf;
 618
 619          if (!xdr_ndmp4_error (xdrs, &objp->error))
 620                  return FALSE;
 621          if (!xdr_u_char (xdrs, &objp->status))
 622                  return FALSE;
 623          if (!xdr_u_long (xdrs, &objp->dataout_len))
 624                  return FALSE;
 625          if (!xdr_bytes (xdrs, (char **)&objp->datain.datain_val, (u_int *) &objp->datain.datain_len, ~0))
 626                  return FALSE;
 627          if (!xdr_bytes (xdrs, (char **)&objp->ext_sense.ext_sense_val, (u_int *) &objp->ext_sense.ext_sense_len, ~0))
 628                  return FALSE;
 629         return TRUE;
 630 }
 631
 632 bool_t
 633 xdr_ndmp4_scsi_execute_cdb_request (XDR *xdrs, ndmp4_scsi_execute_cdb_request *objp)
 634 {
 635         register int32_t *buf;
 636
 637          if (!xdr_ndmp4_execute_cdb_request (xdrs, objp))
 638                  return FALSE;
 639         return TRUE;
 640 }
 641
 642 bool_t
 643 xdr_ndmp4_scsi_execute_cdb_reply (XDR *xdrs, ndmp4_scsi_execute_cdb_reply *objp)
 644 {
 645         register int32_t *buf;
 646
 647          if (!xdr_ndmp4_execute_cdb_reply (xdrs, objp))
 648                  return FALSE;
 649         return TRUE;
 650 }
 651
 652 bool_t
 653 xdr_ndmp4_tape_open_mode (XDR *xdrs, ndmp4_tape_open_mode *objp)
 654 {
 655         register int32_t *buf;
 656
 657          if (!xdr_enum (xdrs, (enum_t *) objp))
 658                  return FALSE;
 659         return TRUE;
 660 }
 661
 662 bool_t
 663 xdr_ndmp4_tape_open_request (XDR *xdrs, ndmp4_tape_open_request *objp)
 664 {
 665         register int32_t *buf;
 666
 667          if (!xdr_string (xdrs, &objp->device, ~0))
 668                  return FALSE;
 669          if (!xdr_ndmp4_tape_open_mode (xdrs, &objp->mode))
 670                  return FALSE;
 671         return TRUE;
 672 }
 673
 674 bool_t
 675 xdr_ndmp4_tape_open_reply (XDR *xdrs, ndmp4_tape_open_reply *objp)
 676 {
 677         register int32_t *buf;
 678
 679          if (!xdr_ndmp4_error (xdrs, &objp->error))
 680                  return FALSE;
 681         return TRUE;
 682 }
 683
 684 bool_t
 685 xdr_ndmp4_tape_close_reply (XDR *xdrs, ndmp4_tape_close_reply *objp)
 686 {
 687         register int32_t *buf;
 688
 689          if (!xdr_ndmp4_error (xdrs, &objp->error))
 690                  return FALSE;
 691         return TRUE;
 692 }
 693
 694 bool_t
 695 xdr_ndmp4_tape_get_state_reply (XDR *xdrs, ndmp4_tape_get_state_reply *objp)
 696 {
 697         register int32_t *buf;
 698
 699
 700         if (xdrs->x_op == XDR_ENCODE) {
 701                  if (!xdr_u_long (xdrs, &objp->unsupported))
 702                          return FALSE;
 703                  if (!xdr_ndmp4_error (xdrs, &objp->error))
 704                          return FALSE;
 705                 buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
 706                 if (buf == NULL) {
 707                          if (!xdr_u_long (xdrs, &objp->flags))
 708                                  return FALSE;
 709                          if (!xdr_u_long (xdrs, &objp->file_num))
 710                                  return FALSE;
 711                          if (!xdr_u_long (xdrs, &objp->soft_errors))
 712                                  return FALSE;
 713                          if (!xdr_u_long (xdrs, &objp->block_size))
 714                                  return FALSE;
 715                          if (!xdr_u_long (xdrs, &objp->blockno))
 716                                  return FALSE;
 717
 718                 } else {
 719                 IXDR_PUT_U_LONG(buf, objp->flags);
 720                 IXDR_PUT_U_LONG(buf, objp->file_num);
 721                 IXDR_PUT_U_LONG(buf, objp->soft_errors);
 722                 IXDR_PUT_U_LONG(buf, objp->block_size);
 723                 IXDR_PUT_U_LONG(buf, objp->blockno);
 724                 }
 725                  if (!xdr_ndmp4_u_quad (xdrs, &objp->total_space))
 726                          return FALSE;
 727                  if (!xdr_ndmp4_u_quad (xdrs, &objp->space_remain))
 728                          return FALSE;
 729                 return TRUE;
 730         } else if (xdrs->x_op == XDR_DECODE) {
 731                  if (!xdr_u_long (xdrs, &objp->unsupported))
 732                          return FALSE;
 733                  if (!xdr_ndmp4_error (xdrs, &objp->error))
 734                          return FALSE;
 735                 buf = XDR_INLINE (xdrs, 5 * BYTES_PER_XDR_UNIT);
 736                 if (buf == NULL) {
 737                          if (!xdr_u_long (xdrs, &objp->flags))
 738                                  return FALSE;
 739                          if (!xdr_u_long (xdrs, &objp->file_num))
 740                                  return FALSE;
 741                          if (!xdr_u_long (xdrs, &objp->soft_errors))
 742                                  return FALSE;
 743                          if (!xdr_u_long (xdrs, &objp->block_size))
 744                                  return FALSE;
 745                          if (!xdr_u_long (xdrs, &objp->blockno))
 746                                  return FALSE;
 747
 748                 } else {
 749                 objp->flags = IXDR_GET_U_LONG(buf);
 750                 objp->file_num = IXDR_GET_U_LONG(buf);
 751                 objp->soft_errors = IXDR_GET_U_LONG(buf);
 752                 objp->block_size = IXDR_GET_U_LONG(buf);
 753                 objp->blockno = IXDR_GET_U_LONG(buf);
 754                 }
 755                  if (!xdr_ndmp4_u_quad (xdrs, &objp->total_space))
 756                          return FALSE;
 757                  if (!xdr_ndmp4_u_quad (xdrs, &objp->space_remain))
 758                          return FALSE;
 759          return TRUE;
 760         }
 761
 762          if (!xdr_u_long (xdrs, &objp->unsupported))
 763                  return FALSE;
 764          if (!xdr_ndmp4_error (xdrs, &objp->error))
 765                  return FALSE;
 766          if (!xdr_u_long (xdrs, &objp->flags))
 767                  return FALSE;
 768          if (!xdr_u_long (xdrs, &objp->file_num))
 769                  return FALSE;
 770          if (!xdr_u_long (xdrs, &objp->soft_errors))
 771                  return FALSE;
 772          if (!xdr_u_long (xdrs, &objp->block_size))
 773                  return FALSE;
 774          if (!xdr_u_long (xdrs, &objp->blockno))
 775                  return FALSE;
 776          if (!xdr_ndmp4_u_quad (xdrs, &objp->total_space))
 777                  return FALSE;
 778          if (!xdr_ndmp4_u_quad (xdrs, &objp->space_remain))
 779                  return FALSE;
 780         return TRUE;
 781 }
 782
 783 bool_t
 784 xdr_ndmp4_tape_mtio_op (XDR *xdrs, ndmp4_tape_mtio_op *objp)
 785 {
 786         register int32_t *buf;
 787
 788          if (!xdr_enum (xdrs, (enum_t *) objp))
 789                  return FALSE;
 790         return TRUE;
 791 }
 792
 793 bool_t
 794 xdr_ndmp4_tape_mtio_request (XDR *xdrs, ndmp4_tape_mtio_request *objp)
 795 {
 796         register int32_t *buf;
 797
 798          if (!xdr_ndmp4_tape_mtio_op (xdrs, &objp->tape_op))
 799                  return FALSE;
 800          if (!xdr_u_long (xdrs, &objp->count))
 801                  return FALSE;
 802         return TRUE;
 803 }
 804
 805 bool_t
 806 xdr_ndmp4_tape_mtio_reply (XDR *xdrs, ndmp4_tape_mtio_reply *objp)
 807 {
 808         register int32_t *buf;
 809
 810          if (!xdr_ndmp4_error (xdrs, &objp->error))
 811                  return FALSE;
 812          if (!xdr_u_long (xdrs, &objp->resid_count))
 813                  return FALSE;
 814         return TRUE;
 815 }
 816
 817 bool_t
 818 xdr_ndmp4_tape_write_request (XDR *xdrs, ndmp4_tape_write_request *objp)
 819 {
 820         register int32_t *buf;
 821
 822          if (!xdr_bytes (xdrs, (char **)&objp->data_out.data_out_val, (u_int *) &objp->data_out.data_out_len, ~0))
 823                  return FALSE;
 824         return TRUE;
 825 }
 826
 827 bool_t
 828 xdr_ndmp4_tape_write_reply (XDR *xdrs, ndmp4_tape_write_reply *objp)
 829 {
 830         register int32_t *buf;
 831
 832          if (!xdr_ndmp4_error (xdrs, &objp->error))
 833                  return FALSE;
 834          if (!xdr_u_long (xdrs, &objp->count))
 835                  return FALSE;
 836         return TRUE;
 837 }
 838
 839 bool_t
 840 xdr_ndmp4_tape_read_request (XDR *xdrs, ndmp4_tape_read_request *objp)
 841 {
 842         register int32_t *buf;
 843
 844          if (!xdr_u_long (xdrs, &objp->count))
 845                  return FALSE;
 846         return TRUE;
 847 }
 848
 849 bool_t
 850 xdr_ndmp4_tape_read_reply (XDR *xdrs, ndmp4_tape_read_reply *objp)
 851 {
 852         register int32_t *buf;
 853
 854          if (!xdr_ndmp4_error (xdrs, &objp->error))
 855                  return FALSE;
 856          if (!xdr_bytes (xdrs, (char **)&objp->data_in.data_in_val, (u_int *) &objp->data_in.data_in_len, ~0))
 857                  return FALSE;
 858         return TRUE;
 859 }
 860
 861 bool_t
 862 xdr_ndmp4_tape_execute_cdb_request (XDR *xdrs, ndmp4_tape_execute_cdb_request *objp)
 863 {
 864         register int32_t *buf;
 865
 866          if (!xdr_ndmp4_scsi_execute_cdb_request (xdrs, objp))
 867                  return FALSE;
 868         return TRUE;
 869 }
 870
 871 bool_t
 872 xdr_ndmp4_tape_execute_cdb_reply (XDR *xdrs, ndmp4_tape_execute_cdb_reply *objp)
 873 {
 874         register int32_t *buf;
 875
 876          if (!xdr_ndmp4_scsi_execute_cdb_reply (xdrs, objp))
 877                  return FALSE;
 878         return TRUE;
 879 }
 880
 881 bool_t
 882 xdr_ndmp4_data_operation (XDR *xdrs, ndmp4_data_operation *objp)
 883 {
 884         register int32_t *buf;
 885
 886          if (!xdr_enum (xdrs, (enum_t *) objp))
 887                  return FALSE;
 888         return TRUE;
 889 }
 890
 891 bool_t
 892 xdr_ndmp4_data_state (XDR *xdrs, ndmp4_data_state *objp)
 893 {
 894         register int32_t *buf;
 895
 896          if (!xdr_enum (xdrs, (enum_t *) objp))
 897                  return FALSE;
 898         return TRUE;
 899 }
 900
 901 bool_t
 902 xdr_ndmp4_data_halt_reason (XDR *xdrs, ndmp4_data_halt_reason *objp)
 903 {
 904         register int32_t *buf;
 905
 906          if (!xdr_enum (xdrs, (enum_t *) objp))
 907                  return FALSE;
 908         return TRUE;
 909 }
 910
 911 bool_t
 912 xdr_ndmp4_tcp_addr (XDR *xdrs, ndmp4_tcp_addr *objp)
 913 {
 914         register int32_t *buf;
 915
 916          if (!xdr_u_long (xdrs, &objp->ip_addr))
 917                  return FALSE;
 918          if (!xdr_u_short (xdrs, &objp->port))
 919                  return FALSE;
 920          if (!xdr_array (xdrs, (char **)&objp->addr_env.addr_env_val, (u_int *) &objp->addr_env.addr_env_len, ~0,
 921                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
 922                  return FALSE;
 923         return TRUE;
 924 }
 925
 926 bool_t
 927 xdr_ndmp4_ipc_addr (XDR *xdrs, ndmp4_ipc_addr *objp)
 928 {
 929         register int32_t *buf;
 930
 931          if (!xdr_bytes (xdrs, (char **)&objp->comm_data.comm_data_val, (u_int *) &objp->comm_data.comm_data_len, ~0))
 932                  return FALSE;
 933         return TRUE;
 934 }
 935
 936 bool_t
 937 xdr_ndmp4_addr (XDR *xdrs, ndmp4_addr *objp)
 938 {
 939         register int32_t *buf;
 940
 941          if (!xdr_ndmp4_addr_type (xdrs, &objp->addr_type))
 942                  return FALSE;
 943         switch (objp->addr_type) {
 944         case NDMP4_ADDR_LOCAL:
 945                 break;
 946         case NDMP4_ADDR_TCP:
 947                  if (!xdr_array (xdrs, (char **)&objp->ndmp4_addr_u.tcp_addr.tcp_addr_val, (u_int *) &objp->ndmp4_addr_u.tcp_addr.tcp_addr_len, ~0,
 948                         sizeof (ndmp4_tcp_addr), (xdrproc_t) xdr_ndmp4_tcp_addr))
 949                          return FALSE;
 950                 break;
 951         case NDMP4_ADDR_IPC:
 952                  if (!xdr_ndmp4_ipc_addr (xdrs, &objp->ndmp4_addr_u.ipc_addr))
 953                          return FALSE;
 954                 break;
 955         default:
 956                 return FALSE;
 957         }
 958         return TRUE;
 959 }
 960
 961 bool_t
 962 xdr_ndmp4_data_get_state_reply (XDR *xdrs, ndmp4_data_get_state_reply *objp)
 963 {
 964         register int32_t *buf;
 965
 966          if (!xdr_u_long (xdrs, &objp->unsupported))
 967                  return FALSE;
 968          if (!xdr_ndmp4_error (xdrs, &objp->error))
 969                  return FALSE;
 970          if (!xdr_ndmp4_data_operation (xdrs, &objp->operation))
 971                  return FALSE;
 972          if (!xdr_ndmp4_data_state (xdrs, &objp->state))
 973                  return FALSE;
 974          if (!xdr_ndmp4_data_halt_reason (xdrs, &objp->halt_reason))
 975                  return FALSE;
 976          if (!xdr_ndmp4_u_quad (xdrs, &objp->bytes_processed))
 977                  return FALSE;
 978          if (!xdr_ndmp4_u_quad (xdrs, &objp->est_bytes_remain))
 979                  return FALSE;
 980          if (!xdr_u_long (xdrs, &objp->est_time_remain))
 981                  return FALSE;
 982          if (!xdr_ndmp4_addr (xdrs, &objp->data_connection_addr))
 983                  return FALSE;
 984          if (!xdr_ndmp4_u_quad (xdrs, &objp->read_offset))
 985                  return FALSE;
 986          if (!xdr_ndmp4_u_quad (xdrs, &objp->read_length))
 987                  return FALSE;
 988         return TRUE;
 989 }
 990
 991 bool_t
 992 xdr_ndmp4_data_listen_request (XDR *xdrs, ndmp4_data_listen_request *objp)
 993 {
 994         register int32_t *buf;
 995
 996          if (!xdr_ndmp4_addr_type (xdrs, &objp->addr_type))
 997                  return FALSE;
 998         return TRUE;
 999 }
1000
1001 bool_t
1002 xdr_ndmp4_data_listen_reply (XDR *xdrs, ndmp4_data_listen_reply *objp)
1003 {
1004         register int32_t *buf;
1005
1006          if (!xdr_ndmp4_error (xdrs, &objp->error))
1007                  return FALSE;
1008          if (!xdr_ndmp4_addr (xdrs, &objp->connect_addr))
1009                  return FALSE;
1010         return TRUE;
1011 }
1012
1013 bool_t
1014 xdr_ndmp4_data_connect_request (XDR *xdrs, ndmp4_data_connect_request *objp)
1015 {
1016         register int32_t *buf;
1017
1018          if (!xdr_ndmp4_addr (xdrs, &objp->addr))
1019                  return FALSE;
1020         return TRUE;
1021 }
1022
1023 bool_t
1024 xdr_ndmp4_data_connect_reply (XDR *xdrs, ndmp4_data_connect_reply *objp)
1025 {
1026         register int32_t *buf;
1027
1028          if (!xdr_ndmp4_error (xdrs, &objp->error))
1029                  return FALSE;
1030         return TRUE;
1031 }
1032
1033 bool_t
1034 xdr_ndmp4_data_start_backup_request (XDR *xdrs, ndmp4_data_start_backup_request *objp)
1035 {
1036         register int32_t *buf;
1037
1038          if (!xdr_string (xdrs, &objp->butype_name, ~0))
1039                  return FALSE;
1040          if (!xdr_array (xdrs, (char **)&objp->env.env_val, (u_int *) &objp->env.env_len, ~0,
1041                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
1042                  return FALSE;
1043         return TRUE;
1044 }
1045
1046 bool_t
1047 xdr_ndmp4_data_start_backup_reply (XDR *xdrs, ndmp4_data_start_backup_reply *objp)
1048 {
1049         register int32_t *buf;
1050
1051          if (!xdr_ndmp4_error (xdrs, &objp->error))
1052                  return FALSE;
1053         return TRUE;
1054 }
1055
1056 bool_t
1057 xdr_ndmp4_name (XDR *xdrs, ndmp4_name *objp)
1058 {
1059         register int32_t *buf;
1060
1061          if (!xdr_string (xdrs, &objp->original_path, ~0))
1062                  return FALSE;
1063          if (!xdr_string (xdrs, &objp->destination_path, ~0))
1064                  return FALSE;
1065          if (!xdr_string (xdrs, &objp->name, ~0))
1066                  return FALSE;
1067          if (!xdr_string (xdrs, &objp->other_name, ~0))
1068                  return FALSE;
1069          if (!xdr_ndmp4_u_quad (xdrs, &objp->node))
1070                  return FALSE;
1071          if (!xdr_ndmp4_u_quad (xdrs, &objp->fh_info))
1072                  return FALSE;
1073         return TRUE;
1074 }
1075
1076 bool_t
1077 xdr_ndmp4_data_start_recover_request (XDR *xdrs, ndmp4_data_start_recover_request *objp)
1078 {
1079         register int32_t *buf;
1080
1081          if (!xdr_array (xdrs, (char **)&objp->env.env_val, (u_int *) &objp->env.env_len, ~0,
1082                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
1083                  return FALSE;
1084          if (!xdr_array (xdrs, (char **)&objp->nlist.nlist_val, (u_int *) &objp->nlist.nlist_len, ~0,
1085                 sizeof (ndmp4_name), (xdrproc_t) xdr_ndmp4_name))
1086                  return FALSE;
1087          if (!xdr_string (xdrs, &objp->butype_name, ~0))
1088                  return FALSE;
1089         return TRUE;
1090 }
1091
1092 bool_t
1093 xdr_ndmp4_data_start_recover_reply (XDR *xdrs, ndmp4_data_start_recover_reply *objp)
1094 {
1095         register int32_t *buf;
1096
1097          if (!xdr_ndmp4_error (xdrs, &objp->error))
1098                  return FALSE;
1099         return TRUE;
1100 }
1101
1102 bool_t
1103 xdr_ndmp4_data_start_recover_filehist_request (XDR *xdrs, ndmp4_data_start_recover_filehist_request *objp)
1104 {
1105         register int32_t *buf;
1106
1107          if (!xdr_array (xdrs, (char **)&objp->env.env_val, (u_int *) &objp->env.env_len, ~0,
1108                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
1109                  return FALSE;
1110          if (!xdr_array (xdrs, (char **)&objp->nlist.nlist_val, (u_int *) &objp->nlist.nlist_len, ~0,
1111                 sizeof (ndmp4_name), (xdrproc_t) xdr_ndmp4_name))
1112                  return FALSE;
1113          if (!xdr_string (xdrs, &objp->butype_name, ~0))
1114                  return FALSE;
1115         return TRUE;
1116 }
1117
1118 bool_t
1119 xdr_ndmp4_data_start_recover_filehist_reply (XDR *xdrs, ndmp4_data_start_recover_filehist_reply *objp)
1120 {
1121         register int32_t *buf;
1122
1123          if (!xdr_ndmp4_error (xdrs, &objp->error))
1124                  return FALSE;
1125         return TRUE;
1126 }
1127
1128 bool_t
1129 xdr_ndmp4_data_abort_reply (XDR *xdrs, ndmp4_data_abort_reply *objp)
1130 {
1131         register int32_t *buf;
1132
1133          if (!xdr_ndmp4_error (xdrs, &objp->error))
1134                  return FALSE;
1135         return TRUE;
1136 }
1137
1138 bool_t
1139 xdr_ndmp4_data_stop_reply (XDR *xdrs, ndmp4_data_stop_reply *objp)
1140 {
1141         register int32_t *buf;
1142
1143          if (!xdr_ndmp4_error (xdrs, &objp->error))
1144                  return FALSE;
1145         return TRUE;
1146 }
1147
1148 bool_t
1149 xdr_ndmp4_data_get_env_reply (XDR *xdrs, ndmp4_data_get_env_reply *objp)
1150 {
1151         register int32_t *buf;
1152
1153          if (!xdr_ndmp4_error (xdrs, &objp->error))
1154                  return FALSE;
1155          if (!xdr_array (xdrs, (char **)&objp->env.env_val, (u_int *) &objp->env.env_len, ~0,
1156                 sizeof (ndmp4_pval), (xdrproc_t) xdr_ndmp4_pval))
1157                  return FALSE;
1158         return TRUE;
1159 }
1160
1161 bool_t
1162 xdr_ndmp4_mover_mode (XDR *xdrs, ndmp4_mover_mode *objp)
1163 {
1164         register int32_t *buf;
1165
1166          if (!xdr_enum (xdrs, (enum_t *) objp))
1167                  return FALSE;
1168         return TRUE;
1169 }
1170
1171 bool_t
1172 xdr_ndmp4_mover_state (XDR *xdrs, ndmp4_mover_state *objp)
1173 {
1174         register int32_t *buf;
1175
1176          if (!xdr_enum (xdrs, (enum_t *) objp))
1177                  return FALSE;
1178         return TRUE;
1179 }
1180
1181 bool_t
1182 xdr_ndmp4_mover_pause_reason (XDR *xdrs, ndmp4_mover_pause_reason *objp)
1183 {
1184         register int32_t *buf;
1185
1186          if (!xdr_enum (xdrs, (enum_t *) objp))
1187                  return FALSE;
1188         return TRUE;
1189 }
1190
1191 bool_t
1192 xdr_ndmp4_mover_halt_reason (XDR *xdrs, ndmp4_mover_halt_reason *objp)
1193 {
1194         register int32_t *buf;
1195
1196          if (!xdr_enum (xdrs, (enum_t *) objp))
1197                  return FALSE;
1198         return TRUE;
1199 }
1200
1201 bool_t
1202 xdr_ndmp4_mover_set_record_size_request (XDR *xdrs, ndmp4_mover_set_record_size_request *objp)
1203 {
1204         register int32_t *buf;
1205
1206          if (!xdr_u_long (xdrs, &objp->len))
1207                  return FALSE;
1208         return TRUE;
1209 }
1210
1211 bool_t
1212 xdr_ndmp4_mover_set_record_size_reply (XDR *xdrs, ndmp4_mover_set_record_size_reply *objp)
1213 {
1214         register int32_t *buf;
1215
1216          if (!xdr_ndmp4_error (xdrs, &objp->error))
1217                  return FALSE;
1218         return TRUE;
1219 }
1220
1221 bool_t
1222 xdr_ndmp4_mover_set_window_request (XDR *xdrs, ndmp4_mover_set_window_request *objp)
1223 {
1224         register int32_t *buf;
1225
1226          if (!xdr_ndmp4_u_quad (xdrs, &objp->offset))
1227                  return FALSE;
1228          if (!xdr_ndmp4_u_quad (xdrs, &objp->length))
1229                  return FALSE;
1230         return TRUE;
1231 }
1232
1233 bool_t
1234 xdr_ndmp4_mover_set_window_reply (XDR *xdrs, ndmp4_mover_set_window_reply *objp)
1235 {
1236         register int32_t *buf;
1237
1238          if (!xdr_ndmp4_error (xdrs, &objp->error))
1239                  return FALSE;
1240         return TRUE;
1241 }
1242
1243 bool_t
1244 xdr_ndmp4_mover_connect_request (XDR *xdrs, ndmp4_mover_connect_request *objp)
1245 {
1246         register int32_t *buf;
1247
1248          if (!xdr_ndmp4_mover_mode (xdrs, &objp->mode))
1249                  return FALSE;
1250          if (!xdr_ndmp4_addr (xdrs, &objp->addr))
1251                  return FALSE;
1252         return TRUE;
1253 }
1254
1255 bool_t
1256 xdr_ndmp4_mover_connect_reply (XDR *xdrs, ndmp4_mover_connect_reply *objp)
1257 {
1258         register int32_t *buf;
1259
1260          if (!xdr_ndmp4_error (xdrs, &objp->error))
1261                  return FALSE;
1262         return TRUE;
1263 }
1264
1265 bool_t
1266 xdr_ndmp4_mover_listen_request (XDR *xdrs, ndmp4_mover_listen_request *objp)
1267 {
1268         register int32_t *buf;
1269
1270          if (!xdr_ndmp4_mover_mode (xdrs, &objp->mode))
1271                  return FALSE;
1272          if (!xdr_ndmp4_addr_type (xdrs, &objp->addr_type))
1273                  return FALSE;
1274         return TRUE;
1275 }
1276
1277 bool_t
1278 xdr_ndmp4_mover_listen_reply (XDR *xdrs, ndmp4_mover_listen_reply *objp)
1279 {
1280         register int32_t *buf;
1281
1282          if (!xdr_ndmp4_error (xdrs, &objp->error))
1283                  return FALSE;
1284          if (!xdr_ndmp4_addr (xdrs, &objp->connect_addr))
1285                  return FALSE;
1286         return TRUE;
1287 }
1288
1289 bool_t
1290 xdr_ndmp4_mover_read_request (XDR *xdrs, ndmp4_mover_read_request *objp)
1291 {
1292         register int32_t *buf;
1293
1294          if (!xdr_ndmp4_u_quad (xdrs, &objp->offset))
1295                  return FALSE;
1296          if (!xdr_ndmp4_u_quad (xdrs, &objp->length))
1297                  return FALSE;
1298         return TRUE;
1299 }
1300
1301 bool_t
1302 xdr_ndmp4_mover_read_reply (XDR *xdrs, ndmp4_mover_read_reply *objp)
1303 {
1304         register int32_t *buf;
1305
1306          if (!xdr_ndmp4_error (xdrs, &objp->error))
1307                  return FALSE;
1308         return TRUE;
1309 }
1310
1311 bool_t
1312 xdr_ndmp4_mover_get_state_reply (XDR *xdrs, ndmp4_mover_get_state_reply *objp)
1313 {
1314         register int32_t *buf;
1315
1316          if (!xdr_ndmp4_error (xdrs, &objp->error))
1317                  return FALSE;
1318          if (!xdr_ndmp4_mover_mode (xdrs, &objp->mode))
1319                  return FALSE;
1320          if (!xdr_ndmp4_mover_state (xdrs, &objp->state))
1321                  return FALSE;
1322          if (!xdr_ndmp4_mover_pause_reason (xdrs, &objp->pause_reason))
1323                  return FALSE;
1324          if (!xdr_ndmp4_mover_halt_reason (xdrs, &objp->halt_reason))
1325                  return FALSE;
1326          if (!xdr_u_long (xdrs, &objp->record_size))
1327                  return FALSE;
1328          if (!xdr_u_long (xdrs, &objp->record_num))
1329                  return FALSE;
1330          if (!xdr_ndmp4_u_quad (xdrs, &objp->bytes_moved))
1331                  return FALSE;
1332          if (!xdr_ndmp4_u_quad (xdrs, &objp->seek_position))
1333                  return FALSE;
1334          if (!xdr_ndmp4_u_quad (xdrs, &objp->bytes_left_to_read))
1335                  return FALSE;
1336          if (!xdr_ndmp4_u_quad (xdrs, &objp->window_offset))
1337                  return FALSE;
1338          if (!xdr_ndmp4_u_quad (xdrs, &objp->window_length))
1339                  return FALSE;
1340          if (!xdr_ndmp4_addr (xdrs, &objp->data_connection_addr))
1341                  return FALSE;
1342         return TRUE;
1343 }
1344
1345 bool_t
1346 xdr_ndmp4_mover_continue_reply (XDR *xdrs, ndmp4_mover_continue_reply *objp)
1347 {
1348         register int32_t *buf;
1349
1350          if (!xdr_ndmp4_error (xdrs, &objp->error))
1351                  return FALSE;
1352         return TRUE;
1353 }
1354
1355 bool_t
1356 xdr_ndmp4_mover_close_reply (XDR *xdrs, ndmp4_mover_close_reply *objp)
1357 {
1358         register int32_t *buf;
1359
1360          if (!xdr_ndmp4_error (xdrs, &objp->error))
1361                  return FALSE;
1362         return TRUE;
1363 }
1364
1365 bool_t
1366 xdr_ndmp4_mover_abort_reply (XDR *xdrs, ndmp4_mover_abort_reply *objp)
1367 {
1368         register int32_t *buf;
1369
1370          if (!xdr_ndmp4_error (xdrs, &objp->error))
1371                  return FALSE;
1372         return TRUE;
1373 }
1374
1375 bool_t
1376 xdr_ndmp4_mover_stop_reply (XDR *xdrs, ndmp4_mover_stop_reply *objp)
1377 {
1378         register int32_t *buf;
1379
1380          if (!xdr_ndmp4_error (xdrs, &objp->error))
1381                  return FALSE;
1382         return TRUE;
1383 }
1384
1385 bool_t
1386 xdr_ndmp4_notify_data_halted_post (XDR *xdrs, ndmp4_notify_data_halted_post *objp)
1387 {
1388         register int32_t *buf;
1389
1390          if (!xdr_ndmp4_data_halt_reason (xdrs, &objp->reason))
1391                  return FALSE;
1392         return TRUE;
1393 }
1394
1395 bool_t
1396 xdr_ndmp4_connection_status_reason (XDR *xdrs, ndmp4_connection_status_reason *objp)
1397 {
1398         register int32_t *buf;
1399
1400          if (!xdr_enum (xdrs, (enum_t *) objp))
1401                  return FALSE;
1402         return TRUE;
1403 }
1404
1405 bool_t
1406 xdr_ndmp4_notify_connection_status_post (XDR *xdrs, ndmp4_notify_connection_status_post *objp)
1407 {
1408         register int32_t *buf;
1409
1410          if (!xdr_ndmp4_connection_status_reason (xdrs, &objp->reason))
1411                  return FALSE;
1412          if (!xdr_u_short (xdrs, &objp->protocol_version))
1413                  return FALSE;
1414          if (!xdr_string (xdrs, &objp->text_reason, ~0))
1415                  return FALSE;
1416         return TRUE;
1417 }
1418
1419 bool_t
1420 xdr_ndmp4_notify_mover_halted_post (XDR *xdrs, ndmp4_notify_mover_halted_post *objp)
1421 {
1422         register int32_t *buf;
1423
1424          if (!xdr_ndmp4_mover_halt_reason (xdrs, &objp->reason))
1425                  return FALSE;
1426         return TRUE;
1427 }
1428
1429 bool_t
1430 xdr_ndmp4_notify_mover_paused_post (XDR *xdrs, ndmp4_notify_mover_paused_post *objp)
1431 {
1432         register int32_t *buf;
1433
1434          if (!xdr_ndmp4_mover_pause_reason (xdrs, &objp->reason))
1435                  return FALSE;
1436          if (!xdr_ndmp4_u_quad (xdrs, &objp->seek_position))
1437                  return FALSE;
1438         return TRUE;
1439 }
1440
1441 bool_t
1442 xdr_ndmp4_notify_data_read_post (XDR *xdrs, ndmp4_notify_data_read_post *objp)
1443 {
1444         register int32_t *buf;
1445
1446          if (!xdr_ndmp4_u_quad (xdrs, &objp->offset))
1447                  return FALSE;
1448          if (!xdr_ndmp4_u_quad (xdrs, &objp->length))
1449                  return FALSE;
1450         return TRUE;
1451 }
1452
1453 bool_t
1454 xdr_ndmp4_has_associated_message (XDR *xdrs, ndmp4_has_associated_message *objp)
1455 {
1456         register int32_t *buf;
1457
1458          if (!xdr_enum (xdrs, (enum_t *) objp))
1459                  return FALSE;
1460         return TRUE;
1461 }
1462
1463 bool_t
1464 xdr_ndmp4_log_type (XDR *xdrs, ndmp4_log_type *objp)
1465 {
1466         register int32_t *buf;
1467
1468          if (!xdr_enum (xdrs, (enum_t *) objp))
1469                  return FALSE;
1470         return TRUE;
1471 }
1472
1473 bool_t
1474 xdr_ndmp4_log_message_post (XDR *xdrs, ndmp4_log_message_post *objp)
1475 {
1476         register int32_t *buf;
1477
1478          if (!xdr_ndmp4_log_type (xdrs, &objp->log_type))
1479                  return FALSE;
1480          if (!xdr_u_long (xdrs, &objp->message_id))
1481                  return FALSE;
1482          if (!xdr_string (xdrs, &objp->entry, ~0))
1483                  return FALSE;
1484          if (!xdr_ndmp4_has_associated_message (xdrs, &objp->associated_message_valid))
1485                  return FALSE;
1486          if (!xdr_u_long (xdrs, &objp->associated_message_sequence))
1487                  return FALSE;
1488         return TRUE;
1489 }
1490
1491 bool_t
1492 xdr_ndmp4_recovery_status (XDR *xdrs, ndmp4_recovery_status *objp)
1493 {
1494         register int32_t *buf;
1495
1496          if (!xdr_enum (xdrs, (enum_t *) objp))
1497                  return FALSE;
1498         return TRUE;
1499 }
1500
1501 bool_t
1502 xdr_ndmp4_log_file_post (XDR *xdrs, ndmp4_log_file_post *objp)
1503 {
1504         register int32_t *buf;
1505
1506          if (!xdr_string (xdrs, &objp->name, ~0))
1507                  return FALSE;
1508          if (!xdr_ndmp4_recovery_status (xdrs, &objp->recovery_status))
1509                  return FALSE;
1510         return TRUE;
1511 }
1512
1513 bool_t
1514 xdr_ndmp4_fs_type (XDR *xdrs, ndmp4_fs_type *objp)
1515 {
1516         register int32_t *buf;
1517
1518          if (!xdr_enum (xdrs, (enum_t *) objp))
1519                  return FALSE;
1520         return TRUE;
1521 }
1522
1523 bool_t
1524 xdr_ndmp4_path (XDR *xdrs, ndmp4_path *objp)
1525 {
1526         register int32_t *buf;
1527
1528          if (!xdr_string (xdrs, objp, ~0))
1529                  return FALSE;
1530         return TRUE;
1531 }
1532
1533 bool_t
1534 xdr_ndmp4_nt_path (XDR *xdrs, ndmp4_nt_path *objp)
1535 {
1536         register int32_t *buf;
1537
1538          if (!xdr_ndmp4_path (xdrs, &objp->nt_path))
1539                  return FALSE;
1540          if (!xdr_ndmp4_path (xdrs, &objp->dos_path))
1541                  return FALSE;
1542         return TRUE;
1543 }
1544
1545 bool_t
1546 xdr_ndmp4_file_name (XDR *xdrs, ndmp4_file_name *objp)
1547 {
1548         register int32_t *buf;
1549
1550          if (!xdr_ndmp4_fs_type (xdrs, &objp->fs_type))
1551                  return FALSE;
1552         switch (objp->fs_type) {
1553         case NDMP4_FS_UNIX:
1554                  if (!xdr_ndmp4_path (xdrs, &objp->ndmp4_file_name_u.unix_name))
1555                          return FALSE;
1556                 break;
1557         case NDMP4_FS_NT:
1558                  if (!xdr_ndmp4_nt_path (xdrs, &objp->ndmp4_file_name_u.nt_name))
1559                          return FALSE;
1560                 break;
1561         default:
1562                  if (!xdr_ndmp4_path (xdrs, &objp->ndmp4_file_name_u.other_name))
1563                          return FALSE;
1564                 break;
1565         }
1566         return TRUE;
1567 }
1568
1569 bool_t
1570 xdr_ndmp4_file_type (XDR *xdrs, ndmp4_file_type *objp)
1571 {
1572         register int32_t *buf;
1573
1574          if (!xdr_enum (xdrs, (enum_t *) objp))
1575                  return FALSE;
1576         return TRUE;
1577 }
1578
1579 bool_t
1580 xdr_ndmp4_file_stat (XDR *xdrs, ndmp4_file_stat *objp)
1581 {
1582         register int32_t *buf;
1583
1584
1585         if (xdrs->x_op == XDR_ENCODE) {
1586                  if (!xdr_u_long (xdrs, &objp->unsupported))
1587                          return FALSE;
1588                  if (!xdr_ndmp4_fs_type (xdrs, &objp->fs_type))
1589                          return FALSE;
1590                  if (!xdr_ndmp4_file_type (xdrs, &objp->ftype))
1591                          return FALSE;
1592                 buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
1593                 if (buf == NULL) {
1594                          if (!xdr_u_long (xdrs, &objp->mtime))
1595                                  return FALSE;
1596                          if (!xdr_u_long (xdrs, &objp->atime))
1597                                  return FALSE;
1598                          if (!xdr_u_long (xdrs, &objp->ctime))
1599                                  return FALSE;
1600                          if (!xdr_u_long (xdrs, &objp->owner))
1601                                  return FALSE;
1602                          if (!xdr_u_long (xdrs, &objp->group))
1603                                  return FALSE;
1604                          if (!xdr_u_long (xdrs, &objp->fattr))
1605                                  return FALSE;
1606
1607                 } else {
1608                 IXDR_PUT_U_LONG(buf, objp->mtime);
1609                 IXDR_PUT_U_LONG(buf, objp->atime);
1610                 IXDR_PUT_U_LONG(buf, objp->ctime);
1611                 IXDR_PUT_U_LONG(buf, objp->owner);
1612                 IXDR_PUT_U_LONG(buf, objp->group);
1613                 IXDR_PUT_U_LONG(buf, objp->fattr);
1614                 }
1615                  if (!xdr_ndmp4_u_quad (xdrs, &objp->size))
1616                          return FALSE;
1617                  if (!xdr_u_long (xdrs, &objp->links))
1618                          return FALSE;
1619                 return TRUE;
1620         } else if (xdrs->x_op == XDR_DECODE) {
1621                  if (!xdr_u_long (xdrs, &objp->unsupported))
1622                          return FALSE;
1623                  if (!xdr_ndmp4_fs_type (xdrs, &objp->fs_type))
1624                          return FALSE;
1625                  if (!xdr_ndmp4_file_type (xdrs, &objp->ftype))
1626                          return FALSE;
1627                 buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
1628                 if (buf == NULL) {
1629                          if (!xdr_u_long (xdrs, &objp->mtime))
1630                                  return FALSE;
1631                          if (!xdr_u_long (xdrs, &objp->atime))
1632                                  return FALSE;
1633                          if (!xdr_u_long (xdrs, &objp->ctime))
1634                                  return FALSE;
1635                          if (!xdr_u_long (xdrs, &objp->owner))
1636                                  return FALSE;
1637                          if (!xdr_u_long (xdrs, &objp->group))
1638                                  return FALSE;
1639                          if (!xdr_u_long (xdrs, &objp->fattr))
1640                                  return FALSE;
1641
1642                 } else {
1643                 objp->mtime = IXDR_GET_U_LONG(buf);
1644                 objp->atime = IXDR_GET_U_LONG(buf);
1645                 objp->ctime = IXDR_GET_U_LONG(buf);
1646                 objp->owner = IXDR_GET_U_LONG(buf);
1647                 objp->group = IXDR_GET_U_LONG(buf);
1648                 objp->fattr = IXDR_GET_U_LONG(buf);
1649                 }
1650                  if (!xdr_ndmp4_u_quad (xdrs, &objp->size))
1651                          return FALSE;
1652                  if (!xdr_u_long (xdrs, &objp->links))
1653                          return FALSE;
1654          return TRUE;
1655         }
1656
1657          if (!xdr_u_long (xdrs, &objp->unsupported))
1658                  return FALSE;
1659          if (!xdr_ndmp4_fs_type (xdrs, &objp->fs_type))
1660                  return FALSE;
1661          if (!xdr_ndmp4_file_type (xdrs, &objp->ftype))
1662                  return FALSE;
1663          if (!xdr_u_long (xdrs, &objp->mtime))
1664                  return FALSE;
1665          if (!xdr_u_long (xdrs, &objp->atime))
1666                  return FALSE;
1667          if (!xdr_u_long (xdrs, &objp->ctime))
1668                  return FALSE;
1669          if (!xdr_u_long (xdrs, &objp->owner))
1670                  return FALSE;
1671          if (!xdr_u_long (xdrs, &objp->group))
1672                  return FALSE;
1673          if (!xdr_u_long (xdrs, &objp->fattr))
1674                  return FALSE;
1675          if (!xdr_ndmp4_u_quad (xdrs, &objp->size))
1676                  return FALSE;
1677          if (!xdr_u_long (xdrs, &objp->links))
1678                  return FALSE;
1679         return TRUE;
1680 }
1681
1682 bool_t
1683 xdr_ndmp4_file (XDR *xdrs, ndmp4_file *objp)
1684 {
1685         register int32_t *buf;
1686
1687          if (!xdr_array (xdrs, (char **)&objp->names.names_val, (u_int *) &objp->names.names_len, ~0,
1688                 sizeof (ndmp4_file_name), (xdrproc_t) xdr_ndmp4_file_name))
1689                  return FALSE;
1690          if (!xdr_array (xdrs, (char **)&objp->stats.stats_val, (u_int *) &objp->stats.stats_len, ~0,
1691                 sizeof (ndmp4_file_stat), (xdrproc_t) xdr_ndmp4_file_stat))
1692                  return FALSE;
1693          if (!xdr_ndmp4_u_quad (xdrs, &objp->node))
1694                  return FALSE;
1695          if (!xdr_ndmp4_u_quad (xdrs, &objp->fh_info))
1696                  return FALSE;
1697         return TRUE;
1698 }
1699
1700 bool_t
1701 xdr_ndmp4_fh_add_file_post (XDR *xdrs, ndmp4_fh_add_file_post *objp)
1702 {
1703         register int32_t *buf;
1704
1705          if (!xdr_array (xdrs, (char **)&objp->files.files_val, (u_int *) &objp->files.files_len, ~0,
1706                 sizeof (ndmp4_file), (xdrproc_t) xdr_ndmp4_file))
1707                  return FALSE;
1708         return TRUE;
1709 }
1710
1711 bool_t
1712 xdr_ndmp4_dir (XDR *xdrs, ndmp4_dir *objp)
1713 {
1714         register int32_t *buf;
1715
1716          if (!xdr_array (xdrs, (char **)&objp->names.names_val, (u_int *) &objp->names.names_len, ~0,
1717                 sizeof (ndmp4_file_name), (xdrproc_t) xdr_ndmp4_file_name))
1718                  return FALSE;
1719          if (!xdr_ndmp4_u_quad (xdrs, &objp->node))
1720                  return FALSE;
1721          if (!xdr_ndmp4_u_quad (xdrs, &objp->parent))
1722                  return FALSE;
1723         return TRUE;
1724 }
1725
1726 bool_t
1727 xdr_ndmp4_fh_add_dir_post (XDR *xdrs, ndmp4_fh_add_dir_post *objp)
1728 {
1729         register int32_t *buf;
1730
1731          if (!xdr_array (xdrs, (char **)&objp->dirs.dirs_val, (u_int *) &objp->dirs.dirs_len, ~0,
1732                 sizeof (ndmp4_dir), (xdrproc_t) xdr_ndmp4_dir))
1733                  return FALSE;
1734         return TRUE;
1735 }
1736
1737 bool_t
1738 xdr_ndmp4_node (XDR *xdrs, ndmp4_node *objp)
1739 {
1740         register int32_t *buf;
1741
1742          if (!xdr_array (xdrs, (char **)&objp->stats.stats_val, (u_int *) &objp->stats.stats_len, ~0,
1743                 sizeof (ndmp4_file_stat), (xdrproc_t) xdr_ndmp4_file_stat))
1744                  return FALSE;
1745          if (!xdr_ndmp4_u_quad (xdrs, &objp->node))
1746                  return FALSE;
1747          if (!xdr_ndmp4_u_quad (xdrs, &objp->fh_info))
1748                  return FALSE;
1749         return TRUE;
1750 }
1751
1752 bool_t
1753 xdr_ndmp4_fh_add_node_post (XDR *xdrs, ndmp4_fh_add_node_post *objp)
1754 {
1755         register int32_t *buf;
1756
1757          if (!xdr_array (xdrs, (char **)&objp->nodes.nodes_val, (u_int *) &objp->nodes.nodes_len, ~0,
1758                 sizeof (ndmp4_node), (xdrproc_t) xdr_ndmp4_node))
1759                  return FALSE;
1760         return TRUE;
1761 }
1762 #endif /* !NDMOS_OPTION_NO_NDMP4 */