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

#ifndef __RPCC_SFSAGENT_H_INCLUDED__
#define __RPCC_SFSAGENT_H_INCLUDED__ 1

#include "xdrmisc.h"
#include "sfs_prot.h"

typedef rpc_str<255> sfs_filename;
void *sfs_filename_alloc ();
bool_t xdr_sfs_filename (XDR *, void *);
RPC_TYPEDEF_DECL (sfs_filename)


struct sfsagent_authinit_arg {
  int32_t ntries;
  rpc_str<RPC_INFINITY> requestor;
  sfs_authinfo authinfo;
  sfs_seqno seqno;
};
void *sfsagent_authinit_arg_alloc ();
bool_t xdr_sfsagent_authinit_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_authinit_arg)

template<class T> bool
rpc_traverse (T &t, sfsagent_authinit_arg &obj)
{
  return rpc_traverse (t, obj.ntries)
    && rpc_traverse (t, obj.requestor)
    && rpc_traverse (t, obj.authinfo)
    && rpc_traverse (t, obj.seqno);
}



struct sfsagent_auth_idtag {
  sfs_authinfo authinfo;
  sfs_seqno seqno;
};
void *sfsagent_auth_idtag_alloc ();
bool_t xdr_sfsagent_auth_idtag (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_auth_idtag)

template<class T> bool
rpc_traverse (T &t, sfsagent_auth_idtag &obj)
{
  return rpc_traverse (t, obj.authinfo)
    && rpc_traverse (t, obj.seqno);
}



struct sfsagent_authmore_arg {
  sfs_authinfo authinfo;
  sfs_seqno seqno;
  rpc_bytes<RPC_INFINITY> challenge;
};
void *sfsagent_authmore_arg_alloc ();
bool_t xdr_sfsagent_authmore_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_authmore_arg)

template<class T> bool
rpc_traverse (T &t, sfsagent_authmore_arg &obj)
{
  return rpc_traverse (t, obj.authinfo)
    && rpc_traverse (t, obj.seqno)
    && rpc_traverse (t, obj.challenge);
}



struct sfsagent_auth_res {
  const bool authenticate;
  union {
    union_entry_base _base;
    union_entry<rpc_bytes<RPC_INFINITY> > certificate;
  };

#define rpcunion_tag_sfsagent_auth_res authenticate
#define rpcunion_switch_sfsagent_auth_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case true: \
    action (opaque, certificate); \
    break; \
  case false: \
    voidaction; \
    break; \
  default: \
    defaction; \
    break; \
  }

  sfsagent_auth_res (bool _tag = (bool) 0) : authenticate (_tag)
    { _base.init (); set_authenticate (_tag); }
  sfsagent_auth_res (const sfsagent_auth_res &_s)
    : authenticate (_s.authenticate)
    { _base.init (_s._base); }
  ~sfsagent_auth_res () { _base.destroy (); }
  sfsagent_auth_res &operator= (const sfsagent_auth_res &_s) {
    const_cast<bool &> (authenticate) = _s.authenticate;
    _base.assign (_s._base);
    return *this;
  }

  void set_authenticate (bool _tag) {
    const_cast<bool &> (authenticate) = _tag;
    rpcunion_switch_sfsagent_auth_res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, sfsagent_auth_res &obj)
{
  bool tag = obj.authenticate;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.authenticate)
    obj.set_authenticate (tag);

  rpcunion_switch_sfsagent_auth_res
    (obj.authenticate, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsagent_auth_res &obj)
{
  rpcunion_switch_sfsagent_auth_res
    (obj.authenticate, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsagent_auth_res_alloc ();
bool_t xdr_sfsagent_auth_res (XDR *, void *);
RPC_UNION_DECL (sfsagent_auth_res)


typedef rpc_str<1024> sfsagent_path;
void *sfsagent_path_alloc ();
bool_t xdr_sfsagent_path (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_path)

enum sfsagent_lookup_type {
  LOOKUP_NOOP = 0,
  LOOKUP_MAKELINK = 1,
  LOOKUP_MAKEDIR = 2,
};
void *sfsagent_lookup_type_alloc ();
bool_t xdr_sfsagent_lookup_type (XDR *, void *);
RPC_ENUM_DECL (sfsagent_lookup_type)

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


struct sfsagent_lookup_res {
  const sfsagent_lookup_type type;
  union {
    union_entry_base _base;
    union_entry<sfsagent_path> path;
    union_entry<sfsagent_path> dir;
  };

#define rpcunion_tag_sfsagent_lookup_res type
#define rpcunion_switch_sfsagent_lookup_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case LOOKUP_NOOP: \
    voidaction; \
    break; \
  case LOOKUP_MAKELINK: \
    action (sfsagent_path, path); \
    break; \
  case LOOKUP_MAKEDIR: \
    action (sfsagent_path, dir); \
    break; \
  default: \
    defaction; \
    break; \
  }

  sfsagent_lookup_res (sfsagent_lookup_type _tag = (sfsagent_lookup_type) 0) : type (_tag)
    { _base.init (); set_type (_tag); }
  sfsagent_lookup_res (const sfsagent_lookup_res &_s)
    : type (_s.type)
    { _base.init (_s._base); }
  ~sfsagent_lookup_res () { _base.destroy (); }
  sfsagent_lookup_res &operator= (const sfsagent_lookup_res &_s) {
    const_cast<sfsagent_lookup_type &> (type) = _s.type;
    _base.assign (_s._base);
    return *this;
  }

  void set_type (sfsagent_lookup_type _tag) {
    const_cast<sfsagent_lookup_type &> (type) = _tag;
    rpcunion_switch_sfsagent_lookup_res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, sfsagent_lookup_res &obj)
{
  sfsagent_lookup_type tag = obj.type;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.type)
    obj.set_type (tag);

  rpcunion_switch_sfsagent_lookup_res
    (obj.type, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsagent_lookup_res &obj)
{
  rpcunion_switch_sfsagent_lookup_res
    (obj.type, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsagent_lookup_res_alloc ();
bool_t xdr_sfsagent_lookup_res (XDR *, void *);
RPC_UNION_DECL (sfsagent_lookup_res)


enum sfs_revocation_type {
  REVOCATION_NONE = 0,
  REVOCATION_BLOCK = 1,
  REVOCATION_CERT = 2,
};
void *sfs_revocation_type_alloc ();
bool_t xdr_sfs_revocation_type (XDR *, void *);
RPC_ENUM_DECL (sfs_revocation_type)

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


struct sfsagent_revoked_res {
  const sfs_revocation_type type;
  union {
    union_entry_base _base;
    union_entry<sfs_pathrevoke> cert;
  };

#define rpcunion_tag_sfsagent_revoked_res type
#define rpcunion_switch_sfsagent_revoked_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case REVOCATION_NONE: \
    voidaction; \
    break; \
  case REVOCATION_BLOCK: \
    voidaction; \
    break; \
  case REVOCATION_CERT: \
    action (sfs_pathrevoke, cert); \
    break; \
  default: \
    defaction; \
    break; \
  }

  sfsagent_revoked_res (sfs_revocation_type _tag = (sfs_revocation_type) 0) : type (_tag)
    { _base.init (); set_type (_tag); }
  sfsagent_revoked_res (const sfsagent_revoked_res &_s)
    : type (_s.type)
    { _base.init (_s._base); }
  ~sfsagent_revoked_res () { _base.destroy (); }
  sfsagent_revoked_res &operator= (const sfsagent_revoked_res &_s) {
    const_cast<sfs_revocation_type &> (type) = _s.type;
    _base.assign (_s._base);
    return *this;
  }

  void set_type (sfs_revocation_type _tag) {
    const_cast<sfs_revocation_type &> (type) = _tag;
    rpcunion_switch_sfsagent_revoked_res
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, sfsagent_revoked_res &obj)
{
  sfs_revocation_type tag = obj.type;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.type)
    obj.set_type (tag);

  rpcunion_switch_sfsagent_revoked_res
    (obj.type, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsagent_revoked_res &obj)
{
  rpcunion_switch_sfsagent_revoked_res
    (obj.type, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsagent_revoked_res_alloc ();
bool_t xdr_sfsagent_revoked_res (XDR *, void *);
RPC_UNION_DECL (sfsagent_revoked_res)



struct sfsagent_symlink_arg {
  sfs_filename name;
  sfsagent_path contents;
};
void *sfsagent_symlink_arg_alloc ();
bool_t xdr_sfsagent_symlink_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_symlink_arg)

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


typedef rpc_opaque<48> sfsagent_seed;
void *sfsagent_seed_alloc ();
bool_t xdr_sfsagent_seed (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_seed)

enum { sfs_badgid = -1 };


struct sfs_privkey2_clear {
  const sfs_keytype type;
  union {
    union_entry_base _base;
    union_entry<sfs_rabin_priv_xdr> rabin;
    union_entry<sfs_1schnorr_priv_xdr> schnorr1;
    union_entry<sfs_2schnorr_priv_xdr> schnorr2;
  };

#define rpcunion_tag_sfs_privkey2_clear type
#define rpcunion_switch_sfs_privkey2_clear(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case SFS_RABIN: \
    action (sfs_rabin_priv_xdr, rabin); \
    break; \
  case SFS_1SCHNORR: \
    action (sfs_1schnorr_priv_xdr, schnorr1); \
    break; \
  case SFS_2SCHNORR: \
    action (sfs_2schnorr_priv_xdr, schnorr2); \
    break; \
  default: \
    defaction; \
    break; \
  }

  sfs_privkey2_clear (sfs_keytype _tag = (sfs_keytype) 0) : type (_tag)
    { _base.init (); set_type (_tag); }
  sfs_privkey2_clear (const sfs_privkey2_clear &_s)
    : type (_s.type)
    { _base.init (_s._base); }
  ~sfs_privkey2_clear () { _base.destroy (); }
  sfs_privkey2_clear &operator= (const sfs_privkey2_clear &_s) {
    const_cast<sfs_keytype &> (type) = _s.type;
    _base.assign (_s._base);
    return *this;
  }

  void set_type (sfs_keytype _tag) {
    const_cast<sfs_keytype &> (type) = _tag;
    rpcunion_switch_sfs_privkey2_clear
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, sfs_privkey2_clear &obj)
{
  sfs_keytype tag = obj.type;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.type)
    obj.set_type (tag);

  rpcunion_switch_sfs_privkey2_clear
    (obj.type, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfs_privkey2_clear &obj)
{
  rpcunion_switch_sfs_privkey2_clear
    (obj.type, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfs_privkey2_clear_alloc ();
bool_t xdr_sfs_privkey2_clear (XDR *, void *);
RPC_UNION_DECL (sfs_privkey2_clear)


typedef rpc_str<1023> sfsagent_comment;
void *sfsagent_comment_alloc ();
bool_t xdr_sfsagent_comment (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_comment)


struct sfs_addkey_arg {
  sfs_privkey2_clear privkey;
  int32_t key_version;
  sfs_time expire;
  sfsagent_comment name;
};
void *sfs_addkey_arg_alloc ();
bool_t xdr_sfs_addkey_arg (XDR *, void *);
RPC_STRUCT_DECL (sfs_addkey_arg)

template<class T> bool
rpc_traverse (T &t, sfs_addkey_arg &obj)
{
  return rpc_traverse (t, obj.privkey)
    && rpc_traverse (t, obj.key_version)
    && rpc_traverse (t, obj.expire)
    && rpc_traverse (t, obj.name);
}



struct sfsagent_addextauth_arg {
  sfs_time expire;
  int32_t pid;
  sfsagent_comment name;
};
void *sfsagent_addextauth_arg_alloc ();
bool_t xdr_sfsagent_addextauth_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_addextauth_arg)

template<class T> bool
rpc_traverse (T &t, sfsagent_addextauth_arg &obj)
{
  return rpc_traverse (t, obj.expire)
    && rpc_traverse (t, obj.pid)
    && rpc_traverse (t, obj.name);
}



struct sfsextauth_init {
  sfsagent_comment name;
  sfsagent_authinit_arg autharg;
};
void *sfsextauth_init_alloc ();
bool_t xdr_sfsextauth_init (XDR *, void *);
RPC_STRUCT_DECL (sfsextauth_init)

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



struct sfsextauth_more {
  sfsagent_comment name;
  sfsagent_authmore_arg autharg;
};
void *sfsextauth_more_alloc ();
bool_t xdr_sfsextauth_more (XDR *, void *);
RPC_STRUCT_DECL (sfsextauth_more)

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


enum sfs_remauth_type {
  SFS_REM_PUBKEY = 0,
  SFS_REM_NAME = 1,
  SFS_REM_PID = 2,
};
void *sfs_remauth_type_alloc ();
bool_t xdr_sfs_remauth_type (XDR *, void *);
RPC_ENUM_DECL (sfs_remauth_type)

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


struct sfs_remauth_arg {
  const sfs_remauth_type type;
  union {
    union_entry_base _base;
    union_entry<sfs_pubkey2> pubkey;
    union_entry<sfsagent_comment> name;
    union_entry<int32_t> pid;
  };

#define rpcunion_tag_sfs_remauth_arg type
#define rpcunion_switch_sfs_remauth_arg(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case SFS_REM_PUBKEY: \
    action (sfs_pubkey2, pubkey); \
    break; \
  case SFS_REM_NAME: \
    action (sfsagent_comment, name); \
    break; \
  case SFS_REM_PID: \
    action (int32_t, pid); \
    break; \
  default: \
    defaction; \
    break; \
  }

  sfs_remauth_arg (sfs_remauth_type _tag = (sfs_remauth_type) 0) : type (_tag)
    { _base.init (); set_type (_tag); }
  sfs_remauth_arg (const sfs_remauth_arg &_s)
    : type (_s.type)
    { _base.init (_s._base); }
  ~sfs_remauth_arg () { _base.destroy (); }
  sfs_remauth_arg &operator= (const sfs_remauth_arg &_s) {
    const_cast<sfs_remauth_type &> (type) = _s.type;
    _base.assign (_s._base);
    return *this;
  }

  void set_type (sfs_remauth_type _tag) {
    const_cast<sfs_remauth_type &> (type) = _tag;
    rpcunion_switch_sfs_remauth_arg
      (_tag, RPCUNION_SET, _base.destroy (), _base.destroy ());
  }
};

template<class T> bool
rpc_traverse (T &t, sfs_remauth_arg &obj)
{
  sfs_remauth_type tag = obj.type;
  if (!rpc_traverse (t, tag))
    return false;
  if (tag != obj.type)
    obj.set_type (tag);

  rpcunion_switch_sfs_remauth_arg
    (obj.type, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfs_remauth_arg &obj)
{
  rpcunion_switch_sfs_remauth_arg
    (obj.type, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfs_remauth_arg_alloc ();
bool_t xdr_sfs_remauth_arg (XDR *, void *);
RPC_UNION_DECL (sfs_remauth_arg)



struct sfs_keylistelm {
  rpc_str<RPC_INFINITY> desc;
  sfs_time expire;
  sfsagent_comment name;
  rpc_ptr<sfs_keylistelm> next;
};
void *sfs_keylistelm_alloc ();
bool_t xdr_sfs_keylistelm (XDR *, void *);
RPC_STRUCT_DECL (sfs_keylistelm)

template<class T> bool
rpc_traverse (T &t, sfs_keylistelm &obj)
{
  return rpc_traverse (t, obj.desc)
    && rpc_traverse (t, obj.expire)
    && rpc_traverse (t, obj.name)
    && rpc_traverse (t, obj.next);
}


typedef rpc_ptr<sfs_keylistelm> sfs_keylist;
void *sfs_keylist_alloc ();
bool_t xdr_sfs_keylist (XDR *, void *);
RPC_TYPEDEF_DECL (sfs_keylist)

typedef rpc_str<RPC_INFINITY> sfsagent_progarg;
void *sfsagent_progarg_alloc ();
bool_t xdr_sfsagent_progarg (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_progarg)

typedef rpc_vec<sfsagent_progarg, RPC_INFINITY> sfsagent_cmd;
void *sfsagent_cmd_alloc ();
bool_t xdr_sfsagent_cmd (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_cmd)


struct sfsagent_certprog {
  rpc_str<RPC_INFINITY> prefix;
  rpc_str<RPC_INFINITY> filter;
  rpc_str<RPC_INFINITY> exclude;
  sfsagent_cmd av;
};
void *sfsagent_certprog_alloc ();
bool_t xdr_sfsagent_certprog (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_certprog)

template<class T> bool
rpc_traverse (T &t, sfsagent_certprog &obj)
{
  return rpc_traverse (t, obj.prefix)
    && rpc_traverse (t, obj.filter)
    && rpc_traverse (t, obj.exclude)
    && rpc_traverse (t, obj.av);
}


typedef rpc_vec<sfsagent_certprog, RPC_INFINITY> sfsagent_certprogs;
void *sfsagent_certprogs_alloc ();
bool_t xdr_sfsagent_certprogs (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_certprogs)


struct sfsagent_blockfilter {
  rpc_str<RPC_INFINITY> filter;
  rpc_str<RPC_INFINITY> exclude;
};
void *sfsagent_blockfilter_alloc ();
bool_t xdr_sfsagent_blockfilter (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_blockfilter)

template<class T> bool
rpc_traverse (T &t, sfsagent_blockfilter &obj)
{
  return rpc_traverse (t, obj.filter)
    && rpc_traverse (t, obj.exclude);
}



struct sfsagent_revokeprog {
  rpc_ptr<sfsagent_blockfilter> block;
  sfsagent_cmd av;
};
void *sfsagent_revokeprog_alloc ();
bool_t xdr_sfsagent_revokeprog (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_revokeprog)

template<class T> bool
rpc_traverse (T &t, sfsagent_revokeprog &obj)
{
  return rpc_traverse (t, obj.block)
    && rpc_traverse (t, obj.av);
}


typedef rpc_vec<sfsagent_revokeprog, RPC_INFINITY> sfsagent_revokeprogs;
void *sfsagent_revokeprogs_alloc ();
bool_t xdr_sfsagent_revokeprogs (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_revokeprogs)

typedef rpc_vec<sfs_hash, RPC_INFINITY> sfsagent_norevoke_list;
void *sfsagent_norevoke_list_alloc ();
bool_t xdr_sfsagent_norevoke_list (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_norevoke_list)

typedef rpc_str<RPC_INFINITY> sfsagent_srpname;
void *sfsagent_srpname_alloc ();
bool_t xdr_sfsagent_srpname (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_srpname)


struct sfsagent_srpname_pair {
  sfsagent_srpname srpname;
  sfs_hostname sfsname;
};
void *sfsagent_srpname_pair_alloc ();
bool_t xdr_sfsagent_srpname_pair (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_srpname_pair)

template<class T> bool
rpc_traverse (T &t, sfsagent_srpname_pair &obj)
{
  return rpc_traverse (t, obj.srpname)
    && rpc_traverse (t, obj.sfsname);
}


typedef rpc_vec<sfsagent_srpname_pair, RPC_INFINITY> sfsagent_srpname_pairs;
void *sfsagent_srpname_pairs_alloc ();
bool_t xdr_sfsagent_srpname_pairs (XDR *, void *);
RPC_TYPEDEF_DECL (sfsagent_srpname_pairs)


struct sfsagent_srpname_res {
  const bool status;
  union {
    union_entry_base _base;
    union_entry<sfs_hostname> sfsname;
  };

#define rpcunion_tag_sfsagent_srpname_res status
#define rpcunion_switch_sfsagent_srpname_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case true: \
    action (sfs_hostname, sfsname); \
    break; \
  case false: \
    voidaction; \
    break; \
  default: \
    defaction; \
    break; \
  }

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

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

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

  rpcunion_switch_sfsagent_srpname_res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsagent_srpname_res &obj)
{
  rpcunion_switch_sfsagent_srpname_res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsagent_srpname_res_alloc ();
bool_t xdr_sfsagent_srpname_res (XDR *, void *);
RPC_UNION_DECL (sfsagent_srpname_res)



struct sfsagent_rex_arg {
  sfs_hostname dest;
  bool forwardagent;
};
void *sfsagent_rex_arg_alloc ();
bool_t xdr_sfsagent_rex_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_rex_arg)

template<class T> bool
rpc_traverse (T &t, sfsagent_rex_arg &obj)
{
  return rpc_traverse (t, obj.dest)
    && rpc_traverse (t, obj.forwardagent);
}



struct sfsagent_rex_resok {
  sfs_kmsg kcs;
  sfs_kmsg ksc;
  sfs_seqno seqno;
};
void *sfsagent_rex_resok_alloc ();
bool_t xdr_sfsagent_rex_resok (XDR *, void *);
RPC_STRUCT_DECL (sfsagent_rex_resok)

template<class T> bool
rpc_traverse (T &t, sfsagent_rex_resok &obj)
{
  return rpc_traverse (t, obj.kcs)
    && rpc_traverse (t, obj.ksc)
    && rpc_traverse (t, obj.seqno);
}



struct sfsagent_rex_res {
  const bool status;
  union {
    union_entry_base _base;
    union_entry<sfsagent_rex_resok> resok;
  };

#define rpcunion_tag_sfsagent_rex_res status
#define rpcunion_switch_sfsagent_rex_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case true: \
    action (sfsagent_rex_resok, resok); \
    break; \
  case false: \
    voidaction; \
    break; \
  default: \
    defaction; \
    break; \
  }

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

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

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

  rpcunion_switch_sfsagent_rex_res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsagent_rex_res &obj)
{
  rpcunion_switch_sfsagent_rex_res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsagent_rex_res_alloc ();
bool_t xdr_sfsagent_rex_res (XDR *, void *);
RPC_UNION_DECL (sfsagent_rex_res)



struct rex_sessentry {
  sfs_hostname to;
  sfs_hostname created_from;
  bool agentforwarded;
};
void *rex_sessentry_alloc ();
bool_t xdr_rex_sessentry (XDR *, void *);
RPC_STRUCT_DECL (rex_sessentry)

template<class T> bool
rpc_traverse (T &t, rex_sessentry &obj)
{
  return rpc_traverse (t, obj.to)
    && rpc_traverse (t, obj.created_from)
    && rpc_traverse (t, obj.agentforwarded);
}


typedef rpc_vec<rex_sessentry, RPC_INFINITY> rex_sessvec;
void *rex_sessvec_alloc ();
bool_t xdr_rex_sessvec (XDR *, void *);
RPC_TYPEDEF_DECL (rex_sessvec)


struct sfsctl_getfh_arg {
  filename3 filesys;
  u_int64_t fileid;
};
void *sfsctl_getfh_arg_alloc ();
bool_t xdr_sfsctl_getfh_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsctl_getfh_arg)

template<class T> bool
rpc_traverse (T &t, sfsctl_getfh_arg &obj)
{
  return rpc_traverse (t, obj.filesys)
    && rpc_traverse (t, obj.fileid);
}



struct sfsctl_getfh_res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<nfs_fh3> fh;
  };

#define rpcunion_tag_sfsctl_getfh_res status
#define rpcunion_switch_sfsctl_getfh_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (nfs_fh3, fh); \
    break; \
  default: \
    voidaction; \
    break; \
  }

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

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

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

  rpcunion_switch_sfsctl_getfh_res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsctl_getfh_res &obj)
{
  rpcunion_switch_sfsctl_getfh_res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsctl_getfh_res_alloc ();
bool_t xdr_sfsctl_getfh_res (XDR *, void *);
RPC_UNION_DECL (sfsctl_getfh_res)



struct sfsctl_getidnames_arg {
  filename3 filesys;
  sfs_idnums nums;
};
void *sfsctl_getidnames_arg_alloc ();
bool_t xdr_sfsctl_getidnames_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsctl_getidnames_arg)

template<class T> bool
rpc_traverse (T &t, sfsctl_getidnames_arg &obj)
{
  return rpc_traverse (t, obj.filesys)
    && rpc_traverse (t, obj.nums);
}



struct sfsctl_getidnames_res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<sfs_idnames> names;
  };

#define rpcunion_tag_sfsctl_getidnames_res status
#define rpcunion_switch_sfsctl_getidnames_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (sfs_idnames, names); \
    break; \
  default: \
    voidaction; \
    break; \
  }

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

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

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

  rpcunion_switch_sfsctl_getidnames_res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsctl_getidnames_res &obj)
{
  rpcunion_switch_sfsctl_getidnames_res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsctl_getidnames_res_alloc ();
bool_t xdr_sfsctl_getidnames_res (XDR *, void *);
RPC_UNION_DECL (sfsctl_getidnames_res)



struct sfsctl_getidnums_arg {
  filename3 filesys;
  sfs_idnames names;
};
void *sfsctl_getidnums_arg_alloc ();
bool_t xdr_sfsctl_getidnums_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsctl_getidnums_arg)

template<class T> bool
rpc_traverse (T &t, sfsctl_getidnums_arg &obj)
{
  return rpc_traverse (t, obj.filesys)
    && rpc_traverse (t, obj.names);
}



struct sfsctl_getidnums_res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<sfs_idnums> nums;
  };

#define rpcunion_tag_sfsctl_getidnums_res status
#define rpcunion_switch_sfsctl_getidnums_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (sfs_idnums, nums); \
    break; \
  default: \
    voidaction; \
    break; \
  }

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

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

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

  rpcunion_switch_sfsctl_getidnums_res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsctl_getidnums_res &obj)
{
  rpcunion_switch_sfsctl_getidnums_res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsctl_getidnums_res_alloc ();
bool_t xdr_sfsctl_getidnums_res (XDR *, void *);
RPC_UNION_DECL (sfsctl_getidnums_res)



struct sfsctl_getcred_res {
  const nfsstat3 status;
  union {
    union_entry_base _base;
    union_entry<sfsauth_cred> cred;
  };

#define rpcunion_tag_sfsctl_getcred_res status
#define rpcunion_switch_sfsctl_getcred_res(swarg, action, voidaction, defaction) \
  switch (swarg) { \
  case NFS3_OK: \
    action (sfsauth_cred, cred); \
    break; \
  default: \
    voidaction; \
    break; \
  }

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

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

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

  rpcunion_switch_sfsctl_getcred_res
    (obj.status, RPCUNION_TRAVERSE, return true, return false);
}
inline bool
rpc_traverse (const stompcast_t &s, sfsctl_getcred_res &obj)
{
  rpcunion_switch_sfsctl_getcred_res
    (obj.status, RPCUNION_REC_STOMPCAST,
     obj._base.destroy (); return true, obj._base.destroy (); return true;);
}
void *sfsctl_getcred_res_alloc ();
bool_t xdr_sfsctl_getcred_res (XDR *, void *);
RPC_UNION_DECL (sfsctl_getcred_res)



struct sfsctl_lookup_arg {
  filename3 filesys;
  diropargs3 arg;
};
void *sfsctl_lookup_arg_alloc ();
bool_t xdr_sfsctl_lookup_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsctl_lookup_arg)

template<class T> bool
rpc_traverse (T &t, sfsctl_lookup_arg &obj)
{
  return rpc_traverse (t, obj.filesys)
    && rpc_traverse (t, obj.arg);
}



struct sfsctl_getacl_arg {
  filename3 filesys;
  diropargs3 arg;
};
void *sfsctl_getacl_arg_alloc ();
bool_t xdr_sfsctl_getacl_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsctl_getacl_arg)

template<class T> bool
rpc_traverse (T &t, sfsctl_getacl_arg &obj)
{
  return rpc_traverse (t, obj.filesys)
    && rpc_traverse (t, obj.arg);
}



struct sfsctl_setacl_arg {
  filename3 filesys;
  setaclargs arg;
};
void *sfsctl_setacl_arg_alloc ();
bool_t xdr_sfsctl_setacl_arg (XDR *, void *);
RPC_STRUCT_DECL (sfsctl_setacl_arg)

template<class T> bool
rpc_traverse (T &t, sfsctl_setacl_arg &obj)
{
  return rpc_traverse (t, obj.filesys)
    && rpc_traverse (t, obj.arg);
}


#ifndef AGENTCTL_PROG
#define AGENTCTL_PROG 344428
#endif /* !AGENTCTL_PROG */
extern const rpc_program agentctl_prog_1;
enum { AGENTCTL_VERS = 1 };
enum {
  AGENTCTL_NULL = 0,
  AGENTCTL_ADDKEY = 1,
  AGENTCTL_REMAUTH = 2,
  AGENTCTL_REMALLKEYS = 3,
  AGENTCTL_DUMPKEYS = 4,
  AGENTCTL_CLRCERTPROGS = 5,
  AGENTCTL_ADDCERTPROG = 6,
  AGENTCTL_DUMPCERTPROGS = 7,
  AGENTCTL_CLRREVOKEPROGS = 8,
  AGENTCTL_ADDREVOKEPROG = 9,
  AGENTCTL_DUMPREVOKEPROGS = 10,
  AGENTCTL_SETNOREVOKE = 11,
  AGENTCTL_GETNOREVOKE = 12,
  AGENTCTL_SYMLINK = 13,
  AGENTCTL_RESET = 14,
  AGENTCTL_FORWARD = 15,
  AGENTCTL_RNDSEED = 16,
  AGENTCTL_REX = 17,
  AGENTCTL_LISTSESS = 18,
  AGENTCTL_KILLSESS = 19,
  AGENTCTL_CLRCERTPROG_BYREALM = 20,
  AGENTCTL_ADDEXTAUTH = 21,
  AGENTCTL_CLRSRPNAMES = 22,
  AGENTCTL_ADDSRPNAME = 23,
  AGENTCTL_DUMPSRPNAMES = 24,
  AGENTCTL_LOOKUPSRPNAME = 25,
};
#define AGENTCTL_PROG_1_APPLY_NOVOID(macro, void) \
  macro (AGENTCTL_NULL, void, void) \
  macro (AGENTCTL_ADDKEY, sfs_addkey_arg, bool) \
  macro (AGENTCTL_REMAUTH, sfs_remauth_arg, bool) \
  macro (AGENTCTL_REMALLKEYS, void, void) \
  macro (AGENTCTL_DUMPKEYS, void, sfs_keylist) \
  macro (AGENTCTL_CLRCERTPROGS, void, void) \
  macro (AGENTCTL_ADDCERTPROG, sfsagent_certprog, bool) \
  macro (AGENTCTL_DUMPCERTPROGS, void, sfsagent_certprogs) \
  macro (AGENTCTL_CLRREVOKEPROGS, void, void) \
  macro (AGENTCTL_ADDREVOKEPROG, sfsagent_revokeprog, bool) \
  macro (AGENTCTL_DUMPREVOKEPROGS, void, sfsagent_revokeprogs) \
  macro (AGENTCTL_SETNOREVOKE, sfsagent_norevoke_list, void) \
  macro (AGENTCTL_GETNOREVOKE, void, sfsagent_norevoke_list) \
  macro (AGENTCTL_SYMLINK, sfsagent_symlink_arg, void) \
  macro (AGENTCTL_RESET, void, void) \
  macro (AGENTCTL_FORWARD, sfs_hostname, int32_t) \
  macro (AGENTCTL_RNDSEED, sfsagent_seed, void) \
  macro (AGENTCTL_REX, sfsagent_rex_arg, sfsagent_rex_res) \
  macro (AGENTCTL_LISTSESS, void, rex_sessvec) \
  macro (AGENTCTL_KILLSESS, sfs_hostname, bool) \
  macro (AGENTCTL_CLRCERTPROG_BYREALM, sfsauth_realm, bool) \
  macro (AGENTCTL_ADDEXTAUTH, sfsagent_addextauth_arg, bool) \
  macro (AGENTCTL_CLRSRPNAMES, void, void) \
  macro (AGENTCTL_ADDSRPNAME, sfsagent_srpname_pair, bool) \
  macro (AGENTCTL_DUMPSRPNAMES, void, sfsagent_srpname_pairs) \
  macro (AGENTCTL_LOOKUPSRPNAME, sfsagent_srpname, sfsagent_srpname_res)
#define AGENTCTL_PROG_1_APPLY(macro) \
  AGENTCTL_PROG_1_APPLY_NOVOID(macro, void)


#ifndef SFSEXTAUTH_PROG
#define SFSEXTAUTH_PROG 344429
#endif /* !SFSEXTAUTH_PROG */
extern const rpc_program sfsextauth_prog_1;
enum { SFSEXTAUTH_VERS = 1 };
enum {
  SFSEXTAUTH_NULL = 0,
  SFSEXTAUTH_AUTHINIT = 1,
  SFSEXTAUTH_AUTHMORE = 2,
};
#define SFSEXTAUTH_PROG_1_APPLY_NOVOID(macro, void) \
  macro (SFSEXTAUTH_NULL, void, void) \
  macro (SFSEXTAUTH_AUTHINIT, sfsextauth_init, sfsagent_auth_res) \
  macro (SFSEXTAUTH_AUTHMORE, sfsextauth_more, sfsagent_auth_res)
#define SFSEXTAUTH_PROG_1_APPLY(macro) \
  SFSEXTAUTH_PROG_1_APPLY_NOVOID(macro, void)


#ifndef SETUID_PROG
#define SETUID_PROG 344430
#endif /* !SETUID_PROG */
extern const rpc_program setuid_prog_1;
enum { SETUID_VERS = 1 };
enum {
  SETUIDPROC_SETUID = 0,
};
#define SETUID_PROG_1_APPLY_NOVOID(macro, void) \
  macro (SETUIDPROC_SETUID, void, int32_t)
#define SETUID_PROG_1_APPLY(macro) \
  SETUID_PROG_1_APPLY_NOVOID(macro, void)


#ifndef AGENT_PROG
#define AGENT_PROG 344432
#endif /* !AGENT_PROG */
extern const rpc_program agent_prog_1;
enum { AGENT_VERS = 1 };
enum {
  AGENT_NULL = 0,
  AGENT_START = 1,
  AGENT_KILL = 2,
  AGENT_KILLSTART = 3,
  AGENT_SYMLINK = 4,
  AGENT_FLUSHNAME = 5,
  AGENT_FLUSHNEG = 6,
  AGENT_REVOKE = 7,
  AGENT_RNDSEED = 8,
  AGENT_AIDALLOC = 9,
  AGENT_GETAGENT = 10,
};
#define AGENT_PROG_1_APPLY_NOVOID(macro, void) \
  macro (AGENT_NULL, void, void) \
  macro (AGENT_START, void, int32_t) \
  macro (AGENT_KILL, void, int32_t) \
  macro (AGENT_KILLSTART, void, int32_t) \
  macro (AGENT_SYMLINK, sfsagent_symlink_arg, void) \
  macro (AGENT_FLUSHNAME, sfs_filename, void) \
  macro (AGENT_FLUSHNEG, void, void) \
  macro (AGENT_REVOKE, sfs_pathrevoke, void) \
  macro (AGENT_RNDSEED, void, sfsagent_seed) \
  macro (AGENT_AIDALLOC, void, u_int32_t) \
  macro (AGENT_GETAGENT, void, int32_t)
#define AGENT_PROG_1_APPLY(macro) \
  AGENT_PROG_1_APPLY_NOVOID(macro, void)


#ifndef AGENTCB_PROG
#define AGENTCB_PROG 344433
#endif /* !AGENTCB_PROG */
extern const rpc_program agentcb_prog_1;
enum { AGENTCB_VERS = 1 };
enum {
  AGENTCB_NULL = 0,
  AGENTCB_AUTHINIT = 1,
  AGENTCB_AUTHMORE = 2,
  AGENTCB_LOOKUP = 3,
  AGENTCB_REVOKED = 4,
  AGENTCB_CLONE = 5,
};
#define AGENTCB_PROG_1_APPLY_NOVOID(macro, void) \
  macro (AGENTCB_NULL, void, void) \
  macro (AGENTCB_AUTHINIT, sfsagent_authinit_arg, sfsagent_auth_res) \
  macro (AGENTCB_AUTHMORE, sfsagent_authmore_arg, sfsagent_auth_res) \
  macro (AGENTCB_LOOKUP, sfs_filename, sfsagent_lookup_res) \
  macro (AGENTCB_REVOKED, filename3, sfsagent_revoked_res) \
  macro (AGENTCB_CLONE, void, void)
#define AGENTCB_PROG_1_APPLY(macro) \
  AGENTCB_PROG_1_APPLY_NOVOID(macro, void)


#ifndef SFSCTL_PROG
#define SFSCTL_PROG 344434
#endif /* !SFSCTL_PROG */
extern const rpc_program sfsctl_prog_1;
enum { SFSCTL_VERS = 1 };
enum {
  SFSCTL_NULL = 0,
  SFSCTL_SETPID = 1,
  SFSCTL_GETFH = 2,
  SFSCTL_GETIDNAMES = 3,
  SFSCTL_GETIDNUMS = 4,
  SFSCTL_GETCRED = 5,
  SFSCTL_LOOKUP = 6,
  SFSCTL_GETACL = 7,
  SFSCTL_SETACL = 8,
};
#define SFSCTL_PROG_1_APPLY_NOVOID(macro, void) \
  macro (SFSCTL_NULL, void, void) \
  macro (SFSCTL_SETPID, int32_t, void) \
  macro (SFSCTL_GETFH, sfsctl_getfh_arg, sfsctl_getfh_res) \
  macro (SFSCTL_GETIDNAMES, sfsctl_getidnames_arg, sfsctl_getidnames_res) \
  macro (SFSCTL_GETIDNUMS, sfsctl_getidnums_arg, sfsctl_getidnums_res) \
  macro (SFSCTL_GETCRED, filename3, sfsctl_getcred_res) \
  macro (SFSCTL_LOOKUP, sfsctl_lookup_arg, lookup3res) \
  macro (SFSCTL_GETACL, sfsctl_getacl_arg, read3res) \
  macro (SFSCTL_SETACL, sfsctl_setacl_arg, write3res)
#define SFSCTL_PROG_1_APPLY(macro) \
  SFSCTL_PROG_1_APPLY_NOVOID(macro, void)

#endif /* !__RPCC_SFSAGENT_H_INCLUDED__ */
