include/rpcsvc/nfs_prot.x

   1 /*
   2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   3  * unrestricted use provided that this legend is included on all tape
   4  * media and as a part of the software program in whole or part.  Users
   5  * may copy or modify Sun RPC without charge, but are not authorized
   6  * to license or distribute it to anyone else except as part of a product or
   7  * program developed by the user.
   8  *
   9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  12  *
  13  * Sun RPC is provided with no support and without any obligation on the
  14  * part of Sun Microsystems, Inc. to assist in its use, correction,
  15  * modification or enhancement.
  16  *
  17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  19  * OR ANY PART THEREOF.
  20  *
  21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  22  * or profits or other special, indirect and consequential damages, even if
  23  * Sun has been advised of the possibility of such damages.
  24  *
  25  * Sun Microsystems, Inc.
  26  * 2550 Garcia Avenue
  27  * Mountain View, California  94043
  28  *
  29  * @(#)nfs_prot.x 1.2 87/10/12 Copyr 1987 Sun Micro
  30  * @(#)nfs_prot.x       2.1 88/08/01 4.0 RPCSRC
  31  * $FreeBSD: src/include/rpcsvc/nfs_prot.x,v 1.7 1999/08/27 23:45:08 peter Exp $
  32  * $DragonFly: src/include/rpcsvc/nfs_prot.x,v 1.2 2003/06/17 04:25:58 dillon Exp $
  33  */
  34
  35 const NFS_PORT          = 2049;
  36 const NFS_MAXDATA       = 8192;
  37 const NFS_MAXPATHLEN    = 1024;
  38 const NFS_MAXNAMLEN     = 255;
  39 const NFS_FHSIZE        = 32;
  40 const NFS_COOKIESIZE    = 4;
  41 const NFS_FIFO_DEV      = -1;   /* size kludge for named pipes */
  42
  43 /*
  44  * File types
  45  */
  46 const NFSMODE_FMT  = 0170000;   /* type of file */
  47 const NFSMODE_DIR  = 0040000;   /* directory */
  48 const NFSMODE_CHR  = 0020000;   /* character special */
  49 const NFSMODE_BLK  = 0060000;   /* block special */
  50 const NFSMODE_REG  = 0100000;   /* regular */
  51 const NFSMODE_LNK  = 0120000;   /* symbolic link */
  52 const NFSMODE_SOCK = 0140000;   /* socket */
  53 const NFSMODE_FIFO = 0010000;   /* fifo */
  54
  55 /*
  56  * Error status
  57  */
  58 enum nfsstat {
  59         NFS_OK= 0,              /* no error */
  60         NFSERR_PERM=1,          /* Not owner */
  61         NFSERR_NOENT=2,         /* No such file or directory */
  62         NFSERR_IO=5,            /* I/O error */
  63         NFSERR_NXIO=6,          /* No such device or address */
  64         NFSERR_ACCES=13,        /* Permission denied */
  65         NFSERR_EXIST=17,        /* File exists */
  66         NFSERR_NODEV=19,        /* No such device */
  67         NFSERR_NOTDIR=20,       /* Not a directory*/
  68         NFSERR_ISDIR=21,        /* Is a directory */
  69         NFSERR_FBIG=27,         /* File too large */
  70         NFSERR_NOSPC=28,        /* No space left on device */
  71         NFSERR_ROFS=30,         /* Read-only file system */
  72         NFSERR_NAMETOOLONG=63,  /* File name too long */
  73         NFSERR_NOTEMPTY=66,     /* Directory not empty */
  74         NFSERR_DQUOT=69,        /* Disc quota exceeded */
  75         NFSERR_STALE=70,        /* Stale NFS file handle */
  76         NFSERR_WFLUSH=99        /* write cache flushed */
  77 };
  78
  79 /*
  80  * File types
  81  */
  82 enum ftype {
  83         NFNON = 0,      /* non-file */
  84         NFREG = 1,      /* regular file */
  85         NFDIR = 2,      /* directory */
  86         NFBLK = 3,      /* block special */
  87         NFCHR = 4,      /* character special */
  88         NFLNK = 5,      /* symbolic link */
  89         NFSOCK = 6,     /* unix domain sockets */
  90         NFBAD = 7,      /* unused */
  91         NFFIFO = 8      /* named pipe */
  92 };
  93
  94 /*
  95  * File access handle
  96  */
  97 struct nfs_fh {
  98         opaque data[NFS_FHSIZE];
  99 };
 100
 101 /*
 102  * Timeval
 103  */
 104 struct nfstime {
 105         unsigned seconds;
 106         unsigned useconds;
 107 };
 108
 109
 110 /*
 111  * File attributes
 112  */
 113 struct fattr {
 114         ftype type;             /* file type */
 115         unsigned mode;          /* protection mode bits */
 116         unsigned nlink;         /* # hard links */
 117         unsigned uid;           /* owner user id */
 118         unsigned gid;           /* owner group id */
 119         unsigned size;          /* file size in bytes */
 120         unsigned blocksize;     /* prefered block size */
 121         unsigned rdev;          /* special device # */
 122         unsigned blocks;        /* Kb of disk used by file */
 123         unsigned fsid;          /* device # */
 124         unsigned fileid;        /* inode # */
 125         nfstime atime;          /* time of last access */
 126         nfstime mtime;          /* time of last modification */
 127         nfstime ctime;          /* time of last change */
 128 };
 129
 130 /*
 131  * File attributes which can be set
 132  */
 133 struct sattr {
 134         unsigned mode;  /* protection mode bits */
 135         unsigned uid;   /* owner user id */
 136         unsigned gid;   /* owner group id */
 137         unsigned size;  /* file size in bytes */
 138         nfstime atime;  /* time of last access */
 139         nfstime mtime;  /* time of last modification */
 140 };
 141
 142
 143 typedef string filename<NFS_MAXNAMLEN>;
 144 typedef string nfspath<NFS_MAXPATHLEN>;
 145
 146 /*
 147  * Reply status with file attributes
 148  */
 149 union attrstat switch (nfsstat status) {
 150 case NFS_OK:
 151         fattr attributes;
 152 default:
 153         void;
 154 };
 155
 156 struct sattrargs {
 157         nfs_fh file;
 158         sattr attributes;
 159 };
 160
 161 /*
 162  * Arguments for directory operations
 163  */
 164 struct diropargs {
 165         nfs_fh  dir;    /* directory file handle */
 166         filename name;          /* name (up to NFS_MAXNAMLEN bytes) */
 167 };
 168
 169 struct diropokres {
 170         nfs_fh file;
 171         fattr attributes;
 172 };
 173
 174 /*
 175  * Results from directory operation
 176  */
 177 union diropres switch (nfsstat status) {
 178 case NFS_OK:
 179         diropokres diropres;
 180 default:
 181         void;
 182 };
 183
 184 union readlinkres switch (nfsstat status) {
 185 case NFS_OK:
 186         nfspath data;
 187 default:
 188         void;
 189 };
 190
 191 /*
 192  * Arguments to remote read
 193  */
 194 struct readargs {
 195         nfs_fh file;            /* handle for file */
 196         unsigned offset;        /* byte offset in file */
 197         unsigned count;         /* immediate read count */
 198         unsigned totalcount;    /* total read count (from this offset)*/
 199 };
 200
 201 /*
 202  * Status OK portion of remote read reply
 203  */
 204 struct readokres {
 205         fattr   attributes;     /* attributes, need for pagin*/
 206         opaque data<NFS_MAXDATA>;
 207 };
 208
 209 union readres switch (nfsstat status) {
 210 case NFS_OK:
 211         readokres reply;
 212 default:
 213         void;
 214 };
 215
 216 /*
 217  * Arguments to remote write
 218  */
 219 struct writeargs {
 220         nfs_fh  file;           /* handle for file */
 221         unsigned beginoffset;   /* beginning byte offset in file */
 222         unsigned offset;        /* current byte offset in file */
 223         unsigned totalcount;    /* total write count (to this offset)*/
 224         opaque data<NFS_MAXDATA>;
 225 };
 226
 227 struct createargs {
 228         diropargs where;
 229         sattr attributes;
 230 };
 231
 232 struct renameargs {
 233         diropargs from;
 234         diropargs to;
 235 };
 236
 237 struct linkargs {
 238         nfs_fh from;
 239         diropargs to;
 240 };
 241
 242 struct symlinkargs {
 243         diropargs from;
 244         nfspath to;
 245         sattr attributes;
 246 };
 247
 248
 249 typedef opaque nfscookie[NFS_COOKIESIZE];
 250
 251 /*
 252  * Arguments to readdir
 253  */
 254 struct readdirargs {
 255         nfs_fh dir;             /* directory handle */
 256         nfscookie cookie;
 257         unsigned count;         /* number of directory bytes to read */
 258 };
 259
 260 struct entry {
 261         unsigned fileid;
 262         filename name;
 263         nfscookie cookie;
 264         entry *nextentry;
 265 };
 266
 267 struct dirlist {
 268         entry *entries;
 269         bool eof;
 270 };
 271
 272 union readdirres switch (nfsstat status) {
 273 case NFS_OK:
 274         dirlist reply;
 275 default:
 276         void;
 277 };
 278
 279 struct statfsokres {
 280         unsigned tsize; /* preferred transfer size in bytes */
 281         unsigned bsize; /* fundamental file system block size */
 282         unsigned blocks;        /* total blocks in file system */
 283         unsigned bfree; /* free blocks in fs */
 284         unsigned bavail;        /* free blocks avail to non-superuser */
 285 };
 286
 287 union statfsres switch (nfsstat status) {
 288 case NFS_OK:
 289         statfsokres reply;
 290 default:
 291         void;
 292 };
 293
 294 #ifdef WANT_NFS3
 295
 296 /*
 297  * NFSv3 constants and types
 298  */
 299 const NFS3_FHSIZE       = 64;   /* maximum size in bytes of a file handle */
 300 const NFS3_COOKIEVERFSIZE = 8;  /* size of a cookie verifier for READDIR */
 301 const NFS3_CREATEVERFSIZE = 8;  /* size of the verifier used for CREATE */
 302 const NFS3_WRITEVERFSIZE = 8;   /* size of the verifier used for WRITE */
 303
 304 typedef unsigned hyper uint64;
 305 typedef hyper int64;
 306 typedef unsigned long uint32;
 307 typedef long int32;
 308 typedef string filename3<>;
 309 typedef string nfspath3<>;
 310 typedef uint64 fileid3;
 311 typedef uint64 cookie3;
 312 typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
 313 typedef opaque createverf3[NFS3_CREATEVERFSIZE];
 314 typedef opaque writeverf3[NFS3_WRITEVERFSIZE];
 315 typedef uint32 uid3;
 316 typedef uint32 gid3;
 317 typedef uint64 size3;
 318 typedef uint64 offset3;
 319 typedef uint32 mode3;
 320 typedef uint32 count3;
 321
 322 /*
 323  * Error status (v3)
 324  */
 325 enum nfsstat3 {
 326         NFS3_OK = 0,
 327         NFS3ERR_PERM            = 1,
 328         NFS3ERR_NOENT           = 2,
 329         NFS3ERR_IO              = 5,
 330         NFS3ERR_NXIO            = 6,
 331         NFS3ERR_ACCES           = 13,
 332         NFS3ERR_EXIST           = 17,
 333         NFS3ERR_XDEV            = 18,
 334         NFS3ERR_NODEV           = 19,
 335         NFS3ERR_NOTDIR          = 20,
 336         NFS3ERR_ISDIR           = 21,
 337         NFS3ERR_INVAL           = 22,
 338         NFS3ERR_FBIG            = 27,
 339         NFS3ERR_NOSPC           = 28,
 340         NFS3ERR_ROFS            = 30,
 341         NFS3ERR_MLINK           = 31,
 342         NFS3ERR_NAMETOOLONG     = 63,
 343         NFS3ERR_NOTEMPTY        = 66,
 344         NFS3ERR_DQUOT           = 69,
 345         NFS3ERR_STALE           = 70,
 346         NFS3ERR_REMOTE          = 71,
 347         NFS3ERR_BADHANDLE       = 10001,
 348         NFS3ERR_NOT_SYNC        = 10002,
 349         NFS3ERR_BAD_COOKIE      = 10003,
 350         NFS3ERR_NOTSUPP         = 10004,
 351         NFS3ERR_TOOSMALL        = 10005,
 352         NFS3ERR_SERVERFAULT     = 10006,
 353         NFS3ERR_BADTYPE         = 10007,
 354         NFS3ERR_JUKEBOX         = 10008
 355 };
 356
 357 /*
 358  * File types (v3)
 359  */
 360 enum ftype3 {
 361         NF3REG  = 1,            /* regular file */
 362         NF3DIR  = 2,            /* directory */
 363         NF3BLK  = 3,            /* block special */
 364         NF3CHR  = 4,            /* character special */
 365         NF3LNK  = 5,            /* symbolic link */
 366         NF3SOCK = 6,            /* unix domain sockets */
 367         NF3FIFO = 7             /* named pipe */
 368 };
 369
 370 struct specdata3 {
 371         uint32  specdata1;
 372         uint32  specdata2;
 373 };
 374
 375 /*
 376  * File access handle (v3)
 377  */
 378 struct nfs_fh3 {
 379         opaque data<NFS3_FHSIZE>;
 380 };
 381
 382 /*
 383  * Timeval (v3)
 384  */
 385 struct nfstime3 {
 386         uint32  seconds;
 387         uint32  nseconds;
 388 };
 389
 390
 391 /*
 392  * File attributes (v3)
 393  */
 394 struct fattr3 {
 395         ftype3  type;           /* file type */
 396         mode3   mode;           /* protection mode bits */
 397         uint32  nlink;          /* # hard links */
 398         uid3    uid;            /* owner user id */
 399         gid3    gid;            /* owner group id */
 400         size3   size;           /* file size in bytes */
 401         size3   used;           /* prefered block size */
 402         specdata3 rdev;         /* special device # */
 403         uint64 fsid;            /* device # */
 404         fileid3 fileid;         /* inode # */
 405         nfstime3 atime;         /* time of last access */
 406         nfstime3 mtime;         /* time of last modification */
 407         nfstime3 ctime;         /* time of last change */
 408 };
 409
 410 union post_op_attr switch (bool attributes_follow) {
 411 case TRUE:
 412         fattr3  attributes;
 413 case FALSE:
 414         void;
 415 };
 416
 417 struct wcc_attr {
 418         size3   size;
 419         nfstime3 mtime;
 420         nfstime3 ctime;
 421 };
 422
 423 union pre_op_attr switch (bool attributes_follow) {
 424 case TRUE:
 425         wcc_attr attributes;
 426 case FALSE:
 427         void;
 428 };
 429
 430 struct wcc_data {
 431         pre_op_attr before;
 432         post_op_attr after;
 433 };
 434
 435 union post_op_fh3 switch (bool handle_follows) {
 436 case TRUE:
 437         nfs_fh3 handle;
 438 case FALSE:
 439         void;
 440 };
 441
 442 /*
 443  * File attributes which can be set (v3)
 444  */
 445 enum time_how {
 446         DONT_CHANGE             = 0,
 447         SET_TO_SERVER_TIME      = 1,
 448         SET_TO_CLIENT_TIME      = 2
 449 };
 450
 451 union set_mode3 switch (bool set_it) {
 452 case TRUE:
 453         mode3   mode;
 454 default:
 455         void;
 456 };
 457
 458 union set_uid3 switch (bool set_it) {
 459 case TRUE:
 460         uid3    uid;
 461 default:
 462         void;
 463 };
 464
 465 union set_gid3 switch (bool set_it) {
 466 case TRUE:
 467         gid3    gid;
 468 default:
 469         void;
 470 };
 471
 472 union set_size3 switch (bool set_it) {
 473 case TRUE:
 474         size3   size;
 475 default:
 476         void;
 477 };
 478
 479 union set_atime switch (time_how set_it) {
 480 case SET_TO_CLIENT_TIME:
 481         nfstime3        atime;
 482 default:
 483         void;
 484 };
 485
 486 union set_mtime switch (time_how set_it) {
 487 case SET_TO_CLIENT_TIME:
 488         nfstime3        mtime;
 489 default:
 490         void;
 491 };
 492
 493 struct sattr3 {
 494         set_mode3       mode;
 495         set_uid3        uid;
 496         set_gid3        gid;
 497         set_size3       size;
 498         set_atime       atime;
 499         set_mtime       mtime;
 500 };
 501
 502 /*
 503  * Arguments for directory operations (v3)
 504  */
 505 struct diropargs3 {
 506         nfs_fh3 dir;            /* directory file handle */
 507         filename3 name;         /* name (up to NFS_MAXNAMLEN bytes) */
 508 };
 509
 510 /*
 511  * Arguments to getattr (v3).
 512  */
 513 struct GETATTR3args {
 514         nfs_fh3         object;
 515 };
 516
 517 struct GETATTR3resok {
 518         fattr3          obj_attributes;
 519 };
 520
 521 union GETATTR3res switch (nfsstat3 status) {
 522 case NFS3_OK:
 523         GETATTR3resok   resok;
 524 default:
 525         void;
 526 };
 527
 528 /*
 529  * Arguments to setattr (v3).
 530  */
 531 union sattrguard3 switch (bool check) {
 532 case TRUE:
 533         nfstime3        obj_ctime;
 534 case FALSE:
 535         void;
 536 };
 537
 538 struct SETATTR3args {
 539         nfs_fh3         object;
 540         sattr3          new_attributes;
 541         sattrguard3     guard;
 542 };
 543
 544 struct SETATTR3resok {
 545         wcc_data        obj_wcc;
 546 };
 547
 548 struct SETATTR3resfail {
 549         wcc_data        obj_wcc;
 550 };
 551
 552 union SETATTR3res switch (nfsstat3 status) {
 553 case NFS3_OK:
 554         SETATTR3resok   resok;
 555 default:
 556         SETATTR3resfail resfail;
 557 };
 558
 559 /*
 560  * Arguments to lookup (v3).
 561  */
 562 struct LOOKUP3args {
 563         diropargs3      what;
 564 };
 565
 566 struct LOOKUP3resok {
 567         nfs_fh3         object;
 568         post_op_attr    obj_attributes;
 569         post_op_attr    dir_attributes;
 570 };
 571
 572 struct LOOKUP3resfail {
 573         post_op_attr    dir_attributes;
 574 };
 575
 576 union LOOKUP3res switch (nfsstat3 status) {
 577 case NFS3_OK:
 578         LOOKUP3resok    resok;
 579 default:
 580         LOOKUP3resfail  resfail;
 581 };
 582
 583 /*
 584  * Arguments to access (v3).
 585  */
 586 const ACCESS3_READ      = 0x0001;
 587 const ACCESS3_LOOKUP    = 0x0002;
 588 const ACCESS3_MODIFY    = 0x0004;
 589 const ACCESS3_EXTEND    = 0x0008;
 590 const ACCESS3_DELETE    = 0x0010;
 591 const ACCESS3_EXECUTE   = 0x0020;
 592
 593 struct ACCESS3args {
 594         nfs_fh3         object;
 595         uint32          access;
 596 };
 597
 598 struct ACCESS3resok {
 599         post_op_attr    obj_attributes;
 600         uint32          access;
 601 };
 602
 603 struct ACCESS3resfail {
 604         post_op_attr    obj_attributes;
 605 };
 606
 607 union ACCESS3res switch (nfsstat3 status) {
 608 case NFS3_OK:
 609         ACCESS3resok    resok;
 610 default:
 611         ACCESS3resfail  resfail;
 612 };
 613
 614 /*
 615  * Arguments to readlink (v3).
 616  */
 617 struct READLINK3args {
 618         nfs_fh3         symlink;
 619 };
 620
 621 struct READLINK3resok {
 622         post_op_attr    symlink_attributes;
 623         nfspath3        data;
 624 };
 625
 626 struct READLINK3resfail {
 627         post_op_attr    symlink_attributes;
 628 };
 629
 630 union READLINK3res switch (nfsstat3 status) {
 631 case NFS3_OK:
 632         READLINK3resok  resok;
 633 default:
 634         READLINK3resfail resfail;
 635 };
 636
 637 /*
 638  * Arguments to read (v3).
 639  */
 640 struct READ3args {
 641         nfs_fh3         file;
 642         offset3         offset;
 643         count3          count;
 644 };
 645
 646 struct READ3resok {
 647         post_op_attr    file_attributes;
 648         count3          count;
 649         bool            eof;
 650         opaque          data<>;
 651 };
 652
 653 struct READ3resfail {
 654         post_op_attr    file_attributes;
 655 };
 656
 657 /* XXX: solaris 2.6 uses ``nfsstat'' here */
 658 union READ3res switch (nfsstat3 status) {
 659 case NFS3_OK:
 660         READ3resok      resok;
 661 default:
 662         READ3resfail    resfail;
 663 };
 664
 665 /*
 666  * Arguments to write (v3).
 667  */
 668 enum stable_how {
 669         UNSTABLE        = 0,
 670         DATA_SYNC       = 1,
 671         FILE_SYNC       = 2
 672 };
 673
 674 struct WRITE3args {
 675         nfs_fh3         file;
 676         offset3         offset;
 677         count3          count;
 678         stable_how      stable;
 679         opaque          data<>;
 680 };
 681
 682 struct WRITE3resok {
 683         wcc_data        file_wcc;
 684         count3          count;
 685         stable_how      committed;
 686         writeverf3      verf;
 687 };
 688
 689 struct WRITE3resfail {
 690         wcc_data        file_wcc;
 691 };
 692
 693 union WRITE3res switch (nfsstat3 status) {
 694 case NFS3_OK:
 695         WRITE3resok     resok;
 696 default:
 697         WRITE3resfail   resfail;
 698 };
 699
 700 /*
 701  * Arguments to create (v3).
 702  */
 703 enum createmode3 {
 704         UNCHECKED       = 0,
 705         GUARDED         = 1,
 706         EXCLUSIVE       = 2
 707 };
 708
 709 union createhow3 switch (createmode3 mode) {
 710 case UNCHECKED:
 711 case GUARDED:
 712         sattr3          obj_attributes;
 713 case EXCLUSIVE:
 714         createverf3     verf;
 715 };
 716
 717 struct CREATE3args {
 718         diropargs3      where;
 719         createhow3      how;
 720 };
 721
 722 struct CREATE3resok {
 723         post_op_fh3     obj;
 724         post_op_attr    obj_attributes;
 725         wcc_data        dir_wcc;
 726 };
 727
 728 struct CREATE3resfail {
 729         wcc_data        dir_wcc;
 730 };
 731
 732 union CREATE3res switch (nfsstat3 status) {
 733 case NFS3_OK:
 734         CREATE3resok    resok;
 735 default:
 736         CREATE3resfail  resfail;
 737 };
 738
 739 /*
 740  * Arguments to mkdir (v3).
 741  */
 742 struct MKDIR3args {
 743         diropargs3      where;
 744         sattr3          attributes;
 745 };
 746
 747 struct MKDIR3resok {
 748         post_op_fh3     obj;
 749         post_op_attr    obj_attributes;
 750         wcc_data        dir_wcc;
 751 };
 752
 753 struct MKDIR3resfail {
 754         wcc_data        dir_wcc;
 755 };
 756
 757 union MKDIR3res switch (nfsstat3 status) {
 758 case NFS3_OK:
 759         MKDIR3resok     resok;
 760 default:
 761         MKDIR3resfail   resfail;
 762 };
 763
 764 /*
 765  * Arguments to symlink (v3).
 766  */
 767 struct symlinkdata3 {
 768         sattr3          symlink_attributes;
 769         nfspath3        symlink_data;
 770 };
 771
 772 struct SYMLINK3args {
 773         diropargs3      where;
 774         symlinkdata3    symlink;
 775 };
 776
 777 struct SYMLINK3resok {
 778         post_op_fh3     obj;
 779         post_op_attr    obj_attributes;
 780         wcc_data        dir_wcc;
 781 };
 782
 783 struct SYMLINK3resfail {
 784         wcc_data        dir_wcc;
 785 };
 786
 787 union SYMLINK3res switch (nfsstat3 status) {
 788 case NFS3_OK:
 789         SYMLINK3resok   resok;
 790 default:
 791         SYMLINK3resfail resfail;
 792 };
 793
 794 /*
 795  * Arguments to mknod (v3).
 796  */
 797 struct devicedata3 {
 798         sattr3          dev_attributes;
 799         specdata3       spec;
 800 };
 801
 802 union mknoddata3 switch (ftype3 type) {
 803 case NF3CHR:
 804 case NF3BLK:
 805         devicedata3     device;
 806 case NF3SOCK:
 807 case NF3FIFO:
 808         sattr3          pipe_attributes;
 809 default:
 810         void;
 811 };
 812
 813 struct MKNOD3args {
 814         diropargs3      where;
 815         mknoddata3      what;
 816 };
 817
 818 struct MKNOD3resok {
 819         post_op_fh3     obj;
 820         post_op_attr    obj_attributes;
 821         wcc_data        dir_wcc;
 822 };
 823
 824 struct MKNOD3resfail {
 825         wcc_data        dir_wcc;
 826 };
 827
 828 union MKNOD3res switch (nfsstat3 status) {
 829 case NFS3_OK:
 830         MKNOD3resok     resok;
 831 default:
 832         MKNOD3resfail   resfail;
 833 };
 834
 835 /*
 836  * Arguments to remove (v3).
 837  */
 838 struct REMOVE3args {
 839         diropargs3      object;
 840 };
 841
 842 struct REMOVE3resok {
 843         wcc_data        dir_wcc;
 844 };
 845
 846 struct REMOVE3resfail {
 847         wcc_data        dir_wcc;
 848 };
 849
 850 union REMOVE3res switch (nfsstat3 status) {
 851 case NFS3_OK:
 852         REMOVE3resok    resok;
 853 default:
 854         REMOVE3resfail  resfail;
 855 };
 856
 857 /*
 858  * Arguments to rmdir (v3).
 859  */
 860 struct RMDIR3args {
 861         diropargs3      object;
 862 };
 863
 864 struct RMDIR3resok {
 865         wcc_data        dir_wcc;
 866 };
 867
 868 struct RMDIR3resfail {
 869         wcc_data        dir_wcc;
 870 };
 871
 872 union RMDIR3res switch (nfsstat3 status) {
 873 case NFS3_OK:
 874         RMDIR3resok     resok;
 875 default:
 876         RMDIR3resfail   resfail;
 877 };
 878
 879 /*
 880  * Arguments to rename (v3).
 881  */
 882 struct RENAME3args {
 883         diropargs3      from;
 884         diropargs3      to;
 885 };
 886
 887 struct RENAME3resok {
 888         wcc_data        fromdir_wcc;
 889         wcc_data        todir_wcc;
 890 };
 891
 892 struct RENAME3resfail {
 893         wcc_data        fromdir_wcc;
 894         wcc_data        todir_wcc;
 895 };
 896
 897 union RENAME3res switch (nfsstat3 status) {
 898 case NFS3_OK:
 899         RENAME3resok    resok;
 900 default:
 901         RENAME3resfail  resfail;
 902 };
 903
 904 /*
 905  * Arguments to link (v3).
 906  */
 907 struct LINK3args {
 908         nfs_fh3         file;
 909         diropargs3      link;
 910 };
 911
 912 struct LINK3resok {
 913         post_op_attr    file_attributes;
 914         wcc_data        linkdir_wcc;
 915 };
 916
 917 struct LINK3resfail {
 918         post_op_attr    file_attributes;
 919         wcc_data        linkdir_wcc;
 920 };
 921
 922 union LINK3res switch (nfsstat3 status) {
 923 case NFS3_OK:
 924         LINK3resok      resok;
 925 default:
 926         LINK3resfail    resfail;
 927 };
 928
 929 /*
 930  * Arguments to readdir (v3).
 931  */
 932 struct READDIR3args {
 933         nfs_fh3         dir;
 934         cookie3         cookie;
 935         cookieverf3     cookieverf;
 936         count3          count;
 937 };
 938
 939 struct entry3 {
 940         fileid3         fileid;
 941         filename3       name;
 942         cookie3         cookie;
 943         entry3          *nextentry;
 944 };
 945
 946 struct dirlist3 {
 947         entry3          *entries;
 948         bool            eof;
 949 };
 950
 951 struct READDIR3resok {
 952         post_op_attr    dir_attributes;
 953         cookieverf3     cookieverf;
 954         dirlist3        reply;
 955 };
 956
 957 struct READDIR3resfail {
 958         post_op_attr    dir_attributes;
 959 };
 960
 961 union READDIR3res switch (nfsstat3 status) {
 962 case NFS3_OK:
 963         READDIR3resok   resok;
 964 default:
 965         READDIR3resfail resfail;
 966 };
 967
 968 /*
 969  * Arguments to readdirplus (v3).
 970  */
 971 struct READDIRPLUS3args {
 972         nfs_fh3         dir;
 973         cookie3         cookie;
 974         cookieverf3     cookieverf;
 975         count3          dircount;
 976         count3          maxcount;
 977 };
 978
 979 struct entryplus3 {
 980         fileid3         fileid;
 981         filename3       name;
 982         cookie3         cookie;
 983         post_op_attr    name_attributes;
 984         post_op_fh3     name_handle;
 985         entryplus3      *nextentry;
 986 };
 987
 988 struct dirlistplus3 {
 989         entryplus3      *entries;
 990         bool            eof;
 991 };
 992
 993 struct READDIRPLUS3resok {
 994         post_op_attr    dir_attributes;
 995         cookieverf3     cookieverf;
 996         dirlistplus3    reply;
 997 };
 998
 999 struct READDIRPLUS3resfail {
1000         post_op_attr    dir_attributes;
1001 };
1002
1003 union READDIRPLUS3res switch (nfsstat3 status) {
1004 case NFS3_OK:
1005         READDIRPLUS3resok       resok;
1006 default:
1007         READDIRPLUS3resfail     resfail;
1008 };
1009
1010 /*
1011  * Arguments to fsstat (v3).
1012  */
1013 struct FSSTAT3args {
1014         nfs_fh3         fsroot;
1015 };
1016
1017 struct FSSTAT3resok {
1018         post_op_attr    obj_attributes;
1019         size3           tbytes;
1020         size3           fbytes;
1021         size3           abytes;
1022         size3           tfiles;
1023         size3           ffiles;
1024         size3           afiles;
1025         uint32          invarsec;
1026 };
1027
1028 struct FSSTAT3resfail {
1029         post_op_attr    obj_attributes;
1030 };
1031
1032 union FSSTAT3res switch (nfsstat3 status) {
1033 case NFS3_OK:
1034         FSSTAT3resok    resok;
1035 default:
1036         FSSTAT3resfail  resfail;
1037 };
1038
1039 /*
1040  * Arguments to fsinfo (v3).
1041  */
1042 const FSF3_LINK         = 0x0001;
1043 const FSF3_SYMLINK      = 0x0002;
1044 const FSF3_HOMOGENEOUS  = 0x0008;
1045 const FSF3_CANSETTIME   = 0x0010;
1046
1047 struct FSINFO3args {
1048         nfs_fh3         fsroot;
1049 };
1050
1051 struct FSINFO3resok {
1052         post_op_attr    obj_attributes;
1053         uint32          rtmax;
1054         uint32          rtpref;
1055         uint32          rtmult;
1056         uint32          wtmax;
1057         uint32          wtpref;
1058         uint32          wtmult;
1059         uint32          dtpref;
1060         size3           maxfilesize;
1061         nfstime3        time_delta;
1062         uint32          properties;
1063 };
1064
1065 struct FSINFO3resfail {
1066         post_op_attr    obj_attributes;
1067 };
1068
1069 union FSINFO3res switch (nfsstat3 status) {
1070 case NFS3_OK:
1071         FSINFO3resok    resok;
1072 default:
1073         FSINFO3resfail  resfail;
1074 };
1075
1076 /*
1077  * Arguments to pathconf (v3).
1078  */
1079 struct PATHCONF3args {
1080         nfs_fh3         object;
1081 };
1082
1083 struct PATHCONF3resok {
1084         post_op_attr    obj_attributes;
1085         uint32          linkmax;
1086         uint32          name_max;
1087         bool            no_trunc;
1088         bool            chown_restricted;
1089         bool            case_insensitive;
1090         bool            case_preserving;
1091 };
1092
1093 struct PATHCONF3resfail {
1094         post_op_attr    obj_attributes;
1095 };
1096
1097 union PATHCONF3res switch (nfsstat3 status) {
1098 case NFS3_OK:
1099         PATHCONF3resok  resok;
1100 default:
1101         PATHCONF3resfail        resfail;
1102 };
1103
1104 /*
1105  * Arguments to commit (v3).
1106  */
1107 struct COMMIT3args {
1108         nfs_fh3         file;
1109         offset3         offset;
1110         count3          count;
1111 };
1112
1113 struct COMMIT3resok {
1114         wcc_data        file_wcc;
1115         writeverf3      verf;
1116 };
1117
1118 struct COMMIT3resfail {
1119         wcc_data        file_wcc;
1120 };
1121
1122 union COMMIT3res switch (nfsstat3 status) {
1123 case NFS3_OK:
1124         COMMIT3resok    resok;
1125 default:
1126         COMMIT3resfail  resfail;
1127 };
1128
1129 #endif /* WANT_NFS3 */
1130
1131 /*
1132  * Remote file service routines
1133  */
1134 program NFS_PROGRAM {
1135         version NFS_VERSION {
1136                 void
1137                 NFSPROC_NULL(void) = 0;
1138
1139                 attrstat
1140                 NFSPROC_GETATTR(nfs_fh) =       1;
1141
1142                 attrstat
1143                 NFSPROC_SETATTR(sattrargs) = 2;
1144
1145                 void
1146                 NFSPROC_ROOT(void) = 3;
1147
1148                 diropres
1149                 NFSPROC_LOOKUP(diropargs) = 4;
1150
1151                 readlinkres
1152                 NFSPROC_READLINK(nfs_fh) = 5;
1153
1154                 readres
1155                 NFSPROC_READ(readargs) = 6;
1156
1157                 void
1158                 NFSPROC_WRITECACHE(void) = 7;
1159
1160                 attrstat
1161                 NFSPROC_WRITE(writeargs) = 8;
1162
1163                 diropres
1164                 NFSPROC_CREATE(createargs) = 9;
1165
1166                 nfsstat
1167                 NFSPROC_REMOVE(diropargs) = 10;
1168
1169                 nfsstat
1170                 NFSPROC_RENAME(renameargs) = 11;
1171
1172                 nfsstat
1173                 NFSPROC_LINK(linkargs) = 12;
1174
1175                 nfsstat
1176                 NFSPROC_SYMLINK(symlinkargs) = 13;
1177
1178                 diropres
1179                 NFSPROC_MKDIR(createargs) = 14;
1180
1181                 nfsstat
1182                 NFSPROC_RMDIR(diropargs) = 15;
1183
1184                 readdirres
1185                 NFSPROC_READDIR(readdirargs) = 16;
1186
1187                 statfsres
1188                 NFSPROC_STATFS(nfs_fh) = 17;
1189         } = 2;
1190 } = 100003;
1191 #ifdef WANT_NFS3
1192 program NFS3_PROGRAM {
1193         version NFS_V3 {
1194                 void
1195                 NFSPROC3_NULL(void)                     = 0;
1196
1197                 GETATTR3res
1198                 NFSPROC3_GETATTR(GETATTR3args)          = 1;
1199
1200                 SETATTR3res
1201                 NFSPROC3_SETATTR(SETATTR3args)          = 2;
1202
1203                 LOOKUP3res
1204                 NFSPROC3_LOOKUP(LOOKUP3args)            = 3;
1205
1206                 ACCESS3res
1207                 NFSPROC3_ACCESS(ACCESS3args)            = 4;
1208
1209                 READLINK3res
1210                 NFSPROC3_READLINK(READLINK3args)        = 5;
1211
1212                 READ3res
1213                 NFSPROC3_READ(READ3args)                = 6;
1214
1215                 WRITE3res
1216                 NFSPROC3_WRITE(WRITE3args)              = 7;
1217
1218                 CREATE3res
1219                 NFSPROC3_CREATE(CREATE3args)            = 8;
1220
1221                 MKDIR3res
1222                 NFSPROC3_MKDIR(MKDIR3args)              = 9;
1223
1224                 SYMLINK3res
1225                 NFSPROC3_SYMLINK(SYMLINK3args)          = 10;
1226
1227                 MKNOD3res
1228                 NFSPROC3_MKNOD(MKNOD3args)              = 11;
1229
1230                 REMOVE3res
1231                 NFSPROC3_REMOVE(REMOVE3args)            = 12;
1232
1233                 RMDIR3res
1234                 NFSPROC3_RMDIR(RMDIR3args)              = 13;
1235
1236                 RENAME3res
1237                 NFSPROC3_RENAME(RENAME3args)            = 14;
1238
1239                 LINK3res
1240                 NFSPROC3_LINK(LINK3args)                = 15;
1241
1242                 READDIR3res
1243                 NFSPROC3_READDIR(READDIR3args)          = 16;
1244
1245                 READDIRPLUS3res
1246                 NFSPROC3_READDIRPLUS(READDIRPLUS3args)  = 17;
1247
1248                 FSSTAT3res
1249                 NFSPROC3_FSSTAT(FSSTAT3args)            = 18;
1250
1251                 FSINFO3res
1252                 NFSPROC3_FSINFO(FSINFO3args)            = 19;
1253
1254                 PATHCONF3res
1255                 NFSPROC3_PATHCONF(PATHCONF3args)        = 20;
1256
1257                 COMMIT3res
1258                 NFSPROC3_COMMIT(COMMIT3args)            = 21;
1259         } = 3;
1260 } = 100003;
1261 #endif
1262