// -*-c++-*-
/* This file was automatically generated by rpcc. */

#ifndef __RPCC_NFS_PROT_H_INCLUDED__
#define __RPCC_NFS_PROT_H_INCLUDED__ 1

#include "xdrmisc.h"

enum { NFS_PORT = 2049 };
enum { NFS_MAXDATA = 8192 };
enum { NFS_MAXPATHLEN = 1024 };
enum { NFS_MAXNAMLEN = 255 };
enum { NFS_FHSIZE = 32 };
enum { NFS_COOKIESIZE = 4 };
enum { NFS_FIFO_DEV = -1 };
enum { NFSMODE_FMT = 0170000 };
enum { NFSMODE_DIR = 0040000 };
enum { NFSMODE_CHR = 0020000 };
enum { NFSMODE_BLK = 0060000 };
enum { NFSMODE_REG = 0100000 };
enum { NFSMODE_LNK = 0120000 };
enum { NFSMODE_SOCK = 0140000 };
enum { NFSMODE_FIFO = 0010000 };

enum nfsstat {
  NFS_OK = 0,
  NFSERR_PERM = 1,
  NFSERR_NOENT = 2,
  NFSERR_IO = 5,
  NFSERR_NXIO = 6,
  NFSERR_ACCES = 13,
  NFSERR_EXIST = 17,
  NFSERR_NODEV = 19,
  NFSERR_NOTDIR = 20,
  NFSERR_ISDIR = 21,
  NFSERR_FBIG = 27,
  NFSERR_NOSPC = 28,
  NFSERR_ROFS = 30,
  NFSERR_NAMETOOLONG = 63,
  NFSERR_NOTEMPTY = 66,
  NFSERR_DQUOT = 69,
  NFSERR_STALE = 70,
  NFSERR_WFLUSH = 99,
};
void *nfsstat_alloc ();
bool_t xdr_nfsstat (XDR *, void *);
RPC_ENUM_DECL (nfsstat)

template<class T> inline bool
rpc_traverse (T &t, nfsstat &obj)
{
  u_int32_t val = obj;
  if (!rpc_traverse (t, val))
    return false;
  obj = nfsstat (val);
  return true;
}

enum ftype {
  NFNON = 0,
  NFREG = 1,
  NFDIR = 2,
  NFBLK = 3,
  NFCHR = 4,
  NFLNK = 5,
  NFSOCK = 6,
  NFBAD = 7,
  NFFIFO = 8,
};
void *ftype_alloc ();
bool_t xdr_ftype (XDR *, void *);
RPC_ENUM_DECL (ftype)

template<class T> inline bool
rpc_traverse (T &t, ftype &obj)
{
  u_int32_t val = obj;
  if (!rpc_traverse (t, val))
    return false;
  obj = ftype (val);
  return true;
}


struct nfs_fh {
  rpc_opaque<NFS_FHSIZE> data;
};
void *nfs_fh_alloc ();
bool_t xdr_nfs_fh (XDR *, void *);
RPC_STRUCT_DECL (nfs_fh)

template<class T> inline bool
rpc_traverse (T &t, nfs_fh &obj)
{
  return rpc_traverse (t, obj.data);
}



struct nfstime {
  u_int32_t seconds;
  u_int32_t useconds;
};
void *nfstime_alloc ();
bool_t xdr_nfstime (XDR *, void *);
RPC_STRUCT_DECL (nfstime)

template<class T> bool
rpc_traverse (T &t, nfstime &obj)
{
  return rpc_traverse (t, obj.seconds)
    && rpc_traverse (t, obj.useconds);
}



struct fattr {
  ftype type;
  u_int32_t mode;
  u_int32_t nlink;
  u_int32_t uid;
  u_int32_t gid;
  u_int32_t size;
  u_int32_t blocksize;
  u_int32_t rdev;
  u_int32_t blocks;
  u_int32_t fsid;
  u_int32_t fileid;
  nfstime atime;
  nfstime mtime;
  nfstime ctime;
};
void *fattr_alloc ();
bool_t xdr_fattr (XDR *, void *);
RPC_STRUCT_DECL (fattr)

template<class T> bool
rpc_traverse (T &t, fattr &obj)
{
  return rpc_traverse (t, obj.type)
    && rpc_traverse (t, obj.mode)
    && rpc_traverse (t, obj.nlink)
    && rpc_traverse (t, obj.uid)
    && rpc_traverse (t, obj.gid)
    && rpc_traverse (t, obj.size)
    && rpc_traverse (t, obj.blocksize)
    && rpc_traverse (t, obj.rdev)
    && rpc_traverse (t, obj.blocks)
    && rpc_traverse (t, obj.fsid)
    && rpc_traverse (t, obj.fileid)
    && rpc_traverse (t, obj.atime)
    && rpc_traverse (t, obj.mtime)
    && rpc_traverse (t, obj.ctime);
}



struct sattr {
  u_int32_t mode;
  u_int32_t uid;
  u_int32_t gid;
  u_int32_t size;
  nfstime atime;
  nfstime mtime;
};
void *sattr_alloc ();
bool_t xdr_sattr (XDR *, void *);
RPC_STRUCT_DECL (sattr)

template<class T> bool
rpc_traverse (T &t, sattr &obj)
{
  return rpc_traverse (t, obj.mode)
    && rpc_traverse (t, obj.uid)
    && rpc_traverse (t, obj.gid)
    && rpc_traverse (t, obj.size)
    && rpc_traverse (t, obj.atime)
    && rpc_traverse (t, obj.mtime);
}


typedef rpc_str<NFS_MAXNAMLEN> filename;
void *filename_alloc ();
bool_t xdr_filename (XDR *, void *);
RPC_TYPEDEF_DECL (filename)

typedef rpc_str<NFS_MAXPATHLEN> nfspath;
void *nfspath_alloc ();
bool_t xdr_nfspath (XDR *, void *);
RPC_TYPEDEF_DECL (nfspath)


struct attrstat {
  const nfsstat status;
  union {
    union_entry_base _base;
    union_entry<fattr> attributes;
  };

#define rpcunion_tag_attrstat status
#define rpcunion_switch_attrstat(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS_OK: \
    action (fattr, attributes); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  attrstat (nfsstat _tag = (nfsstat) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  attrstat (const attrstat &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~attrstat () { _base.destroy (); }
  attrstat &operator= (const attrstat &_s) {
    const_cast<nfsstat &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat _tag) {
    const_cast<nfsstat &> (status) = _tag;
    rpcunion_switch_attrstat
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, attrstat &obj)
{
  nfsstat tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_attrstat
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, attrstat &obj)
{
  rpcunion_switch_attrstat
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *attrstat_alloc ();
bool_t xdr_attrstat (XDR *, void *);
RPC_UNION_DECL (attrstat)



struct sattrargs {
  nfs_fh file;
  sattr attributes;
};
void *sattrargs_alloc ();
bool_t xdr_sattrargs (XDR *, void *);
RPC_STRUCT_DECL (sattrargs)

template<class T> bool
rpc_traverse (T &t, sattrargs &obj)
{
  return rpc_traverse (t, obj.file)
    && rpc_traverse (t, obj.attributes);
}



struct diropargs {
  nfs_fh dir;
  filename name;
};
void *diropargs_alloc ();
bool_t xdr_diropargs (XDR *, void *);
RPC_STRUCT_DECL (diropargs)

template<class T> bool
rpc_traverse (T &t, diropargs &obj)
{
  return rpc_traverse (t, obj.dir)
    && rpc_traverse (t, obj.name);
}



struct diropokres {
  nfs_fh file;
  fattr attributes;
};
void *diropokres_alloc ();
bool_t xdr_diropokres (XDR *, void *);
RPC_STRUCT_DECL (diropokres)

template<class T> bool
rpc_traverse (T &t, diropokres &obj)
{
  return rpc_traverse (t, obj.file)
    && rpc_traverse (t, obj.attributes);
}



struct diropres {
  const nfsstat status;
  union {
    union_entry_base _base;
    union_entry<diropokres> reply;
  };

#define rpcunion_tag_diropres status
#define rpcunion_switch_diropres(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS_OK: \
    action (diropokres, reply); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  diropres (nfsstat _tag = (nfsstat) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  diropres (const diropres &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~diropres () { _base.destroy (); }
  diropres &operator= (const diropres &_s) {
    const_cast<nfsstat &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat _tag) {
    const_cast<nfsstat &> (status) = _tag;
    rpcunion_switch_diropres
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, diropres &obj)
{
  nfsstat tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_diropres
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, diropres &obj)
{
  rpcunion_switch_diropres
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *diropres_alloc ();
bool_t xdr_diropres (XDR *, void *);
RPC_UNION_DECL (diropres)



struct readlinkres {
  const nfsstat status;
  union {
    union_entry_base _base;
    union_entry<nfspath> data;
  };

#define rpcunion_tag_readlinkres status
#define rpcunion_switch_readlinkres(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS_OK: \
    action (nfspath, data); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  readlinkres (nfsstat _tag = (nfsstat) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  readlinkres (const readlinkres &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~readlinkres () { _base.destroy (); }
  readlinkres &operator= (const readlinkres &_s) {
    const_cast<nfsstat &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat _tag) {
    const_cast<nfsstat &> (status) = _tag;
    rpcunion_switch_readlinkres
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, readlinkres &obj)
{
  nfsstat tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_readlinkres
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, readlinkres &obj)
{
  rpcunion_switch_readlinkres
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *readlinkres_alloc ();
bool_t xdr_readlinkres (XDR *, void *);
RPC_UNION_DECL (readlinkres)



struct readargs {
  nfs_fh file;
  u_int32_t offset;
  u_int32_t count;
  u_int32_t totalcount;
};
void *readargs_alloc ();
bool_t xdr_readargs (XDR *, void *);
RPC_STRUCT_DECL (readargs)

template<class T> bool
rpc_traverse (T &t, readargs &obj)
{
  return rpc_traverse (t, obj.file)
    && rpc_traverse (t, obj.offset)
    && rpc_traverse (t, obj.count)
    && rpc_traverse (t, obj.totalcount);
}



struct readokres {
  fattr attributes;
  rpc_bytes<NFS_MAXDATA> data;
};
void *readokres_alloc ();
bool_t xdr_readokres (XDR *, void *);
RPC_STRUCT_DECL (readokres)

template<class T> bool
rpc_traverse (T &t, readokres &obj)
{
  return rpc_traverse (t, obj.attributes)
    && rpc_traverse (t, obj.data);
}



struct readres {
  const nfsstat status;
  union {
    union_entry_base _base;
    union_entry<readokres> reply;
  };

#define rpcunion_tag_readres status
#define rpcunion_switch_readres(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS_OK: \
    action (readokres, reply); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  readres (nfsstat _tag = (nfsstat) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  readres (const readres &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~readres () { _base.destroy (); }
  readres &operator= (const readres &_s) {
    const_cast<nfsstat &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat _tag) {
    const_cast<nfsstat &> (status) = _tag;
    rpcunion_switch_readres
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, readres &obj)
{
  nfsstat tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_readres
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, readres &obj)
{
  rpcunion_switch_readres
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *readres_alloc ();
bool_t xdr_readres (XDR *, void *);
RPC_UNION_DECL (readres)



struct writeargs {
  nfs_fh file;
  u_int32_t beginoffset;
  u_int32_t offset;
  u_int32_t totalcount;
  rpc_bytes<NFS_MAXDATA> data;
};
void *writeargs_alloc ();
bool_t xdr_writeargs (XDR *, void *);
RPC_STRUCT_DECL (writeargs)

template<class T> bool
rpc_traverse (T &t, writeargs &obj)
{
  return rpc_traverse (t, obj.file)
    && rpc_traverse (t, obj.beginoffset)
    && rpc_traverse (t, obj.offset)
    && rpc_traverse (t, obj.totalcount)
    && rpc_traverse (t, obj.data);
}



struct createargs {
  diropargs where;
  sattr attributes;
};
void *createargs_alloc ();
bool_t xdr_createargs (XDR *, void *);
RPC_STRUCT_DECL (createargs)

template<class T> bool
rpc_traverse (T &t, createargs &obj)
{
  return rpc_traverse (t, obj.where)
    && rpc_traverse (t, obj.attributes);
}



struct renameargs {
  diropargs from;
  diropargs to;
};
void *renameargs_alloc ();
bool_t xdr_renameargs (XDR *, void *);
RPC_STRUCT_DECL (renameargs)

template<class T> bool
rpc_traverse (T &t, renameargs &obj)
{
  return rpc_traverse (t, obj.from)
    && rpc_traverse (t, obj.to);
}



struct linkargs {
  nfs_fh from;
  diropargs to;
};
void *linkargs_alloc ();
bool_t xdr_linkargs (XDR *, void *);
RPC_STRUCT_DECL (linkargs)

template<class T> bool
rpc_traverse (T &t, linkargs &obj)
{
  return rpc_traverse (t, obj.from)
    && rpc_traverse (t, obj.to);
}



struct symlinkargs {
  diropargs from;
  nfspath to;
  sattr attributes;
};
void *symlinkargs_alloc ();
bool_t xdr_symlinkargs (XDR *, void *);
RPC_STRUCT_DECL (symlinkargs)

template<class T> bool
rpc_traverse (T &t, symlinkargs &obj)
{
  return rpc_traverse (t, obj.from)
    && rpc_traverse (t, obj.to)
    && rpc_traverse (t, obj.attributes);
}


typedef rpc_opaque<NFS_COOKIESIZE> nfscookie;
void *nfscookie_alloc ();
bool_t xdr_nfscookie (XDR *, void *);
RPC_TYPEDEF_DECL (nfscookie)


struct readdirargs {
  nfs_fh dir;
  nfscookie cookie;
  u_int32_t count;
};
void *readdirargs_alloc ();
bool_t xdr_readdirargs (XDR *, void *);
RPC_STRUCT_DECL (readdirargs)

template<class T> bool
rpc_traverse (T &t, readdirargs &obj)
{
  return rpc_traverse (t, obj.dir)
    && rpc_traverse (t, obj.cookie)
    && rpc_traverse (t, obj.count);
}



struct entry {
  u_int32_t fileid;
  filename name;
  nfscookie cookie;
  rpc_ptr<entry> nextentry;
};
void *entry_alloc ();
bool_t xdr_entry (XDR *, void *);
RPC_STRUCT_DECL (entry)

template<class T> bool
rpc_traverse (T &t, entry &obj)
{
  return rpc_traverse (t, obj.fileid)
    && rpc_traverse (t, obj.name)
    && rpc_traverse (t, obj.cookie)
    && rpc_traverse (t, obj.nextentry);
}



struct dirlist {
  rpc_ptr<entry> entries;
  bool eof;
};
void *dirlist_alloc ();
bool_t xdr_dirlist (XDR *, void *);
RPC_STRUCT_DECL (dirlist)

template<class T> bool
rpc_traverse (T &t, dirlist &obj)
{
  return rpc_traverse (t, obj.entries)
    && rpc_traverse (t, obj.eof);
}



struct readdirres {
  const nfsstat status;
  union {
    union_entry_base _base;
    union_entry<dirlist> reply;
  };

#define rpcunion_tag_readdirres status
#define rpcunion_switch_readdirres(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS_OK: \
    action (dirlist, reply); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  readdirres (nfsstat _tag = (nfsstat) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  readdirres (const readdirres &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~readdirres () { _base.destroy (); }
  readdirres &operator= (const readdirres &_s) {
    const_cast<nfsstat &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat _tag) {
    const_cast<nfsstat &> (status) = _tag;
    rpcunion_switch_readdirres
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, readdirres &obj)
{
  nfsstat tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_readdirres
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, readdirres &obj)
{
  rpcunion_switch_readdirres
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *readdirres_alloc ();
bool_t xdr_readdirres (XDR *, void *);
RPC_UNION_DECL (readdirres)



struct statfsokres {
  u_int32_t tsize;
  u_int32_t bsize;
  u_int32_t blocks;
  u_int32_t bfree;
  u_int32_t bavail;
};
void *statfsokres_alloc ();
bool_t xdr_statfsokres (XDR *, void *);
RPC_STRUCT_DECL (statfsokres)

template<class T> bool
rpc_traverse (T &t, statfsokres &obj)
{
  return rpc_traverse (t, obj.tsize)
    && rpc_traverse (t, obj.bsize)
    && rpc_traverse (t, obj.blocks)
    && rpc_traverse (t, obj.bfree)
    && rpc_traverse (t, obj.bavail);
}



struct statfsres {
  const nfsstat status;
  union {
    union_entry_base _base;
    union_entry<statfsokres> reply;
  };

#define rpcunion_tag_statfsres status
#define rpcunion_switch_statfsres(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS_OK: \
    action (statfsokres, reply); \
    break; \
  default: \
    voidaction; \
    break; \
  }

  statfsres (nfsstat _tag = (nfsstat) 0) : status (_tag)
    { _base.init (); set_status (_tag); }
  statfsres (const statfsres &_s)
    : status (_s.status)
    { _base.init (_s._base); }
  ~statfsres () { _base.destroy (); }
  statfsres &operator= (const statfsres &_s) {
    const_cast<nfsstat &> (status) = _s.status;
    _base.assign (_s._base);
    return *this;
  }

  void set_status (nfsstat _tag) {
    const_cast<nfsstat &> (status) = _tag;
    rpcunion_switch_statfsres
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, statfsres &obj)
{
  nfsstat tag = obj.status;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.status)
    obj.set_status (tag);

  rpcunion_switch_statfsres
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, statfsres &obj)
{
  rpcunion_switch_statfsres
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *statfsres_alloc ();
bool_t xdr_statfsres (XDR *, void *);
RPC_UNION_DECL (statfsres)


#ifndef NFS_PROGRAM
#define NFS_PROGRAM 100003
#endif /* !NFS_PROGRAM */
extern const rpc_program nfs_program_2;
enum { NFS_VERSION = 2 };
enum {
  NFSPROC_NULL = 0,
  NFSPROC_GETATTR = 1,
  NFSPROC_SETATTR = 2,
  NFSPROC_ROOT = 3,
  NFSPROC_LOOKUP = 4,
  NFSPROC_READLINK = 5,
  NFSPROC_READ = 6,
  NFSPROC_WRITECACHE = 7,
  NFSPROC_WRITE = 8,
  NFSPROC_CREATE = 9,
  NFSPROC_REMOVE = 10,
  NFSPROC_RENAME = 11,
  NFSPROC_LINK = 12,
  NFSPROC_SYMLINK = 13,
  NFSPROC_MKDIR = 14,
  NFSPROC_RMDIR = 15,
  NFSPROC_READDIR = 16,
  NFSPROC_STATFS = 17,
};
#define NFS_PROGRAM_2_APPLY_NOVOID(macro, void) \
  macro (NFSPROC_NULL, void, void) \
  macro (NFSPROC_GETATTR, nfs_fh, attrstat) \
  macro (NFSPROC_SETATTR, sattrargs, attrstat) \
  macro (NFSPROC_ROOT, void, void) \
  macro (NFSPROC_LOOKUP, diropargs, diropres) \
  macro (NFSPROC_READLINK, nfs_fh, readlinkres) \
  macro (NFSPROC_READ, readargs, readres) \
  macro (NFSPROC_WRITECACHE, void, void) \
  macro (NFSPROC_WRITE, writeargs, attrstat) \
  macro (NFSPROC_CREATE, createargs, diropres) \
  macro (NFSPROC_REMOVE, diropargs, nfsstat) \
  macro (NFSPROC_RENAME, renameargs, nfsstat) \
  macro (NFSPROC_LINK, linkargs, nfsstat) \
  macro (NFSPROC_SYMLINK, symlinkargs, nfsstat) \
  macro (NFSPROC_MKDIR, createargs, diropres) \
  macro (NFSPROC_RMDIR, diropargs, nfsstat) \
  macro (NFSPROC_READDIR, readdirargs, readdirres) \
  macro (NFSPROC_STATFS, nfs_fh, statfsres)
#define NFS_PROGRAM_2_APPLY(macro) \
  NFS_PROGRAM_2_APPLY_NOVOID(macro, void)

#endif /* !__RPCC_NFS_PROT_H_INCLUDED__ */
