diff --git a/server/plugin/plg_backend_nfs4/index.go b/server/plugin/plg_backend_nfs4/index.go new file mode 100644 index 00000000..a099fda5 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/index.go @@ -0,0 +1,164 @@ +package plg_backend_nfs4 + +import ( + "context" + "io" + "os" + "strconv" + "strings" + + . "github.com/mickael-kerjean/filestash/server/common" + "github.com/mickael-kerjean/filestash/server/plugin/plg_backend_nfs4/repo/nfs4" +) + +const DEFAULT_PORT = ":2049" + +type Nfs4Share struct { + client *nfs4.NfsClient + ctx context.Context +} + +func init() { + Backend.Register("nfs4", Nfs4Share{}) +} + +func (this Nfs4Share) Init(params map[string]string, app *App) (IBackend, error) { + if params["hostname"] == "" { + return nil, ErrNotFound + } + var ( + uid uint32 = 1000 + gid uint32 = 1000 + ) + if params["uid"] != "" { + if _uid, err := strconv.Atoi(params["uid"]); err == nil { + uid = uint32(_uid) + } + } + if params["gid"] != "" { + if _gid, err := strconv.Atoi(params["gid"]); err == nil { + gid = uint32(_gid) + } + } + if params["machine_name"] == "" { + params["machine_name"] = "filestash" + } + if strings.Contains(params["hostname"], ":") == false { + params["hostname"] = params["hostname"] + DEFAULT_PORT + } + client, err := nfs4.NewNfsClient(app.Context, params["hostname"], nfs4.AuthParams{ + MachineName: params["machine_name"], + Uid: uid, + Gid: gid, + }) + if err != nil { + return nil, err + } + return Nfs4Share{ + client, + app.Context, + }, nil +} + +func (this Nfs4Share) LoginForm() Form { + return Form{ + Elmnts: []FormElement{ + FormElement{ + Name: "type", + Type: "hidden", + Value: "nfs4", + }, + FormElement{ + Name: "hostname", + Type: "text", + Placeholder: "Hostname", + }, + FormElement{ + Name: "advanced", + Type: "enable", + Placeholder: "Advanced", + Target: []string{"nfs_uid", "nfs_gid", "nfs_machinename"}, + }, + FormElement{ + Id: "nfs_uid", + Name: "uid", + Type: "number", + Placeholder: "uid", + }, + FormElement{ + Id: "nfs_gid", + Name: "gid", + Type: "number", + Placeholder: "gid", + }, + FormElement{ + Id: "nfs_machinename", + Name: "machine_name", + Type: "text", + Placeholder: "machine name", + }, + }, + } +} + +func (this Nfs4Share) Ls(path string) ([]os.FileInfo, error) { + list, err := this.client.GetFileList(path) + if err != nil { + return nil, err + } + files := make([]os.FileInfo, 0) + for _, info := range list { + files = append(files, File{ + FName: info.Name, + FType: func() string { + if info.IsDir { + return "directory" + } + return "file" + }(), + FSize: int64(info.Size), + FTime: int64(info.Mtime.Nanosecond()), + }) + } + return files, nil +} + +func (this Nfs4Share) Cat(path string) (io.ReadCloser, error) { + _, err := this.client.GetFileInfo(path) + if err != nil { + return nil, err + } + pr, pw := io.Pipe() + go this.client.ReadFileAll(path, pw) + return pr, nil +} + +func (this Nfs4Share) Mkdir(path string) error { + return this.client.MakePath(path) +} + +func (this Nfs4Share) Rm(path string) error { + if strings.HasSuffix(path, "/") { + return ErrNotImplemented + } + return nfs4.RemoveRecursive(this.client, path) +} + +func (this Nfs4Share) Mv(from string, to string) error { + return ErrNotImplemented +} + +func (this Nfs4Share) Touch(path string) error { + _, err := this.client.WriteFile(path, false, 0, strings.NewReader("")) + return err +} + +func (this Nfs4Share) Save(path string, file io.Reader) error { + _, err := this.client.ReWriteFile(path, file) + return err +} + +func (this Nfs4Share) Close() { + this.client.Close() + return +} diff --git a/server/plugin/plg_backend_nfs4/repo/README.md b/server/plugin/plg_backend_nfs4/repo/README.md new file mode 100644 index 00000000..412332d2 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/README.md @@ -0,0 +1 @@ +TODO: we can't go get github.com/kha7iq/go-nfs-client => fork over and fix it instead diff --git a/server/plugin/plg_backend_nfs4/repo/internal/cleanuper.go b/server/plugin/plg_backend_nfs4/repo/internal/cleanuper.go new file mode 100644 index 00000000..d47b69d0 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/cleanuper.go @@ -0,0 +1,30 @@ +package internal + +type cleanuper struct { + cleanupErr func() error + cleanup func() +} + +func NewCleanupErr(cl func() error) *cleanuper { + return &cleanuper{cleanupErr: cl} +} + +func NewCleanup(cl func()) *cleanuper { + return &cleanuper{cleanup: cl} +} + +func (c *cleanuper) Disarm() { + c.cleanupErr = nil + c.cleanup = nil +} + +func (c *cleanuper) Cleanup() { + if c.cleanupErr != nil { + _ = c.cleanupErr() + } + + if c.cleanup != nil { + c.cleanup() + } +} + diff --git a/server/plugin/plg_backend_nfs4/repo/internal/nfs4.go b/server/plugin/plg_backend_nfs4/repo/internal/nfs4.go new file mode 100644 index 00000000..98d0f1fa --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/nfs4.go @@ -0,0 +1,14486 @@ +// Code generated by goxdr -B -p nfs4 nfs4/nfs4.x; DO NOT EDIT. + +package internal +import( + "bytes" + "context" + "encoding/binary" + "fmt" + "io" + "math" + "strings" +) + +var _ = fmt.Sprintf +var _ context.Context + +// +// Data types defined in XDR file +// + +/* + * Sizes + */ +const NFS4_FHSIZE = 128 + +const NFS4_VERIFIER_SIZE = 8 + +const NFS4_OPAQUE_LIMIT = 1024 + +const NFS4_SESSIONID_SIZE = 16 + +/* + * File types + */ +type Nfs_ftype4 int32 +const ( + /* Regular File */ + NF4REG Nfs_ftype4 = 1 + /* Directory */ + NF4DIR Nfs_ftype4 = 2 + /* Special File - block device */ + NF4BLK Nfs_ftype4 = 3 + /* Special File - character device */ + NF4CHR Nfs_ftype4 = 4 + /* Symbolic Link */ + NF4LNK Nfs_ftype4 = 5 + /* Special File - socket */ + NF4SOCK Nfs_ftype4 = 6 + /* Special File - fifo */ + NF4FIFO Nfs_ftype4 = 7 + /* Attribute Directory */ + NF4ATTRDIR Nfs_ftype4 = 8 + /* Named Attribute */ + NF4NAMEDATTR Nfs_ftype4 = 9 +) + +/* + * Error status + */ +type Nfsstat4 int32 +const ( + /* everything is okay */ + NFS4_OK Nfsstat4 = 0 + /* caller not privileged */ + NFS4ERR_PERM Nfsstat4 = 1 + /* no such file/directory */ + NFS4ERR_NOENT Nfsstat4 = 2 + /* hard I/O error */ + NFS4ERR_IO Nfsstat4 = 5 + /* no such device */ + NFS4ERR_NXIO Nfsstat4 = 6 + /* access denied */ + NFS4ERR_ACCESS Nfsstat4 = 13 + /* file already exists */ + NFS4ERR_EXIST Nfsstat4 = 17 + /* different filesystems */ + NFS4ERR_XDEV Nfsstat4 = 18 + /* should be a directory */ + NFS4ERR_NOTDIR Nfsstat4 = 20 + /* should not be directory */ + NFS4ERR_ISDIR Nfsstat4 = 21 + /* invalid argument */ + NFS4ERR_INVAL Nfsstat4 = 22 + /* file exceeds server max */ + NFS4ERR_FBIG Nfsstat4 = 27 + /* no space on filesystem */ + NFS4ERR_NOSPC Nfsstat4 = 28 + /* read-only filesystem */ + NFS4ERR_ROFS Nfsstat4 = 30 + /* too many hard links */ + NFS4ERR_MLINK Nfsstat4 = 31 + /* name exceeds server max */ + NFS4ERR_NAMETOOLONG Nfsstat4 = 63 + /* directory not empty */ + NFS4ERR_NOTEMPTY Nfsstat4 = 66 + /* hard quota limit reached*/ + NFS4ERR_DQUOT Nfsstat4 = 69 + /* file no longer exists */ + NFS4ERR_STALE Nfsstat4 = 70 + /* Illegal filehandle */ + NFS4ERR_BADHANDLE Nfsstat4 = 10001 + /* READDIR cookie is stale */ + NFS4ERR_BAD_COOKIE Nfsstat4 = 10003 + /* operation not supported */ + NFS4ERR_NOTSUPP Nfsstat4 = 10004 + /* response limit exceeded */ + NFS4ERR_TOOSMALL Nfsstat4 = 10005 + /* undefined server error */ + NFS4ERR_SERVERFAULT Nfsstat4 = 10006 + /* type invalid for CREATE */ + NFS4ERR_BADTYPE Nfsstat4 = 10007 + /* file "busy" - retry */ + NFS4ERR_DELAY Nfsstat4 = 10008 + /* nverify says attrs same */ + NFS4ERR_SAME Nfsstat4 = 10009 + /* lock unavailable */ + NFS4ERR_DENIED Nfsstat4 = 10010 + /* lock lease expired */ + NFS4ERR_EXPIRED Nfsstat4 = 10011 + /* I/O failed due to lock */ + NFS4ERR_LOCKED Nfsstat4 = 10012 + /* in grace period */ + NFS4ERR_GRACE Nfsstat4 = 10013 + /* filehandle expired */ + NFS4ERR_FHEXPIRED Nfsstat4 = 10014 + /* share reserve denied */ + NFS4ERR_SHARE_DENIED Nfsstat4 = 10015 + /* wrong security flavor */ + NFS4ERR_WRONGSEC Nfsstat4 = 10016 + /* clientid in use */ + NFS4ERR_CLID_INUSE Nfsstat4 = 10017 + /* resource exhaustion */ + NFS4ERR_RESOURCE Nfsstat4 = 10018 + /* filesystem relocated */ + NFS4ERR_MOVED Nfsstat4 = 10019 + /* current FH is not set */ + NFS4ERR_NOFILEHANDLE Nfsstat4 = 10020 + /* minor vers not supp */ + NFS4ERR_MINOR_VERS_MISMATCH Nfsstat4 = 10021 + /* server has rebooted */ + NFS4ERR_STALE_CLIENTID Nfsstat4 = 10022 + /* server has rebooted */ + NFS4ERR_STALE_STATEID Nfsstat4 = 10023 + /* state is out of sync */ + NFS4ERR_OLD_STATEID Nfsstat4 = 10024 + /* incorrect stateid */ + NFS4ERR_BAD_STATEID Nfsstat4 = 10025 + /* request is out of seq. */ + NFS4ERR_BAD_SEQID Nfsstat4 = 10026 + /* verify - attrs not same */ + NFS4ERR_NOT_SAME Nfsstat4 = 10027 + /* lock range not supported*/ + NFS4ERR_LOCK_RANGE Nfsstat4 = 10028 + /* should be file/directory*/ + NFS4ERR_SYMLINK Nfsstat4 = 10029 + /* no saved filehandle */ + NFS4ERR_RESTOREFH Nfsstat4 = 10030 + /* some filesystem moved */ + NFS4ERR_LEASE_MOVED Nfsstat4 = 10031 + /* recommended attr not sup*/ + NFS4ERR_ATTRNOTSUPP Nfsstat4 = 10032 + /* reclaim outside of grace*/ + NFS4ERR_NO_GRACE Nfsstat4 = 10033 + /* reclaim error at server */ + NFS4ERR_RECLAIM_BAD Nfsstat4 = 10034 + /* conflict on reclaim */ + NFS4ERR_RECLAIM_CONFLICT Nfsstat4 = 10035 + /* XDR decode failed */ + NFS4ERR_BADXDR Nfsstat4 = 10036 + /* file locks held at CLOSE*/ + NFS4ERR_LOCKS_HELD Nfsstat4 = 10037 + /* conflict in OPEN and I/O*/ + NFS4ERR_OPENMODE Nfsstat4 = 10038 + /* owner translation bad */ + NFS4ERR_BADOWNER Nfsstat4 = 10039 + /* utf-8 char not supported*/ + NFS4ERR_BADCHAR Nfsstat4 = 10040 + /* name not supported */ + NFS4ERR_BADNAME Nfsstat4 = 10041 + /* lock range not supported*/ + NFS4ERR_BAD_RANGE Nfsstat4 = 10042 + /* no atomic up/downgrade */ + NFS4ERR_LOCK_NOTSUPP Nfsstat4 = 10043 + /* undefined operation */ + NFS4ERR_OP_ILLEGAL Nfsstat4 = 10044 + /* file locking deadlock */ + NFS4ERR_DEADLOCK Nfsstat4 = 10045 + /* open file blocks op. */ + NFS4ERR_FILE_OPEN Nfsstat4 = 10046 + /* lockowner state revoked */ + NFS4ERR_ADMIN_REVOKED Nfsstat4 = 10047 + /* callback path down */ + NFS4ERR_CB_PATH_DOWN Nfsstat4 = 10048 + NFS4ERR_BADIOMODE Nfsstat4 = 10049 + NFS4ERR_BADLAYOUT Nfsstat4 = 10050 + NFS4ERR_BAD_SESSION_DIGEST Nfsstat4 = 10051 + NFS4ERR_BADSESSION Nfsstat4 = 10052 + NFS4ERR_BADSLOT Nfsstat4 = 10053 + NFS4ERR_COMPLETE_ALREADY Nfsstat4 = 10054 + NFS4ERR_CONN_NOT_BOUND_TO_SESSION Nfsstat4 = 10055 + NFS4ERR_DELEG_ALREADY_WANTED Nfsstat4 = 10056 + NFS4ERR_BACK_CHAN_BUSY Nfsstat4 = 10057 + NFS4ERR_LAYOUTTRYLATER Nfsstat4 = 10058 + NFS4ERR_LAYOUTUNAVAILABLE Nfsstat4 = 10059 + NFS4ERR_NOMATCHING_LAYOUT Nfsstat4 = 10060 + NFS4ERR_RECALLCONFLICT Nfsstat4 = 10061 +) + +/* + * Basic data types + */ +type Bitmap4 = []Uint32_t + +type Offset4 = Uint64_t + +type Count4 = Uint32_t + +type Length4 = Uint64_t + +type Clientid4 = Uint64_t + +type Sequenceid4 = Uint32_t + +type Seqid4 = Uint32_t + +type Slotid4 = Uint32_t + +type Utf8string = []byte + +type Utf8str_cis = Utf8string + +type Utf8str_cs = Utf8string + +type Utf8str_mixed = Utf8string + +type Component4 = Utf8str_cs + +type Pathname4 = []Component4 + +type Nfs_lockid4 = Uint64_t + +type Nfs_cookie4 = Uint64_t + +type Linktext4 = Utf8str_cs + +type Sec_oid4 = []byte + +type Qop4 = Uint32_t + +type Mode4 = Uint32_t + +type Changeid4 = Uint64_t + +type Verifier4 = [NFS4_VERIFIER_SIZE]byte + +type Sessionid4 = [NFS4_SESSIONID_SIZE]byte + +/* + * Authsys_parms + */ +type Authsys_parms struct { + Stamp uint32 + Machinename string // bound 255 + Uid uint32 + Gid uint32 + Gids []uint32 // bound 16 +} + +const NFS4_DEVICEID4_SIZE = 16 + +type Deviceid4 = [NFS4_DEVICEID4_SIZE]byte + +type Layouttype4 int32 +const ( + LAYOUT4_NFSV4_1_FILES Layouttype4 = Layouttype4(0x1) + LAYOUT4_OSD2_OBJECTS Layouttype4 = Layouttype4(0x2) + LAYOUT4_BLOCK_VOLUME Layouttype4 = Layouttype4(0x3) +) + +type Layoutupdate4 struct { + Lou_type Layouttype4 + Lou_body []byte +} + +type Device_addr4 struct { + Da_layout_type Layouttype4 + Da_addr_body []byte +} + +/* + * Timeval + */ +type Nfstime4 struct { + Seconds Int64_t + Nseconds Uint32_t +} + +type Time_how4 int32 +const ( + SET_TO_SERVER_TIME4 Time_how4 = 0 + SET_TO_CLIENT_TIME4 Time_how4 = 1 +) + +type Layoutiomode4 int32 +const ( + LAYOUTIOMODE4_READ Layoutiomode4 = 1 + LAYOUTIOMODE4_RW Layoutiomode4 = 2 + LAYOUTIOMODE4_ANY Layoutiomode4 = 3 +) + +type Layout_content4 struct { + Loc_type Layouttype4 + Loc_body []byte +} + +type Layout4 struct { + Lo_offset Offset4 + Lo_length Length4 + Lo_iomode Layoutiomode4 + Lo_content Layout_content4 +} + +type Settime4 struct { + // The union discriminant Set_it selects among the following arms: + // SET_TO_CLIENT_TIME4: + // Time() *Nfstime4 + // default: + // void + Set_it Time_how4 + U interface{} +} + +/* + * File access handle + */ +type Nfs_fh4 = []byte // bound NFS4_FHSIZE + +/* + * FSID structure for major/minor + */ +type Fsid4 struct { + Major Uint64_t + Minor Uint64_t +} + +/* + * Filesystem locations attribute for relocation/migration + */ +type Fs_location4 struct { + Server []Utf8str_cis + Rootpath Pathname4 +} + +type Fs_locations4 struct { + Fs_root Pathname4 + Locations []Fs_location4 +} + +/* + * Mask that indicates which Access Control Entries are supported. + * Values for the fattr4_aclsupport attribute. + */ +const ACL4_SUPPORT_ALLOW_ACL = 0x00000001 + +const ACL4_SUPPORT_DENY_ACL = 0x00000002 + +const ACL4_SUPPORT_AUDIT_ACL = 0x00000004 + +const ACL4_SUPPORT_ALARM_ACL = 0x00000008 + +type Acetype4 = Uint32_t + +/* + * acetype4 values, others can be added as needed. + */ +const ACE4_ACCESS_ALLOWED_ACE_TYPE = 0x00000000 + +const ACE4_ACCESS_DENIED_ACE_TYPE = 0x00000001 + +const ACE4_SYSTEM_AUDIT_ACE_TYPE = 0x00000002 + +const ACE4_SYSTEM_ALARM_ACE_TYPE = 0x00000003 + +/* + * ACE flag + */ +type Aceflag4 = Uint32_t + +/* + * ACE flag values + */ +const ACE4_FILE_INHERIT_ACE = 0x00000001 + +const ACE4_DIRECTORY_INHERIT_ACE = 0x00000002 + +const ACE4_NO_PROPAGATE_INHERIT_ACE = 0x00000004 + +const ACE4_INHERIT_ONLY_ACE = 0x00000008 + +const ACE4_SUCCESSFUL_ACCESS_ACE_FLAG = 0x00000010 + +const ACE4_FAILED_ACCESS_ACE_FLAG = 0x00000020 + +const ACE4_IDENTIFIER_GROUP = 0x00000040 + +/* + * ACE mask + */ +type Acemask4 = Uint32_t + +/* + * ACE mask values + */ +const ACE4_READ_DATA = 0x00000001 + +const ACE4_LIST_DIRECTORY = 0x00000001 + +const ACE4_WRITE_DATA = 0x00000002 + +const ACE4_ADD_FILE = 0x00000002 + +const ACE4_APPEND_DATA = 0x00000004 + +const ACE4_ADD_SUBDIRECTORY = 0x00000004 + +const ACE4_READ_NAMED_ATTRS = 0x00000008 + +const ACE4_WRITE_NAMED_ATTRS = 0x00000010 + +const ACE4_EXECUTE = 0x00000020 + +const ACE4_DELETE_CHILD = 0x00000040 + +const ACE4_READ_ATTRIBUTES = 0x00000080 + +const ACE4_WRITE_ATTRIBUTES = 0x00000100 + +const ACE4_DELETE = 0x00010000 + +const ACE4_READ_ACL = 0x00020000 + +const ACE4_WRITE_ACL = 0x00040000 + +const ACE4_WRITE_OWNER = 0x00080000 + +const ACE4_SYNCHRONIZE = 0x00100000 + +/* + * ACE4_GENERIC_READ -- defined as combination of + * ACE4_READ_ACL | + * ACE4_READ_DATA | + * ACE4_READ_ATTRIBUTES | + * ACE4_SYNCHRONIZE + */ +const ACE4_GENERIC_READ = 0x00120081 + +/* + * ACE4_GENERIC_WRITE -- defined as combination of + * ACE4_READ_ACL | + * ACE4_WRITE_DATA | + * ACE4_WRITE_ATTRIBUTES | + * ACE4_WRITE_ACL | + * ACE4_APPEND_DATA | + * ACE4_SYNCHRONIZE + */ +const ACE4_GENERIC_WRITE = 0x00160106 + +/* + * ACE4_GENERIC_EXECUTE -- defined as combination of + * ACE4_READ_ACL + * ACE4_READ_ATTRIBUTES + * ACE4_EXECUTE + * ACE4_SYNCHRONIZE + */ +const ACE4_GENERIC_EXECUTE = 0x001200A0 + +/* + * Access Control Entry definition + */ +type Nfsace4 struct { + Type Acetype4 + Flag Aceflag4 + Access_mask Acemask4 + Who Utf8str_mixed +} + +/* + * Field definitions for the fattr4_mode attribute + */ +const MODE4_SUID = 0x800 + +/* set group id on execution */ +const MODE4_SGID = 0x400 + +/* save text even after use */ +const MODE4_SVTX = 0x200 + +/* read permission: owner */ +const MODE4_RUSR = 0x100 + +/* write permission: owner */ +const MODE4_WUSR = 0x080 + +/* execute permission: owner */ +const MODE4_XUSR = 0x040 + +/* read permission: group */ +const MODE4_RGRP = 0x020 + +/* write permission: group */ +const MODE4_WGRP = 0x010 + +/* execute permission: group */ +const MODE4_XGRP = 0x008 + +/* read permission: other */ +const MODE4_ROTH = 0x004 + +/* write permission: other */ +const MODE4_WOTH = 0x002 + +/* execute permission: other */ +const MODE4_XOTH = 0x001 + +/* + * Special data/attribute associated with + * file types NF4BLK and NF4CHR. + */ +type Specdata4 struct { + /* major device number */ + Specdata1 Uint32_t + /* minor device number */ + Specdata2 Uint32_t +} + +/* + * Values for fattr4_fh_expire_type + */ +const FH4_PERSISTENT = 0x00000000 + +const FH4_NOEXPIRE_WITH_OPEN = 0x00000001 + +const FH4_VOLATILE_ANY = 0x00000002 + +const FH4_VOL_MIGRATION = 0x00000004 + +const FH4_VOL_RENAME = 0x00000008 + +type Fattr4_supported_attrs = Bitmap4 + +type Fattr4_type = Nfs_ftype4 + +type Fattr4_fh_expire_type = Uint32_t + +type Fattr4_change = Changeid4 + +type Fattr4_size = Uint64_t + +type Fattr4_link_support = bool + +type Fattr4_symlink_support = bool + +type Fattr4_named_attr = bool + +type Fattr4_fsid = Fsid4 + +type Fattr4_unique_handles = bool + +type Fattr4_lease_time = Uint32_t + +type Fattr4_rdattr_error = Nfsstat4 + +type Fattr4_acl = []Nfsace4 + +type Fattr4_aclsupport = Uint32_t + +type Fattr4_archive = bool + +type Fattr4_cansettime = bool + +type Fattr4_case_insensitive = bool + +type Fattr4_case_preserving = bool + +type Fattr4_chown_restricted = bool + +type Fattr4_fileid = Uint64_t + +type Fattr4_files_avail = Uint64_t + +type Fattr4_filehandle = Nfs_fh4 + +type Fattr4_files_free = Uint64_t + +type Fattr4_files_total = Uint64_t + +type Fattr4_fs_locations = Fs_locations4 + +type Fattr4_hidden = bool + +type Fattr4_homogeneous = bool + +type Fattr4_maxfilesize = Uint64_t + +type Fattr4_maxlink = Uint32_t + +type Fattr4_maxname = Uint32_t + +type Fattr4_maxread = Uint64_t + +type Fattr4_maxwrite = Uint64_t + +type Fattr4_mimetype = Utf8str_cs + +type Fattr4_mode = Mode4 + +type Fattr4_mounted_on_fileid = Uint64_t + +type Fattr4_no_trunc = bool + +type Fattr4_numlinks = Uint32_t + +type Fattr4_owner = Utf8str_mixed + +type Fattr4_owner_group = Utf8str_mixed + +type Fattr4_quota_avail_hard = Uint64_t + +type Fattr4_quota_avail_soft = Uint64_t + +type Fattr4_quota_used = Uint64_t + +type Fattr4_rawdev = Specdata4 + +type Fattr4_space_avail = Uint64_t + +type Fattr4_space_free = Uint64_t + +type Fattr4_space_total = Uint64_t + +type Fattr4_space_used = Uint64_t + +type Fattr4_system = bool + +type Fattr4_time_access = Nfstime4 + +type Fattr4_time_access_set = Settime4 + +type Fattr4_time_backup = Nfstime4 + +type Fattr4_time_create = Nfstime4 + +type Fattr4_time_delta = Nfstime4 + +type Fattr4_time_metadata = Nfstime4 + +type Fattr4_time_modify = Nfstime4 + +type Fattr4_time_modify_set = Settime4 + +/* + * Mandatory Attributes + */ +const FATTR4_SUPPORTED_ATTRS = 0 + +const FATTR4_TYPE = 1 + +const FATTR4_FH_EXPIRE_TYPE = 2 + +const FATTR4_CHANGE = 3 + +const FATTR4_SIZE = 4 + +const FATTR4_LINK_SUPPORT = 5 + +const FATTR4_SYMLINK_SUPPORT = 6 + +const FATTR4_NAMED_ATTR = 7 + +const FATTR4_FSID = 8 + +const FATTR4_UNIQUE_HANDLES = 9 + +const FATTR4_LEASE_TIME = 10 + +const FATTR4_RDATTR_ERROR = 11 + +const FATTR4_FILEHANDLE = 19 + +/* + * Recommended Attributes + */ +const FATTR4_ACL = 12 + +const FATTR4_ACLSUPPORT = 13 + +const FATTR4_ARCHIVE = 14 + +const FATTR4_CANSETTIME = 15 + +const FATTR4_CASE_INSENSITIVE = 16 + +const FATTR4_CASE_PRESERVING = 17 + +const FATTR4_CHOWN_RESTRICTED = 18 + +const FATTR4_FILEID = 20 + +const FATTR4_FILES_AVAIL = 21 + +const FATTR4_FILES_FREE = 22 + +const FATTR4_FILES_TOTAL = 23 + +const FATTR4_FS_LOCATIONS = 24 + +const FATTR4_HIDDEN = 25 + +const FATTR4_HOMOGENEOUS = 26 + +const FATTR4_MAXFILESIZE = 27 + +const FATTR4_MAXLINK = 28 + +const FATTR4_MAXNAME = 29 + +const FATTR4_MAXREAD = 30 + +const FATTR4_MAXWRITE = 31 + +const FATTR4_MIMETYPE = 32 + +const FATTR4_MODE = 33 + +const FATTR4_NO_TRUNC = 34 + +const FATTR4_NUMLINKS = 35 + +const FATTR4_OWNER = 36 + +const FATTR4_OWNER_GROUP = 37 + +const FATTR4_QUOTA_AVAIL_HARD = 38 + +const FATTR4_QUOTA_AVAIL_SOFT = 39 + +const FATTR4_QUOTA_USED = 40 + +const FATTR4_RAWDEV = 41 + +const FATTR4_SPACE_AVAIL = 42 + +const FATTR4_SPACE_FREE = 43 + +const FATTR4_SPACE_TOTAL = 44 + +const FATTR4_SPACE_USED = 45 + +const FATTR4_SYSTEM = 46 + +const FATTR4_TIME_ACCESS = 47 + +const FATTR4_TIME_ACCESS_SET = 48 + +const FATTR4_TIME_BACKUP = 49 + +const FATTR4_TIME_CREATE = 50 + +const FATTR4_TIME_DELTA = 51 + +const FATTR4_TIME_METADATA = 52 + +const FATTR4_TIME_MODIFY = 53 + +const FATTR4_TIME_MODIFY_SET = 54 + +const FATTR4_MOUNTED_ON_FILEID = 55 + +type Attrlist4 = []byte + +/* + * File attribute container + */ +type Fattr4 struct { + Attrmask Bitmap4 + Attr_vals Attrlist4 +} + +/* + * Change info for the client + */ +type Change_info4 struct { + Atomic bool + Before Changeid4 + After Changeid4 +} + +type Clientaddr4 struct { + /* see struct rpcb in RFC 1833 */ + R_netid string + /* universal address */ + R_addr string +} + +/* + * Callback program info as provided by the client + */ +type Cb_client4 struct { + Cb_program Uint32_t + Cb_location Clientaddr4 +} + +/* + * Stateid + */ +type Stateid4 struct { + Seqid Uint32_t + Other [12]byte +} + +/* + * Client ID + */ +type Nfs_client_id4 struct { + Verifier Verifier4 + Id []byte // bound NFS4_OPAQUE_LIMIT +} + +type Open_owner4 struct { + Clientid Clientid4 + Owner []byte // bound NFS4_OPAQUE_LIMIT +} + +type Lock_owner4 struct { + Clientid Clientid4 + Owner []byte // bound NFS4_OPAQUE_LIMIT +} + +type Nfs_lock_type4 int32 +const ( + READ_LT Nfs_lock_type4 = 1 + WRITE_LT Nfs_lock_type4 = 2 + /* blocking read */ + READW_LT Nfs_lock_type4 = 3 + /* blocking write */ + WRITEW_LT Nfs_lock_type4 = 4 +) + +/* + * ACCESS: Check access permission + */ +const ACCESS4_READ = 0x00000001 + +const ACCESS4_LOOKUP = 0x00000002 + +const ACCESS4_MODIFY = 0x00000004 + +const ACCESS4_EXTEND = 0x00000008 + +const ACCESS4_DELETE = 0x00000010 + +const ACCESS4_EXECUTE = 0x00000020 + +type ACCESS4args struct { + /* CURRENT_FH: object */ + Access Uint32_t +} + +type ACCESS4resok struct { + Supported Uint32_t + Access Uint32_t +} + +type ACCESS4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *ACCESS4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * CLOSE: Close a file and release share reservations + */ +type CLOSE4args struct { + /* CURRENT_FH: object */ + Seqid Seqid4 + Open_stateid Stateid4 +} + +type CLOSE4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Open_stateid() *Stateid4 + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * COMMIT: Commit cached data on server to stable storage + */ +type COMMIT4args struct { + /* CURRENT_FH: file */ + Offset Offset4 + Count Count4 +} + +type COMMIT4resok struct { + Writeverf Verifier4 +} + +type COMMIT4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *COMMIT4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * CREATE: Create a non-regular file + */ +type Createtype4 struct { + // The union discriminant Type selects among the following arms: + // NF4LNK: + // Linkdata() *Linktext4 + // NF4BLK, NF4CHR: + // Devdata() *Specdata4 + // NF4SOCK, NF4FIFO, NF4DIR: + // void + // default: + // void + Type Nfs_ftype4 + U interface{} +} + +type CREATE4args struct { + /* CURRENT_FH: directory for creation */ + Objtype Createtype4 + Objname Component4 + Createattrs Fattr4 +} + +type CREATE4resok struct { + Cinfo Change_info4 + /* attributes set */ + Attrset Bitmap4 +} + +type CREATE4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *CREATE4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * DELEGPURGE: Purge Delegations Awaiting Recovery + */ +type DELEGPURGE4args struct { + Clientid Clientid4 +} + +type DELEGPURGE4res struct { + Status Nfsstat4 +} + +/* + * DELEGRETURN: Return a delegation + */ +type DELEGRETURN4args struct { + /* CURRENT_FH: delegated file */ + Deleg_stateid Stateid4 +} + +type DELEGRETURN4res struct { + Status Nfsstat4 +} + +/* + * GETATTR: Get file attributes + */ +type GETATTR4args struct { + /* CURRENT_FH: directory or file */ + Attr_request Bitmap4 +} + +type GETATTR4resok struct { + Obj_attributes Fattr4 +} + +type GETATTR4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *GETATTR4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * GETFH: Get current filehandle + */ +type GETFH4resok struct { + Object Nfs_fh4 +} + +type GETFH4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *GETFH4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * LINK: Create link to an object + */ +type LINK4args struct { + /* CURRENT_FH: target directory */ + Newname Component4 +} + +type LINK4resok struct { + Cinfo Change_info4 +} + +type LINK4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *LINK4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * For LOCK, transition from open_owner to new lock_owner + */ +type Open_to_lock_owner4 struct { + Open_seqid Seqid4 + Open_stateid Stateid4 + Lock_seqid Seqid4 + Lock_owner Lock_owner4 +} + +/* + * For LOCK, existing lock_owner continues to request file locks + */ +type Exist_lock_owner4 struct { + Lock_stateid Stateid4 + Lock_seqid Seqid4 +} + +type Locker4 struct { + // The union discriminant New_lock_owner selects among the following arms: + // true: + // Open_owner() *Open_to_lock_owner4 + // false: + // Lock_owner() *Exist_lock_owner4 + New_lock_owner bool + U interface{} +} + +/* + * LOCK/LOCKT/LOCKU: Record lock management + */ +type LOCK4args struct { + /* CURRENT_FH: file */ + Locktype Nfs_lock_type4 + Reclaim bool + Offset Offset4 + Length Length4 + Locker Locker4 +} + +type LOCK4denied struct { + Offset Offset4 + Length Length4 + Locktype Nfs_lock_type4 + Owner Lock_owner4 +} + +type LOCK4resok struct { + Lock_stateid Stateid4 +} + +type LOCK4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *LOCK4resok + // NFS4ERR_DENIED: + // Denied() *LOCK4denied + // default: + // void + Status Nfsstat4 + U interface{} +} + +type LOCKT4args struct { + /* CURRENT_FH: file */ + Locktype Nfs_lock_type4 + Offset Offset4 + Length Length4 + Owner Lock_owner4 +} + +type LOCKT4res struct { + // The union discriminant Status selects among the following arms: + // NFS4ERR_DENIED: + // Denied() *LOCK4denied + // NFS4_OK: + // void + // default: + // void + Status Nfsstat4 + U interface{} +} + +type LOCKU4args struct { + /* CURRENT_FH: file */ + Locktype Nfs_lock_type4 + Seqid Seqid4 + Lock_stateid Stateid4 + Offset Offset4 + Length Length4 +} + +type LOCKU4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Lock_stateid() *Stateid4 + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * LOOKUP: Lookup filename + */ +type LOOKUP4args struct { + /* CURRENT_FH: directory */ + Objname Component4 +} + +type LOOKUP4res struct { + /* CURRENT_FH: object */ + Status Nfsstat4 +} + +/* + * LOOKUPP: Lookup parent directory + */ +type LOOKUPP4res struct { + /* CURRENT_FH: directory */ + Status Nfsstat4 +} + +/* + * NVERIFY: Verify attributes different + */ +type NVERIFY4args struct { + /* CURRENT_FH: object */ + Obj_attributes Fattr4 +} + +type NVERIFY4res struct { + Status Nfsstat4 +} + +/* + * Various definitions for OPEN + */ +type Createmode4 int32 +const ( + UNCHECKED4 Createmode4 = 0 + GUARDED4 Createmode4 = 1 + EXCLUSIVE4 Createmode4 = 2 +) + +type Createhow4 struct { + // The union discriminant Mode selects among the following arms: + // UNCHECKED4, GUARDED4: + // Createattrs() *Fattr4 + // EXCLUSIVE4: + // Createverf() *Verifier4 + Mode Createmode4 + U interface{} +} + +type Opentype4 int32 +const ( + OPEN4_NOCREATE Opentype4 = 0 + OPEN4_CREATE Opentype4 = 1 +) + +type Openflag4 struct { + // The union discriminant Opentype selects among the following arms: + // OPEN4_CREATE: + // How() *Createhow4 + // default: + // void + Opentype Opentype4 + U interface{} +} + +/* Next definitions used for OPEN delegation */ +type Limit_by4 int32 +const ( + NFS_LIMIT_SIZE Limit_by4 = 1 + NFS_LIMIT_BLOCKS Limit_by4 = 2 +) + +type Nfs_modified_limit4 struct { + Num_blocks Uint32_t + Bytes_per_block Uint32_t +} + +type Nfs_space_limit4 struct { + // The union discriminant Limitby selects among the following arms: + // NFS_LIMIT_SIZE: + // Filesize() *Uint64_t + // NFS_LIMIT_BLOCKS: + // Mod_blocks() *Nfs_modified_limit4 + Limitby Limit_by4 + U interface{} +} + +/* + * Share Access and Deny constants for open argument + */ +const OPEN4_SHARE_ACCESS_READ = 0x00000001 + +const OPEN4_SHARE_ACCESS_WRITE = 0x00000002 + +const OPEN4_SHARE_ACCESS_BOTH = 0x00000003 + +const OPEN4_SHARE_DENY_NONE = 0x00000000 + +const OPEN4_SHARE_DENY_READ = 0x00000001 + +const OPEN4_SHARE_DENY_WRITE = 0x00000002 + +const OPEN4_SHARE_DENY_BOTH = 0x00000003 + +type Open_delegation_type4 int32 +const ( + OPEN_DELEGATE_NONE Open_delegation_type4 = 0 + OPEN_DELEGATE_READ Open_delegation_type4 = 1 + OPEN_DELEGATE_WRITE Open_delegation_type4 = 2 +) + +type Open_claim_type4 int32 +const ( + CLAIM_NULL Open_claim_type4 = 0 + CLAIM_PREVIOUS Open_claim_type4 = 1 + CLAIM_DELEGATE_CUR Open_claim_type4 = 2 + CLAIM_DELEGATE_PREV Open_claim_type4 = 3 + /* new to v4.1 */ + CLAIM_FH Open_claim_type4 = 4 + /* new to v4.1 */ + CLAIM_DELEG_CUR_FH Open_claim_type4 = 5 + /* new to v4.1 */ + CLAIM_DELEG_PREV_FH Open_claim_type4 = 6 +) + +type Open_claim_delegate_cur4 struct { + Delegate_stateid Stateid4 + File Component4 +} + +type Open_claim4 struct { + // The union discriminant Claim selects among the following arms: + // CLAIM_NULL: + // File() *Component4 + // CLAIM_PREVIOUS: + // Delegate_type() *Open_delegation_type4 + // CLAIM_DELEGATE_CUR: + // Delegate_cur_info() *Open_claim_delegate_cur4 + // CLAIM_DELEGATE_PREV: + // File_delegate_prev() *Component4 + Claim Open_claim_type4 + U interface{} +} + +/* + * OPEN: Open a file, potentially receiving an open delegation + */ +type OPEN4args struct { + Seqid Seqid4 + Share_access Uint32_t + Share_deny Uint32_t + Owner Open_owner4 + Openhow Openflag4 + Claim Open_claim4 +} + +type Open_read_delegation4 struct { + /* Stateid for delegation*/ + Stateid Stateid4 + Recall bool + Permissions Nfsace4 +} + +type Open_write_delegation4 struct { + /* Stateid for delegation */ + Stateid Stateid4 + Recall bool + Space_limit Nfs_space_limit4 + Permissions Nfsace4 +} + +type Open_delegation4 struct { + // The union discriminant Delegation_type selects among the following arms: + // OPEN_DELEGATE_NONE: + // void + // OPEN_DELEGATE_READ: + // Read() *Open_read_delegation4 + // OPEN_DELEGATE_WRITE: + // Write() *Open_write_delegation4 + Delegation_type Open_delegation_type4 + U interface{} +} + +/* Client must confirm open */ +const OPEN4_RESULT_CONFIRM = 0x00000002 + +/* Type of file locking behavior at the server */ +const OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004 + +type OPEN4resok struct { + /* Stateid for open */ + Stateid Stateid4 + /* Directory Change Info */ + Cinfo Change_info4 + /* Result flags */ + Rflags Uint32_t + /* attribute set for create*/ + Attrset Bitmap4 + Delegation Open_delegation4 +} + +type OPEN4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *OPEN4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * OPENATTR: open named attributes directory + */ +type OPENATTR4args struct { + /* CURRENT_FH: object */ + Createdir bool +} + +type OPENATTR4res struct { + /* CURRENT_FH: named attr directory */ + Status Nfsstat4 +} + +/* + * OPEN_CONFIRM: confirm the open + */ +type OPEN_CONFIRM4args struct { + /* CURRENT_FH: opened file */ + Open_stateid Stateid4 + Seqid Seqid4 +} + +type OPEN_CONFIRM4resok struct { + Open_stateid Stateid4 +} + +type OPEN_CONFIRM4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *OPEN_CONFIRM4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * OPEN_DOWNGRADE: downgrade the access/deny for a file + */ +type OPEN_DOWNGRADE4args struct { + /* CURRENT_FH: opened file */ + Open_stateid Stateid4 + Seqid Seqid4 + Share_access Uint32_t + Share_deny Uint32_t +} + +type OPEN_DOWNGRADE4resok struct { + Open_stateid Stateid4 +} + +type OPEN_DOWNGRADE4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *OPEN_DOWNGRADE4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * PUTFH: Set current filehandle + */ +type PUTFH4args struct { + Object Nfs_fh4 +} + +type PUTFH4res struct { + /* CURRENT_FH: */ + Status Nfsstat4 +} + +/* + * PUTPUBFH: Set public filehandle + */ +type PUTPUBFH4res struct { + /* CURRENT_FH: public fh */ + Status Nfsstat4 +} + +/* + * PUTROOTFH: Set root filehandle + */ +type PUTROOTFH4res struct { + /* CURRENT_FH: root fh */ + Status Nfsstat4 +} + +/* + * READ: Read from file + */ +type READ4args struct { + /* CURRENT_FH: file */ + Stateid Stateid4 + Offset Offset4 + Count Count4 +} + +type READ4resok struct { + Eof bool + Data []byte +} + +type READ4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *READ4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * READDIR: Read directory + */ +type READDIR4args struct { + /* CURRENT_FH: directory */ + Cookie Nfs_cookie4 + Cookieverf Verifier4 + Dircount Count4 + Maxcount Count4 + Attr_request Bitmap4 +} + +type Entry4 struct { + Cookie Nfs_cookie4 + Name Component4 + Attrs Fattr4 + Nextentry *Entry4 +} + +type Dirlist4 struct { + Entries *Entry4 + Eof bool +} + +type READDIR4resok struct { + Cookieverf Verifier4 + Reply Dirlist4 +} + +type READDIR4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *READDIR4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * READLINK: Read symbolic link + */ +type READLINK4resok struct { + Link Linktext4 +} + +type READLINK4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *READLINK4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * REMOVE: Remove filesystem object + */ +type REMOVE4args struct { + /* CURRENT_FH: directory */ + Target Component4 +} + +type REMOVE4resok struct { + Cinfo Change_info4 +} + +type REMOVE4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *REMOVE4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * RENAME: Rename directory entry + */ +type RENAME4args struct { + /* SAVED_FH: source directory */ + Oldname Component4 + Newname Component4 +} + +type RENAME4resok struct { + Source_cinfo Change_info4 + Target_cinfo Change_info4 +} + +type RENAME4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *RENAME4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * RENEW: Renew a Lease + */ +type RENEW4args struct { + Clientid Clientid4 +} + +type RENEW4res struct { + Status Nfsstat4 +} + +type RESTOREFH4res struct { + /* CURRENT_FH: value of saved fh */ + Status Nfsstat4 +} + +/* + * SAVEFH: Save current filehandle + */ +type SAVEFH4res struct { + /* SAVED_FH: value of current fh */ + Status Nfsstat4 +} + +/* + * SECINFO: Obtain Available Security Mechanisms + */ +type SECINFO4args struct { + Name Component4 +} + +type Rpc_gss_svc_t int32 +const ( + RPC_GSS_SVC_NONE Rpc_gss_svc_t = 1 + RPC_GSS_SVC_INTEGRITY Rpc_gss_svc_t = 2 + RPC_GSS_SVC_PRIVACY Rpc_gss_svc_t = 3 +) + +type Rpcsec_gss_info struct { + Oid Sec_oid4 + Qop Qop4 + Service Rpc_gss_svc_t +} + +const RPCSEC_GSS = 6 + +type Secinfo4 struct { + // The union discriminant Flavor selects among the following arms: + // RPCSEC_GSS: + // Flavor_info() *Rpcsec_gss_info + // default: + // void + Flavor Uint32_t + U interface{} +} + +type SECINFO4resok = []Secinfo4 + +type SECINFO4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *SECINFO4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * SETATTR: Set attributes + */ +type SETATTR4args struct { + /* CURRENT_FH: target object */ + Stateid Stateid4 + Obj_attributes Fattr4 +} + +type SETATTR4res struct { + Status Nfsstat4 + Attrsset Bitmap4 +} + +/* + * SETCLIENTID + */ +type SETCLIENTID4args struct { + Client Nfs_client_id4 + Callback Cb_client4 + Callback_ident Uint32_t +} + +type SETCLIENTID4resok struct { + Clientid Clientid4 + Setclientid_confirm Verifier4 +} + +type SETCLIENTID4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *SETCLIENTID4resok + // NFS4ERR_CLID_INUSE: + // Client_using() *Clientaddr4 + // default: + // void + Status Nfsstat4 + U interface{} +} + +type SETCLIENTID_CONFIRM4args struct { + Clientid Clientid4 + Setclientid_confirm Verifier4 +} + +type SETCLIENTID_CONFIRM4res struct { + Status Nfsstat4 +} + +/* + * VERIFY: Verify attributes same + */ +type VERIFY4args struct { + /* CURRENT_FH: object */ + Obj_attributes Fattr4 +} + +type VERIFY4res struct { + Status Nfsstat4 +} + +/* + * WRITE: Write to file + */ +type Stable_how4 int32 +const ( + UNSTABLE4 Stable_how4 = 0 + DATA_SYNC4 Stable_how4 = 1 + FILE_SYNC4 Stable_how4 = 2 +) + +type WRITE4args struct { + /* CURRENT_FH: file */ + Stateid Stateid4 + Offset Offset4 + Stable Stable_how4 + Data []byte +} + +type WRITE4resok struct { + Count Count4 + Committed Stable_how4 + Writeverf Verifier4 +} + +type WRITE4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *WRITE4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * RELEASE_LOCKOWNER: Notify server to release lockowner + */ +type RELEASE_LOCKOWNER4args struct { + Lock_owner Lock_owner4 +} + +type RELEASE_LOCKOWNER4res struct { + Status Nfsstat4 +} + +type Callback_sec_parms4 struct { + // The union discriminant Cb_secflavor selects among the following arms: + // AUTH_NONE: + // void + // AUTH_SYS: + // Cbsp_sys_cred() *Authsys_parms + Cb_secflavor Uint32_t + U interface{} +} + +/* + * CREATE_SESSION + */ +type Channel_attrs4 struct { + Ca_headerpadsize Count4 + Ca_maxrequestsize Count4 + Ca_maxresponsesize Count4 + Ca_maxresponsesize_cached Count4 + Ca_maxoperations Count4 + Ca_maxrequests Count4 + Ca_rdma_ird []Uint32_t // bound 1 +} + +const CREATE_SESSION4_FLAG_PERSIST = 0x00000001 + +const CREATE_SESSION4_FLAG_CONN_BACK_CHAN = 0x00000002 + +const CREATE_SESSION4_FLAG_CONN_RDMA = 0x00000004 + +type CREATE_SESSION4args struct { + Csa_clientid Clientid4 + Csa_sequence Sequenceid4 + Csa_flags Uint32_t + Csa_fore_chan_attrs Channel_attrs4 + Csa_back_chan_attrs Channel_attrs4 + Csa_cb_program Uint32_t + Csa_sec_parms []Callback_sec_parms4 +} + +type CREATE_SESSION4resok struct { + Csr_sessionid Sessionid4 + Csr_sequence Sequenceid4 + Csr_flags Uint32_t + Csr_fore_chan_attrs Channel_attrs4 + Csr_back_chan_attrs Channel_attrs4 +} + +type CREATE_SESSION4res struct { + // The union discriminant Csr_status selects among the following arms: + // NFS4_OK: + // Csr_resok4() *CREATE_SESSION4resok + // default: + // void + Csr_status Nfsstat4 + U interface{} +} + +/* + * DESTROY_SESSION + */ +type DESTROY_SESSION4args struct { + Dsa_sessionid Sessionid4 +} + +type DESTROY_SESSION4res struct { + Dsr_status Nfsstat4 +} + +/* + * FREE_STATEID + */ +type FREE_STATEID4args struct { + Fsa_stateid Stateid4 +} + +type FREE_STATEID4res struct { + Fsr_status Nfsstat4 +} + +/* + * GET_DIR_DELEGATION + */ +type Attr_notice4 = Nfstime4 + +type GET_DIR_DELEGATION4args struct { + Gdda_signal_deleg_avail bool + Gdda_notification_types Bitmap4 + Gdda_child_attr_delay Attr_notice4 + Gdda_dir_attr_delay Attr_notice4 + Gdda_child_attributes Bitmap4 + Gdda_dir_attributes Bitmap4 +} + +type GET_DIR_DELEGATION4resok struct { + Gddr_cookieverf Verifier4 + Gddr_stateid Stateid4 + Gddr_notification Bitmap4 + Gddr_child_attributes Bitmap4 + Gddr_dir_attributes Bitmap4 +} + +type Gddrnf4_status int32 +const ( + GDD4_OK Gddrnf4_status = 0 + GDD4_UNAVAIL Gddrnf4_status = 1 +) + +type GET_DIR_DELEGATION4res_non_fatal struct { + // The union discriminant Gddrnf_status selects among the following arms: + // GDD4_OK: + // Gddrnf_resok4() *GET_DIR_DELEGATION4resok + // GDD4_UNAVAIL: + // Gddrnf_will_signal_deleg_avail() *bool + Gddrnf_status Gddrnf4_status + U interface{} +} + +type GET_DIR_DELEGATION4res struct { + // The union discriminant Gddr_status selects among the following arms: + // NFS4_OK: + // Gddr_res_non_fatal4() *GET_DIR_DELEGATION4res_non_fatal + // default: + // void + Gddr_status Nfsstat4 + U interface{} +} + +/* + * GETDEVICEINFO + */ +type GETDEVICEINFO4args struct { + Gdia_device_id Deviceid4 + Gdia_layout_type Layouttype4 + Gdia_maxcount Count4 + Gdia_notify_types Bitmap4 +} + +type GETDEVICEINFO4resok struct { + Gdir_device_addr Device_addr4 + Gdir_notification Bitmap4 +} + +type GETDEVICEINFO4res struct { + // The union discriminant Gdir_status selects among the following arms: + // NFS4_OK: + // Gdir_resok4() *GETDEVICEINFO4resok + // NFS4ERR_TOOSMALL: + // Gdir_mincount() *Count4 + // default: + // void + Gdir_status Nfsstat4 + U interface{} +} + +/* + * GETDEVICELIST + */ +type GETDEVICELIST4args struct { + Gdla_layout_type Layouttype4 + Gdla_maxdevices Count4 + Gdla_cookie Nfs_cookie4 + Gdla_cookieverf Verifier4 +} + +type GETDEVICELIST4resok struct { + Gdlr_cookie Nfs_cookie4 + Gdlr_cookieverf Verifier4 + Gdlr_deviceid_list []Deviceid4 + Gdlr_eof bool +} + +type GETDEVICELIST4res struct { + // The union discriminant Gdlr_status selects among the following arms: + // NFS4_OK: + // Gdlr_resok4() *GETDEVICELIST4resok + // default: + // void + Gdlr_status Nfsstat4 + U interface{} +} + +/* + * LAYOUTCOMMIT + */ +type Newtime4 struct { + // The union discriminant Nt_timechanged selects among the following arms: + // true: + // Nt_time() *Nfstime4 + // false: + // void + Nt_timechanged bool + U interface{} +} + +type Newoffset4 struct { + // The union discriminant No_newoffset selects among the following arms: + // true: + // No_offset() *Offset4 + // false: + // void + No_newoffset bool + U interface{} +} + +type LAYOUTCOMMIT4args struct { + Loca_offset Offset4 + Loca_length Length4 + Loca_reclaim bool + Loca_stateid Stateid4 + Loca_last_write_offset Newoffset4 + Loca_time_modify Newtime4 + Loca_layoutupdate Layoutupdate4 +} + +type Newsize4 struct { + // The union discriminant Ns_sizechanged selects among the following arms: + // true: + // Ns_size() *Length4 + // false: + // void + Ns_sizechanged bool + U interface{} +} + +type LAYOUTCOMMIT4resok struct { + Locr_newsize Newsize4 +} + +type LAYOUTCOMMIT4res struct { + // The union discriminant Locr_status selects among the following arms: + // NFS4_OK: + // Locr_resok4() *LAYOUTCOMMIT4resok + // default: + // void + Locr_status Nfsstat4 + U interface{} +} + +/* + * LAYOUTGET + */ +type LAYOUTGET4args struct { + Loga_signal_layout_avail bool + Loga_layout_type Layouttype4 + Loga_iomode Layoutiomode4 + Loga_offset Offset4 + Loga_length Length4 + Loga_minlength Length4 + Loga_stateid Stateid4 + Loga_maxcount Count4 +} + +type LAYOUTGET4resok struct { + Logr_return_on_close bool + Logr_stateid Stateid4 + Logr_layout []Layout4 +} + +type LAYOUTGET4res struct { + // The union discriminant Logr_status selects among the following arms: + // NFS4_OK: + // Logr_resok4() *LAYOUTGET4resok + // NFS4ERR_LAYOUTTRYLATER: + // Logr_will_signal_layout_avail() *bool + // default: + // void + Logr_status Nfsstat4 + U interface{} +} + +/* + * LAYOUTRETURN + */ +const LAYOUT4_RET_REC_FILE = 1 + +const LAYOUT4_RET_REC_FSID = 2 + +const LAYOUT4_RET_REC_ALL = 3 + +type Layoutreturn_type4 int32 +const ( + LAYOUTRETURN4_FILE Layoutreturn_type4 = Layoutreturn_type4(LAYOUT4_RET_REC_FILE) + LAYOUTRETURN4_FSID Layoutreturn_type4 = Layoutreturn_type4(LAYOUT4_RET_REC_FSID) + LAYOUTRETURN4_ALL Layoutreturn_type4 = Layoutreturn_type4(LAYOUT4_RET_REC_ALL) +) + +type Layoutreturn_file4 struct { + Lrf_offset Offset4 + Lrf_length Length4 + Lrf_stateid Stateid4 + Lrf_body []byte +} + +type Layoutreturn4 struct { + // The union discriminant Lr_returntype selects among the following arms: + // LAYOUTRETURN4_FILE: + // Lr_layout() *Layoutreturn_file4 + // default: + // void + Lr_returntype Layoutreturn_type4 + U interface{} +} + +type LAYOUTRETURN4args struct { + Lora_reclaim bool + Lora_layout_type Layouttype4 + Lora_iomode Layoutiomode4 + Lora_layoutreturn Layoutreturn4 +} + +type Layoutreturn_stateid struct { + // The union discriminant Lrs_present selects among the following arms: + // true: + // Lrs_stateid() *Stateid4 + // false: + // void + Lrs_present bool + U interface{} +} + +type LAYOUTRETURN4res struct { + // The union discriminant Lorr_status selects among the following arms: + // NFS4_OK: + // Lorr_stateid() *Layoutreturn_stateid + // default: + // void + Lorr_status Nfsstat4 + U interface{} +} + +/* + * SECINFO_NO_NAME + */ +type Secinfo_style4 int32 +const ( + SECINFO_STYLE4_CURRENT_FH Secinfo_style4 = 0 + SECINFO_STYLE4_PARENT Secinfo_style4 = 1 +) + +type SECINFO_NO_NAME4args = Secinfo_style4 + +type SECINFO_NO_NAME4res = SECINFO4res + +/* + * SEQUENCE + */ +type SEQUENCE4args struct { + Sa_sessionid Sessionid4 + Sa_sequenceid Sequenceid4 + Sa_slotid Slotid4 + Sa_highest_slotid Slotid4 + Sa_cachethis bool +} + +const SEQ4_STATUS_CB_PATH_DOWN = 0x00000001 + +const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING = 0x00000002 + +const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED = 0x00000004 + +const SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED = 0x00000008 + +const SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED = 0x00000010 + +const SEQ4_STATUS_ADMIN_STATE_REVOKED = 0x00000020 + +const SEQ4_STATUS_RECALLABLE_STATE_REVOKED = 0x00000040 + +const SEQ4_STATUS_LEASE_MOVED = 0x00000080 + +const SEQ4_STATUS_RESTART_RECLAIM_NEEDED = 0x00000100 + +const SEQ4_STATUS_CB_PATH_DOWN_SESSION = 0x00000200 + +const SEQ4_STATUS_BACKCHANNEL_FAULT = 0x00000400 + +const SEQ4_STATUS_DEVID_CHANGED = 0x00000800 + +const SEQ4_STATUS_DEVID_DELETED = 0x00001000 + +type SEQUENCE4resok struct { + Sr_sessionid Sessionid4 + Sr_sequenceid Sequenceid4 + Sr_slotid Slotid4 + Sr_highest_slotid Slotid4 + Sr_target_highest_slotid Slotid4 + Sr_status_flags Uint32_t +} + +type SEQUENCE4res struct { + // The union discriminant Sr_status selects among the following arms: + // NFS4_OK: + // Sr_resok4() *SEQUENCE4resok + // default: + // void + Sr_status Nfsstat4 + U interface{} +} + +/* + * SET_SSV + */ +type Ssa_digest_input4 struct { + Sdi_seqargs SEQUENCE4args +} + +type SET_SSV4args struct { + Ssa_ssv []byte + Ssa_digest []byte +} + +type Ssr_digest_input4 struct { + Sdi_seqres SEQUENCE4res +} + +type SET_SSV4resok struct { + Ssr_digest []byte +} + +type SET_SSV4res struct { + // The union discriminant Ssr_status selects among the following arms: + // NFS4_OK: + // Ssr_resok4() *SET_SSV4resok + // default: + // void + Ssr_status Nfsstat4 + U interface{} +} + +/* + * TEST_STATEID + */ +type TEST_STATEID4args struct { + Ts_stateids []Stateid4 +} + +type TEST_STATEID4resok struct { + Tsr_status_codes []Nfsstat4 +} + +type TEST_STATEID4res struct { + // The union discriminant Tsr_status selects among the following arms: + // NFS4_OK: + // Tsr_resok4() *TEST_STATEID4resok + // default: + // void + Tsr_status Nfsstat4 + U interface{} +} + +/* + * WANT_DELEGATION + */ +type Deleg_claim4 struct { + // The union discriminant Dc_claim selects among the following arms: + // CLAIM_FH: + // void + // CLAIM_DELEG_PREV_FH: + // void + // CLAIM_PREVIOUS: + // Dc_delegate_type() *Open_delegation_type4 + Dc_claim Open_claim_type4 + U interface{} +} + +type WANT_DELEGATION4args struct { + Wda_want Uint32_t + Wda_claim Deleg_claim4 +} + +type WANT_DELEGATION4res struct { + // The union discriminant Wdr_status selects among the following arms: + // NFS4_OK: + // Wdr_resok4() *Open_delegation4 + // default: + // void + Wdr_status Nfsstat4 + U interface{} +} + +/* + * DESTROY_CLIENTID + */ +type DESTROY_CLIENTID4args struct { + Dca_clientid Clientid4 +} + +type DESTROY_CLIENTID4res struct { + Dcr_status Nfsstat4 +} + +/* + * RECLAIM_COMPLETE + */ +type RECLAIM_COMPLETE4args struct { + Rca_one_fs bool +} + +type RECLAIM_COMPLETE4res struct { + Rcr_status Nfsstat4 +} + +/* + * ILLEGAL: Response for illegal operation numbers + */ +type ILLEGAL4res struct { + Status Nfsstat4 +} + +type Nfs_opnum4 int32 +const ( + OP_ACCESS Nfs_opnum4 = 3 + OP_CLOSE Nfs_opnum4 = 4 + OP_COMMIT Nfs_opnum4 = 5 + OP_CREATE Nfs_opnum4 = 6 + OP_DELEGPURGE Nfs_opnum4 = 7 + OP_DELEGRETURN Nfs_opnum4 = 8 + OP_GETATTR Nfs_opnum4 = 9 + OP_GETFH Nfs_opnum4 = 10 + OP_LINK Nfs_opnum4 = 11 + OP_LOCK Nfs_opnum4 = 12 + OP_LOCKT Nfs_opnum4 = 13 + OP_LOCKU Nfs_opnum4 = 14 + OP_LOOKUP Nfs_opnum4 = 15 + OP_LOOKUPP Nfs_opnum4 = 16 + OP_NVERIFY Nfs_opnum4 = 17 + OP_OPEN Nfs_opnum4 = 18 + OP_OPENATTR Nfs_opnum4 = 19 + OP_OPEN_CONFIRM Nfs_opnum4 = 20 + OP_OPEN_DOWNGRADE Nfs_opnum4 = 21 + OP_PUTFH Nfs_opnum4 = 22 + OP_PUTPUBFH Nfs_opnum4 = 23 + OP_PUTROOTFH Nfs_opnum4 = 24 + OP_READ Nfs_opnum4 = 25 + OP_READDIR Nfs_opnum4 = 26 + OP_READLINK Nfs_opnum4 = 27 + OP_REMOVE Nfs_opnum4 = 28 + OP_RENAME Nfs_opnum4 = 29 + OP_RENEW Nfs_opnum4 = 30 + OP_RESTOREFH Nfs_opnum4 = 31 + OP_SAVEFH Nfs_opnum4 = 32 + OP_SECINFO Nfs_opnum4 = 33 + OP_SETATTR Nfs_opnum4 = 34 + OP_SETCLIENTID Nfs_opnum4 = 35 + OP_SETCLIENTID_CONFIRM Nfs_opnum4 = 36 + OP_VERIFY Nfs_opnum4 = 37 + OP_WRITE Nfs_opnum4 = 38 + OP_RELEASE_LOCKOWNER Nfs_opnum4 = 39 + OP_CREATE_SESSION Nfs_opnum4 = 43 + OP_DESTROY_SESSION Nfs_opnum4 = 44 + OP_FREE_STATEID Nfs_opnum4 = 45 + OP_GET_DIR_DELEGATION Nfs_opnum4 = 46 + OP_GETDEVICEINFO Nfs_opnum4 = 47 + OP_GETDEVICELIST Nfs_opnum4 = 48 + OP_LAYOUTCOMMIT Nfs_opnum4 = 49 + OP_LAYOUTGET Nfs_opnum4 = 50 + OP_LAYOUTRETURN Nfs_opnum4 = 51 + OP_SECINFO_NO_NAME Nfs_opnum4 = 52 + OP_SEQUENCE Nfs_opnum4 = 53 + OP_SET_SSV Nfs_opnum4 = 54 + OP_TEST_STATEID Nfs_opnum4 = 55 + OP_WANT_DELEGATION Nfs_opnum4 = 56 + OP_DESTROY_CLIENTID Nfs_opnum4 = 57 + OP_RECLAIM_COMPLETE Nfs_opnum4 = 58 + OP_ILLEGAL Nfs_opnum4 = 10044 +) + +type Nfs_argop4 struct { + // The union discriminant Argop selects among the following arms: + // OP_ACCESS: + // Opaccess() *ACCESS4args + // OP_CLOSE: + // Opclose() *CLOSE4args + // OP_COMMIT: + // Opcommit() *COMMIT4args + // OP_CREATE: + // Opcreate() *CREATE4args + // OP_DELEGPURGE: + // Opdelegpurge() *DELEGPURGE4args + // OP_DELEGRETURN: + // Opdelegreturn() *DELEGRETURN4args + // OP_GETATTR: + // Opgetattr() *GETATTR4args + // OP_GETFH: + // void + // OP_LINK: + // Oplink() *LINK4args + // OP_LOCK: + // Oplock() *LOCK4args + // OP_LOCKT: + // Oplockt() *LOCKT4args + // OP_LOCKU: + // Oplocku() *LOCKU4args + // OP_LOOKUP: + // Oplookup() *LOOKUP4args + // OP_LOOKUPP: + // void + // OP_NVERIFY: + // Opnverify() *NVERIFY4args + // OP_OPEN: + // Opopen() *OPEN4args + // OP_OPENATTR: + // Opopenattr() *OPENATTR4args + // OP_OPEN_CONFIRM: + // Opopen_confirm() *OPEN_CONFIRM4args + // OP_OPEN_DOWNGRADE: + // Opopen_downgrade() *OPEN_DOWNGRADE4args + // OP_PUTFH: + // Opputfh() *PUTFH4args + // OP_PUTPUBFH: + // void + // OP_PUTROOTFH: + // void + // OP_READ: + // Opread() *READ4args + // OP_READDIR: + // Opreaddir() *READDIR4args + // OP_READLINK: + // void + // OP_REMOVE: + // Opremove() *REMOVE4args + // OP_RENAME: + // Oprename() *RENAME4args + // OP_RENEW: + // Oprenew() *RENEW4args + // OP_RESTOREFH: + // void + // OP_SAVEFH: + // void + // OP_SECINFO: + // Opsecinfo() *SECINFO4args + // OP_SETATTR: + // Opsetattr() *SETATTR4args + // OP_SETCLIENTID: + // Opsetclientid() *SETCLIENTID4args + // OP_SETCLIENTID_CONFIRM: + // Opsetclientid_confirm() *SETCLIENTID_CONFIRM4args + // OP_VERIFY: + // Opverify() *VERIFY4args + // OP_WRITE: + // Opwrite() *WRITE4args + // OP_RELEASE_LOCKOWNER: + // Oprelease_lockowner() *RELEASE_LOCKOWNER4args + // OP_CREATE_SESSION: + // Opcreatesession() *CREATE_SESSION4args + // OP_DESTROY_SESSION: + // Opdestroysession() *DESTROY_SESSION4args + // OP_FREE_STATEID: + // Opfreestateid() *FREE_STATEID4args + // OP_GET_DIR_DELEGATION: + // Opgetdirdelegation() *GET_DIR_DELEGATION4args + // OP_GETDEVICEINFO: + // Opgetdeviceinfo() *GETDEVICEINFO4args + // OP_GETDEVICELIST: + // Opgetdevicelist() *GETDEVICELIST4args + // OP_LAYOUTCOMMIT: + // Oplayoutcommit() *LAYOUTCOMMIT4args + // OP_LAYOUTGET: + // Oplayoutget() *LAYOUTGET4args + // OP_LAYOUTRETURN: + // Oplayoutreturn() *LAYOUTRETURN4args + // OP_SECINFO_NO_NAME: + // Opsecinfononame() *SECINFO_NO_NAME4args + // OP_SEQUENCE: + // Opsequence() *SEQUENCE4args + // OP_SET_SSV: + // Opsetssv() *SET_SSV4args + // OP_TEST_STATEID: + // Opteststateid() *TEST_STATEID4args + // OP_WANT_DELEGATION: + // Opwantdelegation() *WANT_DELEGATION4args + // OP_DESTROY_CLIENTID: + // Opdestroyclientid() *DESTROY_CLIENTID4args + // OP_RECLAIM_COMPLETE: + // Opreclaimcomplete() *RECLAIM_COMPLETE4args + // OP_ILLEGAL: + // void + Argop Nfs_opnum4 + U interface{} +} + +type Nfs_resop4 struct { + // The union discriminant Resop selects among the following arms: + // OP_ACCESS: + // Opaccess() *ACCESS4res + // OP_CLOSE: + // Opclose() *CLOSE4res + // OP_COMMIT: + // Opcommit() *COMMIT4res + // OP_CREATE: + // Opcreate() *CREATE4res + // OP_DELEGPURGE: + // Opdelegpurge() *DELEGPURGE4res + // OP_DELEGRETURN: + // Opdelegreturn() *DELEGRETURN4res + // OP_GETATTR: + // Opgetattr() *GETATTR4res + // OP_GETFH: + // Opgetfh() *GETFH4res + // OP_LINK: + // Oplink() *LINK4res + // OP_LOCK: + // Oplock() *LOCK4res + // OP_LOCKT: + // Oplockt() *LOCKT4res + // OP_LOCKU: + // Oplocku() *LOCKU4res + // OP_LOOKUP: + // Oplookup() *LOOKUP4res + // OP_LOOKUPP: + // Oplookupp() *LOOKUPP4res + // OP_NVERIFY: + // Opnverify() *NVERIFY4res + // OP_OPEN: + // Opopen() *OPEN4res + // OP_OPENATTR: + // Opopenattr() *OPENATTR4res + // OP_OPEN_CONFIRM: + // Opopen_confirm() *OPEN_CONFIRM4res + // OP_OPEN_DOWNGRADE: + // Opopen_downgrade() *OPEN_DOWNGRADE4res + // OP_PUTFH: + // Opputfh() *PUTFH4res + // OP_PUTPUBFH: + // Opputpubfh() *PUTPUBFH4res + // OP_PUTROOTFH: + // Opputrootfh() *PUTROOTFH4res + // OP_READ: + // Opread() *READ4res + // OP_READDIR: + // Opreaddir() *READDIR4res + // OP_READLINK: + // Opreadlink() *READLINK4res + // OP_REMOVE: + // Opremove() *REMOVE4res + // OP_RENAME: + // Oprename() *RENAME4res + // OP_RENEW: + // Oprenew() *RENEW4res + // OP_RESTOREFH: + // Oprestorefh() *RESTOREFH4res + // OP_SAVEFH: + // Opsavefh() *SAVEFH4res + // OP_SECINFO: + // Opsecinfo() *SECINFO4res + // OP_SETATTR: + // Opsetattr() *SETATTR4res + // OP_SETCLIENTID: + // Opsetclientid() *SETCLIENTID4res + // OP_SETCLIENTID_CONFIRM: + // Opsetclientid_confirm() *SETCLIENTID_CONFIRM4res + // OP_VERIFY: + // Opverify() *VERIFY4res + // OP_WRITE: + // Opwrite() *WRITE4res + // OP_RELEASE_LOCKOWNER: + // Oprelease_lockowner() *RELEASE_LOCKOWNER4res + // OP_CREATE_SESSION: + // Opcreatesession() *CREATE_SESSION4res + // OP_DESTROY_SESSION: + // Opdestroysession() *DESTROY_SESSION4res + // OP_FREE_STATEID: + // Opfreestateid() *FREE_STATEID4res + // OP_GET_DIR_DELEGATION: + // Opgetdirdelegation() *GET_DIR_DELEGATION4res + // OP_GETDEVICEINFO: + // Opgetdeviceinfo() *GETDEVICEINFO4res + // OP_GETDEVICELIST: + // Opgetdevicelist() *GETDEVICELIST4res + // OP_LAYOUTCOMMIT: + // Oplayoutcommit() *LAYOUTCOMMIT4res + // OP_LAYOUTGET: + // Oplayoutget() *LAYOUTGET4res + // OP_LAYOUTRETURN: + // Oplayoutreturn() *LAYOUTRETURN4res + // OP_SECINFO_NO_NAME: + // Opsecinfononame() *SECINFO_NO_NAME4res + // OP_SEQUENCE: + // Opsequence() *SEQUENCE4res + // OP_SET_SSV: + // Opsetssv() *SET_SSV4res + // OP_TEST_STATEID: + // Opteststateid() *TEST_STATEID4res + // OP_WANT_DELEGATION: + // Opwantdelegation() *WANT_DELEGATION4res + // OP_DESTROY_CLIENTID: + // Opdestroyclientid() *DESTROY_CLIENTID4res + // OP_RECLAIM_COMPLETE: + // Opreclaimcomplete() *RECLAIM_COMPLETE4res + // OP_ILLEGAL: + // Opillegal() *ILLEGAL4res + Resop Nfs_opnum4 + U interface{} +} + +type COMPOUND4args struct { + Tag Utf8str_cs + Minorversion Uint32_t + Argarray []Nfs_argop4 +} + +type COMPOUND4res struct { + Status Nfsstat4 + Tag Utf8str_cs + Resarray []Nfs_resop4 +} + +type NFS_V4 interface { + NFSPROC4_NULL() + NFSPROC4_COMPOUND(COMPOUND4args) COMPOUND4res +} + +/* + * CB_GETATTR: Get Current Attributes + */ +type CB_GETATTR4args struct { + Fh Nfs_fh4 + Attr_request Bitmap4 +} + +type CB_GETATTR4resok struct { + Obj_attributes Fattr4 +} + +type CB_GETATTR4res struct { + // The union discriminant Status selects among the following arms: + // NFS4_OK: + // Resok4() *CB_GETATTR4resok + // default: + // void + Status Nfsstat4 + U interface{} +} + +/* + * CB_RECALL: Recall an Open Delegation + */ +type CB_RECALL4args struct { + Stateid Stateid4 + Truncate bool + Fh Nfs_fh4 +} + +type CB_RECALL4res struct { + Status Nfsstat4 +} + +/* + * CB_ILLEGAL: Response for illegal operation numbers + */ +type CB_ILLEGAL4res struct { + Status Nfsstat4 +} + +/* + * Various definitions for CB_COMPOUND + */ +type Nfs_cb_opnum4 int32 +const ( + OP_CB_GETATTR Nfs_cb_opnum4 = 3 + OP_CB_RECALL Nfs_cb_opnum4 = 4 + OP_CB_ILLEGAL Nfs_cb_opnum4 = 10044 +) + +type Nfs_cb_argop4 struct { + // The union discriminant Argop selects among the following arms: + // OP_CB_GETATTR: + // Opcbgetattr() *CB_GETATTR4args + // OP_CB_RECALL: + // Opcbrecall() *CB_RECALL4args + // OP_CB_ILLEGAL: + // void + Argop uint32 + U interface{} +} + +type Nfs_cb_resop4 struct { + // The union discriminant Resop selects among the following arms: + // OP_CB_GETATTR: + // Opcbgetattr() *CB_GETATTR4res + // OP_CB_RECALL: + // Opcbrecall() *CB_RECALL4res + // OP_CB_ILLEGAL: + // Opcbillegal() *CB_ILLEGAL4res + Resop uint32 + U interface{} +} + +type CB_COMPOUND4args struct { + Tag Utf8str_cs + Minorversion Uint32_t + Callback_ident Uint32_t + Argarray []Nfs_cb_argop4 +} + +type CB_COMPOUND4res struct { + Status Nfsstat4 + Tag Utf8str_cs + Resarray []Nfs_cb_resop4 +} + +type NFS_CB interface { + CB_NULL() + CB_COMPOUND(CB_COMPOUND4args) CB_COMPOUND4res +} + +// +// Helper types and generated marshaling functions +// + +var _XdrNames_Nfs_ftype4 = map[int32]string{ + int32(NF4REG): "NF4REG", + int32(NF4DIR): "NF4DIR", + int32(NF4BLK): "NF4BLK", + int32(NF4CHR): "NF4CHR", + int32(NF4LNK): "NF4LNK", + int32(NF4SOCK): "NF4SOCK", + int32(NF4FIFO): "NF4FIFO", + int32(NF4ATTRDIR): "NF4ATTRDIR", + int32(NF4NAMEDATTR): "NF4NAMEDATTR", +} +var _XdrValues_Nfs_ftype4 = map[string]int32{ + "NF4REG": int32(NF4REG), + "NF4DIR": int32(NF4DIR), + "NF4BLK": int32(NF4BLK), + "NF4CHR": int32(NF4CHR), + "NF4LNK": int32(NF4LNK), + "NF4SOCK": int32(NF4SOCK), + "NF4FIFO": int32(NF4FIFO), + "NF4ATTRDIR": int32(NF4ATTRDIR), + "NF4NAMEDATTR": int32(NF4NAMEDATTR), +} +func (Nfs_ftype4) XdrEnumNames() map[int32]string { + return _XdrNames_Nfs_ftype4 +} +func (v Nfs_ftype4) String() string { + if s, ok := _XdrNames_Nfs_ftype4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Nfs_ftype4#%d", v) +} +func (v *Nfs_ftype4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Nfs_ftype4[stok]; ok { + *v = Nfs_ftype4(val) + return nil + } else if stok == "Nfs_ftype4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Nfs_ftype4.", stok)) + } +} +func (v Nfs_ftype4) GetU32() uint32 { return uint32(v) } +func (v *Nfs_ftype4) SetU32(n uint32) { *v = Nfs_ftype4(n) } +func (v *Nfs_ftype4) XdrPointer() interface{} { return v } +func (Nfs_ftype4) XdrTypeName() string { return "Nfs_ftype4" } +func (v Nfs_ftype4) XdrValue() interface{} { return v } +func (v *Nfs_ftype4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Nfs_ftype4 = *Nfs_ftype4 +func XDR_Nfs_ftype4(v *Nfs_ftype4) *Nfs_ftype4 { return v } +func (v *Nfs_ftype4) XdrInitialize() { + switch Nfs_ftype4(0) { + case NF4REG, NF4DIR, NF4BLK, NF4CHR, NF4LNK, NF4SOCK, NF4FIFO, NF4ATTRDIR, NF4NAMEDATTR: + default: + if *v == Nfs_ftype4(0) { *v = NF4REG } + } +} +var _XdrNames_Nfsstat4 = map[int32]string{ + int32(NFS4_OK): "NFS4_OK", + int32(NFS4ERR_PERM): "NFS4ERR_PERM", + int32(NFS4ERR_NOENT): "NFS4ERR_NOENT", + int32(NFS4ERR_IO): "NFS4ERR_IO", + int32(NFS4ERR_NXIO): "NFS4ERR_NXIO", + int32(NFS4ERR_ACCESS): "NFS4ERR_ACCESS", + int32(NFS4ERR_EXIST): "NFS4ERR_EXIST", + int32(NFS4ERR_XDEV): "NFS4ERR_XDEV", + int32(NFS4ERR_NOTDIR): "NFS4ERR_NOTDIR", + int32(NFS4ERR_ISDIR): "NFS4ERR_ISDIR", + int32(NFS4ERR_INVAL): "NFS4ERR_INVAL", + int32(NFS4ERR_FBIG): "NFS4ERR_FBIG", + int32(NFS4ERR_NOSPC): "NFS4ERR_NOSPC", + int32(NFS4ERR_ROFS): "NFS4ERR_ROFS", + int32(NFS4ERR_MLINK): "NFS4ERR_MLINK", + int32(NFS4ERR_NAMETOOLONG): "NFS4ERR_NAMETOOLONG", + int32(NFS4ERR_NOTEMPTY): "NFS4ERR_NOTEMPTY", + int32(NFS4ERR_DQUOT): "NFS4ERR_DQUOT", + int32(NFS4ERR_STALE): "NFS4ERR_STALE", + int32(NFS4ERR_BADHANDLE): "NFS4ERR_BADHANDLE", + int32(NFS4ERR_BAD_COOKIE): "NFS4ERR_BAD_COOKIE", + int32(NFS4ERR_NOTSUPP): "NFS4ERR_NOTSUPP", + int32(NFS4ERR_TOOSMALL): "NFS4ERR_TOOSMALL", + int32(NFS4ERR_SERVERFAULT): "NFS4ERR_SERVERFAULT", + int32(NFS4ERR_BADTYPE): "NFS4ERR_BADTYPE", + int32(NFS4ERR_DELAY): "NFS4ERR_DELAY", + int32(NFS4ERR_SAME): "NFS4ERR_SAME", + int32(NFS4ERR_DENIED): "NFS4ERR_DENIED", + int32(NFS4ERR_EXPIRED): "NFS4ERR_EXPIRED", + int32(NFS4ERR_LOCKED): "NFS4ERR_LOCKED", + int32(NFS4ERR_GRACE): "NFS4ERR_GRACE", + int32(NFS4ERR_FHEXPIRED): "NFS4ERR_FHEXPIRED", + int32(NFS4ERR_SHARE_DENIED): "NFS4ERR_SHARE_DENIED", + int32(NFS4ERR_WRONGSEC): "NFS4ERR_WRONGSEC", + int32(NFS4ERR_CLID_INUSE): "NFS4ERR_CLID_INUSE", + int32(NFS4ERR_RESOURCE): "NFS4ERR_RESOURCE", + int32(NFS4ERR_MOVED): "NFS4ERR_MOVED", + int32(NFS4ERR_NOFILEHANDLE): "NFS4ERR_NOFILEHANDLE", + int32(NFS4ERR_MINOR_VERS_MISMATCH): "NFS4ERR_MINOR_VERS_MISMATCH", + int32(NFS4ERR_STALE_CLIENTID): "NFS4ERR_STALE_CLIENTID", + int32(NFS4ERR_STALE_STATEID): "NFS4ERR_STALE_STATEID", + int32(NFS4ERR_OLD_STATEID): "NFS4ERR_OLD_STATEID", + int32(NFS4ERR_BAD_STATEID): "NFS4ERR_BAD_STATEID", + int32(NFS4ERR_BAD_SEQID): "NFS4ERR_BAD_SEQID", + int32(NFS4ERR_NOT_SAME): "NFS4ERR_NOT_SAME", + int32(NFS4ERR_LOCK_RANGE): "NFS4ERR_LOCK_RANGE", + int32(NFS4ERR_SYMLINK): "NFS4ERR_SYMLINK", + int32(NFS4ERR_RESTOREFH): "NFS4ERR_RESTOREFH", + int32(NFS4ERR_LEASE_MOVED): "NFS4ERR_LEASE_MOVED", + int32(NFS4ERR_ATTRNOTSUPP): "NFS4ERR_ATTRNOTSUPP", + int32(NFS4ERR_NO_GRACE): "NFS4ERR_NO_GRACE", + int32(NFS4ERR_RECLAIM_BAD): "NFS4ERR_RECLAIM_BAD", + int32(NFS4ERR_RECLAIM_CONFLICT): "NFS4ERR_RECLAIM_CONFLICT", + int32(NFS4ERR_BADXDR): "NFS4ERR_BADXDR", + int32(NFS4ERR_LOCKS_HELD): "NFS4ERR_LOCKS_HELD", + int32(NFS4ERR_OPENMODE): "NFS4ERR_OPENMODE", + int32(NFS4ERR_BADOWNER): "NFS4ERR_BADOWNER", + int32(NFS4ERR_BADCHAR): "NFS4ERR_BADCHAR", + int32(NFS4ERR_BADNAME): "NFS4ERR_BADNAME", + int32(NFS4ERR_BAD_RANGE): "NFS4ERR_BAD_RANGE", + int32(NFS4ERR_LOCK_NOTSUPP): "NFS4ERR_LOCK_NOTSUPP", + int32(NFS4ERR_OP_ILLEGAL): "NFS4ERR_OP_ILLEGAL", + int32(NFS4ERR_DEADLOCK): "NFS4ERR_DEADLOCK", + int32(NFS4ERR_FILE_OPEN): "NFS4ERR_FILE_OPEN", + int32(NFS4ERR_ADMIN_REVOKED): "NFS4ERR_ADMIN_REVOKED", + int32(NFS4ERR_CB_PATH_DOWN): "NFS4ERR_CB_PATH_DOWN", + int32(NFS4ERR_BADIOMODE): "NFS4ERR_BADIOMODE", + int32(NFS4ERR_BADLAYOUT): "NFS4ERR_BADLAYOUT", + int32(NFS4ERR_BAD_SESSION_DIGEST): "NFS4ERR_BAD_SESSION_DIGEST", + int32(NFS4ERR_BADSESSION): "NFS4ERR_BADSESSION", + int32(NFS4ERR_BADSLOT): "NFS4ERR_BADSLOT", + int32(NFS4ERR_COMPLETE_ALREADY): "NFS4ERR_COMPLETE_ALREADY", + int32(NFS4ERR_CONN_NOT_BOUND_TO_SESSION): "NFS4ERR_CONN_NOT_BOUND_TO_SESSION", + int32(NFS4ERR_DELEG_ALREADY_WANTED): "NFS4ERR_DELEG_ALREADY_WANTED", + int32(NFS4ERR_BACK_CHAN_BUSY): "NFS4ERR_BACK_CHAN_BUSY", + int32(NFS4ERR_LAYOUTTRYLATER): "NFS4ERR_LAYOUTTRYLATER", + int32(NFS4ERR_LAYOUTUNAVAILABLE): "NFS4ERR_LAYOUTUNAVAILABLE", + int32(NFS4ERR_NOMATCHING_LAYOUT): "NFS4ERR_NOMATCHING_LAYOUT", + int32(NFS4ERR_RECALLCONFLICT): "NFS4ERR_RECALLCONFLICT", +} +var _XdrValues_Nfsstat4 = map[string]int32{ + "NFS4_OK": int32(NFS4_OK), + "NFS4ERR_PERM": int32(NFS4ERR_PERM), + "NFS4ERR_NOENT": int32(NFS4ERR_NOENT), + "NFS4ERR_IO": int32(NFS4ERR_IO), + "NFS4ERR_NXIO": int32(NFS4ERR_NXIO), + "NFS4ERR_ACCESS": int32(NFS4ERR_ACCESS), + "NFS4ERR_EXIST": int32(NFS4ERR_EXIST), + "NFS4ERR_XDEV": int32(NFS4ERR_XDEV), + "NFS4ERR_NOTDIR": int32(NFS4ERR_NOTDIR), + "NFS4ERR_ISDIR": int32(NFS4ERR_ISDIR), + "NFS4ERR_INVAL": int32(NFS4ERR_INVAL), + "NFS4ERR_FBIG": int32(NFS4ERR_FBIG), + "NFS4ERR_NOSPC": int32(NFS4ERR_NOSPC), + "NFS4ERR_ROFS": int32(NFS4ERR_ROFS), + "NFS4ERR_MLINK": int32(NFS4ERR_MLINK), + "NFS4ERR_NAMETOOLONG": int32(NFS4ERR_NAMETOOLONG), + "NFS4ERR_NOTEMPTY": int32(NFS4ERR_NOTEMPTY), + "NFS4ERR_DQUOT": int32(NFS4ERR_DQUOT), + "NFS4ERR_STALE": int32(NFS4ERR_STALE), + "NFS4ERR_BADHANDLE": int32(NFS4ERR_BADHANDLE), + "NFS4ERR_BAD_COOKIE": int32(NFS4ERR_BAD_COOKIE), + "NFS4ERR_NOTSUPP": int32(NFS4ERR_NOTSUPP), + "NFS4ERR_TOOSMALL": int32(NFS4ERR_TOOSMALL), + "NFS4ERR_SERVERFAULT": int32(NFS4ERR_SERVERFAULT), + "NFS4ERR_BADTYPE": int32(NFS4ERR_BADTYPE), + "NFS4ERR_DELAY": int32(NFS4ERR_DELAY), + "NFS4ERR_SAME": int32(NFS4ERR_SAME), + "NFS4ERR_DENIED": int32(NFS4ERR_DENIED), + "NFS4ERR_EXPIRED": int32(NFS4ERR_EXPIRED), + "NFS4ERR_LOCKED": int32(NFS4ERR_LOCKED), + "NFS4ERR_GRACE": int32(NFS4ERR_GRACE), + "NFS4ERR_FHEXPIRED": int32(NFS4ERR_FHEXPIRED), + "NFS4ERR_SHARE_DENIED": int32(NFS4ERR_SHARE_DENIED), + "NFS4ERR_WRONGSEC": int32(NFS4ERR_WRONGSEC), + "NFS4ERR_CLID_INUSE": int32(NFS4ERR_CLID_INUSE), + "NFS4ERR_RESOURCE": int32(NFS4ERR_RESOURCE), + "NFS4ERR_MOVED": int32(NFS4ERR_MOVED), + "NFS4ERR_NOFILEHANDLE": int32(NFS4ERR_NOFILEHANDLE), + "NFS4ERR_MINOR_VERS_MISMATCH": int32(NFS4ERR_MINOR_VERS_MISMATCH), + "NFS4ERR_STALE_CLIENTID": int32(NFS4ERR_STALE_CLIENTID), + "NFS4ERR_STALE_STATEID": int32(NFS4ERR_STALE_STATEID), + "NFS4ERR_OLD_STATEID": int32(NFS4ERR_OLD_STATEID), + "NFS4ERR_BAD_STATEID": int32(NFS4ERR_BAD_STATEID), + "NFS4ERR_BAD_SEQID": int32(NFS4ERR_BAD_SEQID), + "NFS4ERR_NOT_SAME": int32(NFS4ERR_NOT_SAME), + "NFS4ERR_LOCK_RANGE": int32(NFS4ERR_LOCK_RANGE), + "NFS4ERR_SYMLINK": int32(NFS4ERR_SYMLINK), + "NFS4ERR_RESTOREFH": int32(NFS4ERR_RESTOREFH), + "NFS4ERR_LEASE_MOVED": int32(NFS4ERR_LEASE_MOVED), + "NFS4ERR_ATTRNOTSUPP": int32(NFS4ERR_ATTRNOTSUPP), + "NFS4ERR_NO_GRACE": int32(NFS4ERR_NO_GRACE), + "NFS4ERR_RECLAIM_BAD": int32(NFS4ERR_RECLAIM_BAD), + "NFS4ERR_RECLAIM_CONFLICT": int32(NFS4ERR_RECLAIM_CONFLICT), + "NFS4ERR_BADXDR": int32(NFS4ERR_BADXDR), + "NFS4ERR_LOCKS_HELD": int32(NFS4ERR_LOCKS_HELD), + "NFS4ERR_OPENMODE": int32(NFS4ERR_OPENMODE), + "NFS4ERR_BADOWNER": int32(NFS4ERR_BADOWNER), + "NFS4ERR_BADCHAR": int32(NFS4ERR_BADCHAR), + "NFS4ERR_BADNAME": int32(NFS4ERR_BADNAME), + "NFS4ERR_BAD_RANGE": int32(NFS4ERR_BAD_RANGE), + "NFS4ERR_LOCK_NOTSUPP": int32(NFS4ERR_LOCK_NOTSUPP), + "NFS4ERR_OP_ILLEGAL": int32(NFS4ERR_OP_ILLEGAL), + "NFS4ERR_DEADLOCK": int32(NFS4ERR_DEADLOCK), + "NFS4ERR_FILE_OPEN": int32(NFS4ERR_FILE_OPEN), + "NFS4ERR_ADMIN_REVOKED": int32(NFS4ERR_ADMIN_REVOKED), + "NFS4ERR_CB_PATH_DOWN": int32(NFS4ERR_CB_PATH_DOWN), + "NFS4ERR_BADIOMODE": int32(NFS4ERR_BADIOMODE), + "NFS4ERR_BADLAYOUT": int32(NFS4ERR_BADLAYOUT), + "NFS4ERR_BAD_SESSION_DIGEST": int32(NFS4ERR_BAD_SESSION_DIGEST), + "NFS4ERR_BADSESSION": int32(NFS4ERR_BADSESSION), + "NFS4ERR_BADSLOT": int32(NFS4ERR_BADSLOT), + "NFS4ERR_COMPLETE_ALREADY": int32(NFS4ERR_COMPLETE_ALREADY), + "NFS4ERR_CONN_NOT_BOUND_TO_SESSION": int32(NFS4ERR_CONN_NOT_BOUND_TO_SESSION), + "NFS4ERR_DELEG_ALREADY_WANTED": int32(NFS4ERR_DELEG_ALREADY_WANTED), + "NFS4ERR_BACK_CHAN_BUSY": int32(NFS4ERR_BACK_CHAN_BUSY), + "NFS4ERR_LAYOUTTRYLATER": int32(NFS4ERR_LAYOUTTRYLATER), + "NFS4ERR_LAYOUTUNAVAILABLE": int32(NFS4ERR_LAYOUTUNAVAILABLE), + "NFS4ERR_NOMATCHING_LAYOUT": int32(NFS4ERR_NOMATCHING_LAYOUT), + "NFS4ERR_RECALLCONFLICT": int32(NFS4ERR_RECALLCONFLICT), +} +func (Nfsstat4) XdrEnumNames() map[int32]string { + return _XdrNames_Nfsstat4 +} +func (v Nfsstat4) String() string { + if s, ok := _XdrNames_Nfsstat4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Nfsstat4#%d", v) +} +func (v *Nfsstat4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Nfsstat4[stok]; ok { + *v = Nfsstat4(val) + return nil + } else if stok == "Nfsstat4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Nfsstat4.", stok)) + } +} +func (v Nfsstat4) GetU32() uint32 { return uint32(v) } +func (v *Nfsstat4) SetU32(n uint32) { *v = Nfsstat4(n) } +func (v *Nfsstat4) XdrPointer() interface{} { return v } +func (Nfsstat4) XdrTypeName() string { return "Nfsstat4" } +func (v Nfsstat4) XdrValue() interface{} { return v } +func (v *Nfsstat4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Nfsstat4 = *Nfsstat4 +func XDR_Nfsstat4(v *Nfsstat4) *Nfsstat4 { return v } +type _XdrVec_unbounded_Uint32_t []Uint32_t +func (_XdrVec_unbounded_Uint32_t) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Uint32_t) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Uint32_t length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Uint32_t length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Uint32_t) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Uint32_t) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Uint32_t, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Uint32_t) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Uint32_t(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Uint32_t) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Uint32_t) XdrTypeName() string { return "Uint32_t<>" } +func (v *_XdrVec_unbounded_Uint32_t) XdrPointer() interface{} { return (*[]Uint32_t)(v) } +func (v _XdrVec_unbounded_Uint32_t) XdrValue() interface{} { return ([]Uint32_t)(v) } +func (v *_XdrVec_unbounded_Uint32_t) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Bitmap4 struct { + *_XdrVec_unbounded_Uint32_t +} +func XDR_Bitmap4(v *Bitmap4) XdrType_Bitmap4 { + return XdrType_Bitmap4{(*_XdrVec_unbounded_Uint32_t)(v)} +} +func (XdrType_Bitmap4) XdrTypeName() string { return "Bitmap4" } +func (v XdrType_Bitmap4) XdrUnwrap() XdrType { return v._XdrVec_unbounded_Uint32_t } +type XdrType_Offset4 struct { + XdrType_Uint64_t +} +func XDR_Offset4(v *Offset4) *XdrType_Offset4 { + return &XdrType_Offset4{XDR_Uint64_t(v)} +} +func (XdrType_Offset4) XdrTypeName() string { return "Offset4" } +func (v XdrType_Offset4) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Count4 struct { + XdrType_Uint32_t +} +func XDR_Count4(v *Count4) *XdrType_Count4 { + return &XdrType_Count4{XDR_Uint32_t(v)} +} +func (XdrType_Count4) XdrTypeName() string { return "Count4" } +func (v XdrType_Count4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Length4 struct { + XdrType_Uint64_t +} +func XDR_Length4(v *Length4) *XdrType_Length4 { + return &XdrType_Length4{XDR_Uint64_t(v)} +} +func (XdrType_Length4) XdrTypeName() string { return "Length4" } +func (v XdrType_Length4) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Clientid4 struct { + XdrType_Uint64_t +} +func XDR_Clientid4(v *Clientid4) *XdrType_Clientid4 { + return &XdrType_Clientid4{XDR_Uint64_t(v)} +} +func (XdrType_Clientid4) XdrTypeName() string { return "Clientid4" } +func (v XdrType_Clientid4) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Sequenceid4 struct { + XdrType_Uint32_t +} +func XDR_Sequenceid4(v *Sequenceid4) *XdrType_Sequenceid4 { + return &XdrType_Sequenceid4{XDR_Uint32_t(v)} +} +func (XdrType_Sequenceid4) XdrTypeName() string { return "Sequenceid4" } +func (v XdrType_Sequenceid4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Seqid4 struct { + XdrType_Uint32_t +} +func XDR_Seqid4(v *Seqid4) *XdrType_Seqid4 { + return &XdrType_Seqid4{XDR_Uint32_t(v)} +} +func (XdrType_Seqid4) XdrTypeName() string { return "Seqid4" } +func (v XdrType_Seqid4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Slotid4 struct { + XdrType_Uint32_t +} +func XDR_Slotid4(v *Slotid4) *XdrType_Slotid4 { + return &XdrType_Slotid4{XDR_Uint32_t(v)} +} +func (XdrType_Slotid4) XdrTypeName() string { return "Slotid4" } +func (v XdrType_Slotid4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Utf8string struct { + XdrVecOpaque +} +func XDR_Utf8string(v *Utf8string) XdrType_Utf8string { + return XdrType_Utf8string{XdrVecOpaque{v, 0xffffffff}} +} +func (XdrType_Utf8string) XdrTypeName() string { return "Utf8string" } +func (v XdrType_Utf8string) XdrUnwrap() XdrType { return v.XdrVecOpaque } +type XdrType_Utf8str_cis struct { + XdrType_Utf8string +} +func XDR_Utf8str_cis(v *Utf8str_cis) XdrType_Utf8str_cis { + return XdrType_Utf8str_cis{XDR_Utf8string(v)} +} +func (XdrType_Utf8str_cis) XdrTypeName() string { return "Utf8str_cis" } +func (v XdrType_Utf8str_cis) XdrUnwrap() XdrType { return v.XdrType_Utf8string } +type XdrType_Utf8str_cs struct { + XdrType_Utf8string +} +func XDR_Utf8str_cs(v *Utf8str_cs) XdrType_Utf8str_cs { + return XdrType_Utf8str_cs{XDR_Utf8string(v)} +} +func (XdrType_Utf8str_cs) XdrTypeName() string { return "Utf8str_cs" } +func (v XdrType_Utf8str_cs) XdrUnwrap() XdrType { return v.XdrType_Utf8string } +type XdrType_Utf8str_mixed struct { + XdrType_Utf8string +} +func XDR_Utf8str_mixed(v *Utf8str_mixed) XdrType_Utf8str_mixed { + return XdrType_Utf8str_mixed{XDR_Utf8string(v)} +} +func (XdrType_Utf8str_mixed) XdrTypeName() string { return "Utf8str_mixed" } +func (v XdrType_Utf8str_mixed) XdrUnwrap() XdrType { return v.XdrType_Utf8string } +type XdrType_Component4 struct { + XdrType_Utf8str_cs +} +func XDR_Component4(v *Component4) XdrType_Component4 { + return XdrType_Component4{XDR_Utf8str_cs(v)} +} +func (XdrType_Component4) XdrTypeName() string { return "Component4" } +func (v XdrType_Component4) XdrUnwrap() XdrType { return v.XdrType_Utf8str_cs } +type _XdrVec_unbounded_Component4 []Component4 +func (_XdrVec_unbounded_Component4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Component4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Component4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Component4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Component4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Component4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Component4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Component4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Component4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Component4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Component4) XdrTypeName() string { return "Component4<>" } +func (v *_XdrVec_unbounded_Component4) XdrPointer() interface{} { return (*[]Component4)(v) } +func (v _XdrVec_unbounded_Component4) XdrValue() interface{} { return ([]Component4)(v) } +func (v *_XdrVec_unbounded_Component4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Pathname4 struct { + *_XdrVec_unbounded_Component4 +} +func XDR_Pathname4(v *Pathname4) XdrType_Pathname4 { + return XdrType_Pathname4{(*_XdrVec_unbounded_Component4)(v)} +} +func (XdrType_Pathname4) XdrTypeName() string { return "Pathname4" } +func (v XdrType_Pathname4) XdrUnwrap() XdrType { return v._XdrVec_unbounded_Component4 } +type XdrType_Nfs_lockid4 struct { + XdrType_Uint64_t +} +func XDR_Nfs_lockid4(v *Nfs_lockid4) XdrType_Nfs_lockid4 { + return XdrType_Nfs_lockid4{XDR_Uint64_t(v)} +} +func (XdrType_Nfs_lockid4) XdrTypeName() string { return "Nfs_lockid4" } +func (v XdrType_Nfs_lockid4) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Nfs_cookie4 struct { + XdrType_Uint64_t +} +func XDR_Nfs_cookie4(v *Nfs_cookie4) *XdrType_Nfs_cookie4 { + return &XdrType_Nfs_cookie4{XDR_Uint64_t(v)} +} +func (XdrType_Nfs_cookie4) XdrTypeName() string { return "Nfs_cookie4" } +func (v XdrType_Nfs_cookie4) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Linktext4 struct { + XdrType_Utf8str_cs +} +func XDR_Linktext4(v *Linktext4) XdrType_Linktext4 { + return XdrType_Linktext4{XDR_Utf8str_cs(v)} +} +func (XdrType_Linktext4) XdrTypeName() string { return "Linktext4" } +func (v XdrType_Linktext4) XdrUnwrap() XdrType { return v.XdrType_Utf8str_cs } +type XdrType_Sec_oid4 struct { + XdrVecOpaque +} +func XDR_Sec_oid4(v *Sec_oid4) XdrType_Sec_oid4 { + return XdrType_Sec_oid4{XdrVecOpaque{v, 0xffffffff}} +} +func (XdrType_Sec_oid4) XdrTypeName() string { return "Sec_oid4" } +func (v XdrType_Sec_oid4) XdrUnwrap() XdrType { return v.XdrVecOpaque } +type XdrType_Qop4 struct { + XdrType_Uint32_t +} +func XDR_Qop4(v *Qop4) *XdrType_Qop4 { + return &XdrType_Qop4{XDR_Uint32_t(v)} +} +func (XdrType_Qop4) XdrTypeName() string { return "Qop4" } +func (v XdrType_Qop4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Mode4 struct { + XdrType_Uint32_t +} +func XDR_Mode4(v *Mode4) XdrType_Mode4 { + return XdrType_Mode4{XDR_Uint32_t(v)} +} +func (XdrType_Mode4) XdrTypeName() string { return "Mode4" } +func (v XdrType_Mode4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Changeid4 struct { + XdrType_Uint64_t +} +func XDR_Changeid4(v *Changeid4) *XdrType_Changeid4 { + return &XdrType_Changeid4{XDR_Uint64_t(v)} +} +func (XdrType_Changeid4) XdrTypeName() string { return "Changeid4" } +func (v XdrType_Changeid4) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type _XdrArray_8_opaque [8]byte +func (v *_XdrArray_8_opaque) GetByteSlice() []byte { return v[:] } +func (v *_XdrArray_8_opaque) XdrTypeName() string { return "opaque[]" } +func (v *_XdrArray_8_opaque) XdrValue() interface{} { return v[:] } +func (v *_XdrArray_8_opaque) XdrPointer() interface{} { return (*[8]byte)(v) } +func (v *_XdrArray_8_opaque) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *_XdrArray_8_opaque) String() string { return fmt.Sprintf("%x", v[:]) } +func (v *_XdrArray_8_opaque) Scan(ss fmt.ScanState, c rune) error { + return XdrArrayOpaqueScan(v[:], ss, c) +} +func (_XdrArray_8_opaque) XdrArraySize() uint32 { + const bound uint32 = 8 // Force error if not const or doesn't fit + return bound +} +type XdrType_Verifier4 struct { + *_XdrArray_8_opaque +} +func XDR_Verifier4(v *Verifier4) XdrType_Verifier4 { + return XdrType_Verifier4{(*_XdrArray_8_opaque)(v)} +} +func (XdrType_Verifier4) XdrTypeName() string { return "Verifier4" } +func (v XdrType_Verifier4) XdrUnwrap() XdrType { return v._XdrArray_8_opaque } +type _XdrArray_16_opaque [16]byte +func (v *_XdrArray_16_opaque) GetByteSlice() []byte { return v[:] } +func (v *_XdrArray_16_opaque) XdrTypeName() string { return "opaque[]" } +func (v *_XdrArray_16_opaque) XdrValue() interface{} { return v[:] } +func (v *_XdrArray_16_opaque) XdrPointer() interface{} { return (*[16]byte)(v) } +func (v *_XdrArray_16_opaque) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *_XdrArray_16_opaque) String() string { return fmt.Sprintf("%x", v[:]) } +func (v *_XdrArray_16_opaque) Scan(ss fmt.ScanState, c rune) error { + return XdrArrayOpaqueScan(v[:], ss, c) +} +func (_XdrArray_16_opaque) XdrArraySize() uint32 { + const bound uint32 = 16 // Force error if not const or doesn't fit + return bound +} +type XdrType_Sessionid4 struct { + *_XdrArray_16_opaque +} +func XDR_Sessionid4(v *Sessionid4) XdrType_Sessionid4 { + return XdrType_Sessionid4{(*_XdrArray_16_opaque)(v)} +} +func (XdrType_Sessionid4) XdrTypeName() string { return "Sessionid4" } +func (v XdrType_Sessionid4) XdrUnwrap() XdrType { return v._XdrArray_16_opaque } +type _XdrVec_16_uint32 []uint32 +func (_XdrVec_16_uint32) XdrBound() uint32 { + const bound uint32 = 16 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_16_uint32) XdrCheckLen(length uint32) { + if length > uint32(16) { + XdrPanic("_XdrVec_16_uint32 length %d exceeds bound 16", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_16_uint32 length %d exceeds max int", length) + } +} +func (v _XdrVec_16_uint32) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_16_uint32) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(16); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]uint32, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_16_uint32) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_uint32(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_16_uint32) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 16 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_16_uint32) XdrTypeName() string { return "uint32<>" } +func (v *_XdrVec_16_uint32) XdrPointer() interface{} { return (*[]uint32)(v) } +func (v _XdrVec_16_uint32) XdrValue() interface{} { return ([]uint32)(v) } +func (v *_XdrVec_16_uint32) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Authsys_parms = *Authsys_parms +func (v *Authsys_parms) XdrPointer() interface{} { return v } +func (Authsys_parms) XdrTypeName() string { return "Authsys_parms" } +func (v Authsys_parms) XdrValue() interface{} { return v } +func (v *Authsys_parms) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Authsys_parms) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstamp", name), XDR_uint32(&v.Stamp)) + x.Marshal(x.Sprintf("%smachinename", name), XdrString{&v.Machinename, 255}) + x.Marshal(x.Sprintf("%suid", name), XDR_uint32(&v.Uid)) + x.Marshal(x.Sprintf("%sgid", name), XDR_uint32(&v.Gid)) + x.Marshal(x.Sprintf("%sgids", name), (*_XdrVec_16_uint32)(&v.Gids)) +} +func XDR_Authsys_parms(v *Authsys_parms) *Authsys_parms { return v } +type XdrType_Deviceid4 struct { + *_XdrArray_16_opaque +} +func XDR_Deviceid4(v *Deviceid4) *XdrType_Deviceid4 { + return &XdrType_Deviceid4{(*_XdrArray_16_opaque)(v)} +} +func (XdrType_Deviceid4) XdrTypeName() string { return "Deviceid4" } +func (v XdrType_Deviceid4) XdrUnwrap() XdrType { return v._XdrArray_16_opaque } +var _XdrNames_Layouttype4 = map[int32]string{ + int32(LAYOUT4_NFSV4_1_FILES): "LAYOUT4_NFSV4_1_FILES", + int32(LAYOUT4_OSD2_OBJECTS): "LAYOUT4_OSD2_OBJECTS", + int32(LAYOUT4_BLOCK_VOLUME): "LAYOUT4_BLOCK_VOLUME", +} +var _XdrValues_Layouttype4 = map[string]int32{ + "LAYOUT4_NFSV4_1_FILES": int32(LAYOUT4_NFSV4_1_FILES), + "LAYOUT4_OSD2_OBJECTS": int32(LAYOUT4_OSD2_OBJECTS), + "LAYOUT4_BLOCK_VOLUME": int32(LAYOUT4_BLOCK_VOLUME), +} +func (Layouttype4) XdrEnumNames() map[int32]string { + return _XdrNames_Layouttype4 +} +func (v Layouttype4) String() string { + if s, ok := _XdrNames_Layouttype4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Layouttype4#%d", v) +} +func (v *Layouttype4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Layouttype4[stok]; ok { + *v = Layouttype4(val) + return nil + } else if stok == "Layouttype4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Layouttype4.", stok)) + } +} +func (v Layouttype4) GetU32() uint32 { return uint32(v) } +func (v *Layouttype4) SetU32(n uint32) { *v = Layouttype4(n) } +func (v *Layouttype4) XdrPointer() interface{} { return v } +func (Layouttype4) XdrTypeName() string { return "Layouttype4" } +func (v Layouttype4) XdrValue() interface{} { return v } +func (v *Layouttype4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Layouttype4 = *Layouttype4 +func XDR_Layouttype4(v *Layouttype4) *Layouttype4 { return v } +func (v *Layouttype4) XdrInitialize() { + switch Layouttype4(0) { + case LAYOUT4_NFSV4_1_FILES, LAYOUT4_OSD2_OBJECTS, LAYOUT4_BLOCK_VOLUME: + default: + if *v == Layouttype4(0) { *v = LAYOUT4_NFSV4_1_FILES } + } +} +type XdrType_Layoutupdate4 = *Layoutupdate4 +func (v *Layoutupdate4) XdrPointer() interface{} { return v } +func (Layoutupdate4) XdrTypeName() string { return "Layoutupdate4" } +func (v Layoutupdate4) XdrValue() interface{} { return v } +func (v *Layoutupdate4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Layoutupdate4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slou_type", name), XDR_Layouttype4(&v.Lou_type)) + x.Marshal(x.Sprintf("%slou_body", name), XdrVecOpaque{&v.Lou_body, 0xffffffff}) +} +func XDR_Layoutupdate4(v *Layoutupdate4) *Layoutupdate4 { return v } +type XdrType_Device_addr4 = *Device_addr4 +func (v *Device_addr4) XdrPointer() interface{} { return v } +func (Device_addr4) XdrTypeName() string { return "Device_addr4" } +func (v Device_addr4) XdrValue() interface{} { return v } +func (v *Device_addr4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Device_addr4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sda_layout_type", name), XDR_Layouttype4(&v.Da_layout_type)) + x.Marshal(x.Sprintf("%sda_addr_body", name), XdrVecOpaque{&v.Da_addr_body, 0xffffffff}) +} +func XDR_Device_addr4(v *Device_addr4) *Device_addr4 { return v } +type XdrType_Nfstime4 = *Nfstime4 +func (v *Nfstime4) XdrPointer() interface{} { return v } +func (Nfstime4) XdrTypeName() string { return "Nfstime4" } +func (v Nfstime4) XdrValue() interface{} { return v } +func (v *Nfstime4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Nfstime4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sseconds", name), XDR_Int64_t(&v.Seconds)) + x.Marshal(x.Sprintf("%snseconds", name), XDR_Uint32_t(&v.Nseconds)) +} +func XDR_Nfstime4(v *Nfstime4) *Nfstime4 { return v } +var _XdrNames_Time_how4 = map[int32]string{ + int32(SET_TO_SERVER_TIME4): "SET_TO_SERVER_TIME4", + int32(SET_TO_CLIENT_TIME4): "SET_TO_CLIENT_TIME4", +} +var _XdrValues_Time_how4 = map[string]int32{ + "SET_TO_SERVER_TIME4": int32(SET_TO_SERVER_TIME4), + "SET_TO_CLIENT_TIME4": int32(SET_TO_CLIENT_TIME4), +} +func (Time_how4) XdrEnumNames() map[int32]string { + return _XdrNames_Time_how4 +} +func (v Time_how4) String() string { + if s, ok := _XdrNames_Time_how4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Time_how4#%d", v) +} +func (v *Time_how4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Time_how4[stok]; ok { + *v = Time_how4(val) + return nil + } else if stok == "Time_how4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Time_how4.", stok)) + } +} +func (v Time_how4) GetU32() uint32 { return uint32(v) } +func (v *Time_how4) SetU32(n uint32) { *v = Time_how4(n) } +func (v *Time_how4) XdrPointer() interface{} { return v } +func (Time_how4) XdrTypeName() string { return "Time_how4" } +func (v Time_how4) XdrValue() interface{} { return v } +func (v *Time_how4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Time_how4 = *Time_how4 +func XDR_Time_how4(v *Time_how4) *Time_how4 { return v } +var _XdrNames_Layoutiomode4 = map[int32]string{ + int32(LAYOUTIOMODE4_READ): "LAYOUTIOMODE4_READ", + int32(LAYOUTIOMODE4_RW): "LAYOUTIOMODE4_RW", + int32(LAYOUTIOMODE4_ANY): "LAYOUTIOMODE4_ANY", +} +var _XdrValues_Layoutiomode4 = map[string]int32{ + "LAYOUTIOMODE4_READ": int32(LAYOUTIOMODE4_READ), + "LAYOUTIOMODE4_RW": int32(LAYOUTIOMODE4_RW), + "LAYOUTIOMODE4_ANY": int32(LAYOUTIOMODE4_ANY), +} +func (Layoutiomode4) XdrEnumNames() map[int32]string { + return _XdrNames_Layoutiomode4 +} +func (v Layoutiomode4) String() string { + if s, ok := _XdrNames_Layoutiomode4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Layoutiomode4#%d", v) +} +func (v *Layoutiomode4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Layoutiomode4[stok]; ok { + *v = Layoutiomode4(val) + return nil + } else if stok == "Layoutiomode4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Layoutiomode4.", stok)) + } +} +func (v Layoutiomode4) GetU32() uint32 { return uint32(v) } +func (v *Layoutiomode4) SetU32(n uint32) { *v = Layoutiomode4(n) } +func (v *Layoutiomode4) XdrPointer() interface{} { return v } +func (Layoutiomode4) XdrTypeName() string { return "Layoutiomode4" } +func (v Layoutiomode4) XdrValue() interface{} { return v } +func (v *Layoutiomode4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Layoutiomode4 = *Layoutiomode4 +func XDR_Layoutiomode4(v *Layoutiomode4) *Layoutiomode4 { return v } +func (v *Layoutiomode4) XdrInitialize() { + switch Layoutiomode4(0) { + case LAYOUTIOMODE4_READ, LAYOUTIOMODE4_RW, LAYOUTIOMODE4_ANY: + default: + if *v == Layoutiomode4(0) { *v = LAYOUTIOMODE4_READ } + } +} +type XdrType_Layout_content4 = *Layout_content4 +func (v *Layout_content4) XdrPointer() interface{} { return v } +func (Layout_content4) XdrTypeName() string { return "Layout_content4" } +func (v Layout_content4) XdrValue() interface{} { return v } +func (v *Layout_content4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Layout_content4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sloc_type", name), XDR_Layouttype4(&v.Loc_type)) + x.Marshal(x.Sprintf("%sloc_body", name), XdrVecOpaque{&v.Loc_body, 0xffffffff}) +} +func XDR_Layout_content4(v *Layout_content4) *Layout_content4 { return v } +type XdrType_Layout4 = *Layout4 +func (v *Layout4) XdrPointer() interface{} { return v } +func (Layout4) XdrTypeName() string { return "Layout4" } +func (v Layout4) XdrValue() interface{} { return v } +func (v *Layout4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Layout4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slo_offset", name), XDR_Offset4(&v.Lo_offset)) + x.Marshal(x.Sprintf("%slo_length", name), XDR_Length4(&v.Lo_length)) + x.Marshal(x.Sprintf("%slo_iomode", name), XDR_Layoutiomode4(&v.Lo_iomode)) + x.Marshal(x.Sprintf("%slo_content", name), XDR_Layout_content4(&v.Lo_content)) +} +func XDR_Layout4(v *Layout4) *Layout4 { return v } +func (u *Settime4) Time() *Nfstime4 { + switch u.Set_it { + case SET_TO_CLIENT_TIME4: + if v, ok := u.U.(*Nfstime4); ok { + return v + } else { + var zero Nfstime4 + u.U = &zero + return &zero + } + default: + XdrPanic("Settime4.Time accessed when Set_it == %v", u.Set_it) + return nil + } +} +func (u Settime4) XdrValid() bool { + return true +} +func (u *Settime4) XdrUnionTag() XdrNum32 { + return XDR_Time_how4(&u.Set_it) +} +func (u *Settime4) XdrUnionTagName() string { + return "Set_it" +} +func (u *Settime4) XdrUnionBody() XdrType { + switch u.Set_it { + case SET_TO_CLIENT_TIME4: + return XDR_Nfstime4(u.Time()) + default: + return nil + } +} +func (u *Settime4) XdrUnionBodyName() string { + switch u.Set_it { + case SET_TO_CLIENT_TIME4: + return "Time" + default: + return "" + } +} +type XdrType_Settime4 = *Settime4 +func (v *Settime4) XdrPointer() interface{} { return v } +func (Settime4) XdrTypeName() string { return "Settime4" } +func (v Settime4) XdrValue() interface{} { return v } +func (v *Settime4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Settime4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Time_how4(&u.Set_it).XdrMarshal(x, x.Sprintf("%sset_it", name)) + switch u.Set_it { + case SET_TO_CLIENT_TIME4: + x.Marshal(x.Sprintf("%stime", name), XDR_Nfstime4(u.Time())) + return + default: + return + } +} +func XDR_Settime4(v *Settime4) *Settime4 { return v} +type XdrType_Nfs_fh4 struct { + XdrVecOpaque +} +func XDR_Nfs_fh4(v *Nfs_fh4) XdrType_Nfs_fh4 { + return XdrType_Nfs_fh4{XdrVecOpaque{v, NFS4_FHSIZE}} +} +func (XdrType_Nfs_fh4) XdrTypeName() string { return "Nfs_fh4" } +func (v XdrType_Nfs_fh4) XdrUnwrap() XdrType { return v.XdrVecOpaque } +type XdrType_Fsid4 = *Fsid4 +func (v *Fsid4) XdrPointer() interface{} { return v } +func (Fsid4) XdrTypeName() string { return "Fsid4" } +func (v Fsid4) XdrValue() interface{} { return v } +func (v *Fsid4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Fsid4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%smajor", name), XDR_Uint64_t(&v.Major)) + x.Marshal(x.Sprintf("%sminor", name), XDR_Uint64_t(&v.Minor)) +} +func XDR_Fsid4(v *Fsid4) *Fsid4 { return v } +type _XdrVec_unbounded_Utf8str_cis []Utf8str_cis +func (_XdrVec_unbounded_Utf8str_cis) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Utf8str_cis) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Utf8str_cis length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Utf8str_cis length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Utf8str_cis) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Utf8str_cis) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Utf8str_cis, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Utf8str_cis) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Utf8str_cis(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Utf8str_cis) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Utf8str_cis) XdrTypeName() string { return "Utf8str_cis<>" } +func (v *_XdrVec_unbounded_Utf8str_cis) XdrPointer() interface{} { return (*[]Utf8str_cis)(v) } +func (v _XdrVec_unbounded_Utf8str_cis) XdrValue() interface{} { return ([]Utf8str_cis)(v) } +func (v *_XdrVec_unbounded_Utf8str_cis) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Fs_location4 = *Fs_location4 +func (v *Fs_location4) XdrPointer() interface{} { return v } +func (Fs_location4) XdrTypeName() string { return "Fs_location4" } +func (v Fs_location4) XdrValue() interface{} { return v } +func (v *Fs_location4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Fs_location4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sserver", name), (*_XdrVec_unbounded_Utf8str_cis)(&v.Server)) + x.Marshal(x.Sprintf("%srootpath", name), XDR_Pathname4(&v.Rootpath)) +} +func XDR_Fs_location4(v *Fs_location4) *Fs_location4 { return v } +type _XdrVec_unbounded_Fs_location4 []Fs_location4 +func (_XdrVec_unbounded_Fs_location4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Fs_location4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Fs_location4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Fs_location4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Fs_location4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Fs_location4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Fs_location4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Fs_location4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Fs_location4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Fs_location4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Fs_location4) XdrTypeName() string { return "Fs_location4<>" } +func (v *_XdrVec_unbounded_Fs_location4) XdrPointer() interface{} { return (*[]Fs_location4)(v) } +func (v _XdrVec_unbounded_Fs_location4) XdrValue() interface{} { return ([]Fs_location4)(v) } +func (v *_XdrVec_unbounded_Fs_location4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Fs_locations4 = *Fs_locations4 +func (v *Fs_locations4) XdrPointer() interface{} { return v } +func (Fs_locations4) XdrTypeName() string { return "Fs_locations4" } +func (v Fs_locations4) XdrValue() interface{} { return v } +func (v *Fs_locations4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Fs_locations4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sfs_root", name), XDR_Pathname4(&v.Fs_root)) + x.Marshal(x.Sprintf("%slocations", name), (*_XdrVec_unbounded_Fs_location4)(&v.Locations)) +} +func XDR_Fs_locations4(v *Fs_locations4) *Fs_locations4 { return v } +type XdrType_Acetype4 struct { + XdrType_Uint32_t +} +func XDR_Acetype4(v *Acetype4) *XdrType_Acetype4 { + return &XdrType_Acetype4{XDR_Uint32_t(v)} +} +func (XdrType_Acetype4) XdrTypeName() string { return "Acetype4" } +func (v XdrType_Acetype4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Aceflag4 struct { + XdrType_Uint32_t +} +func XDR_Aceflag4(v *Aceflag4) *XdrType_Aceflag4 { + return &XdrType_Aceflag4{XDR_Uint32_t(v)} +} +func (XdrType_Aceflag4) XdrTypeName() string { return "Aceflag4" } +func (v XdrType_Aceflag4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Acemask4 struct { + XdrType_Uint32_t +} +func XDR_Acemask4(v *Acemask4) *XdrType_Acemask4 { + return &XdrType_Acemask4{XDR_Uint32_t(v)} +} +func (XdrType_Acemask4) XdrTypeName() string { return "Acemask4" } +func (v XdrType_Acemask4) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Nfsace4 = *Nfsace4 +func (v *Nfsace4) XdrPointer() interface{} { return v } +func (Nfsace4) XdrTypeName() string { return "Nfsace4" } +func (v Nfsace4) XdrValue() interface{} { return v } +func (v *Nfsace4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Nfsace4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%stype", name), XDR_Acetype4(&v.Type)) + x.Marshal(x.Sprintf("%sflag", name), XDR_Aceflag4(&v.Flag)) + x.Marshal(x.Sprintf("%saccess_mask", name), XDR_Acemask4(&v.Access_mask)) + x.Marshal(x.Sprintf("%swho", name), XDR_Utf8str_mixed(&v.Who)) +} +func XDR_Nfsace4(v *Nfsace4) *Nfsace4 { return v } +type XdrType_Specdata4 = *Specdata4 +func (v *Specdata4) XdrPointer() interface{} { return v } +func (Specdata4) XdrTypeName() string { return "Specdata4" } +func (v Specdata4) XdrValue() interface{} { return v } +func (v *Specdata4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Specdata4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sspecdata1", name), XDR_Uint32_t(&v.Specdata1)) + x.Marshal(x.Sprintf("%sspecdata2", name), XDR_Uint32_t(&v.Specdata2)) +} +func XDR_Specdata4(v *Specdata4) *Specdata4 { return v } +type XdrType_Fattr4_supported_attrs struct { + XdrType_Bitmap4 +} +func XDR_Fattr4_supported_attrs(v *Fattr4_supported_attrs) XdrType_Fattr4_supported_attrs { + return XdrType_Fattr4_supported_attrs{XDR_Bitmap4(v)} +} +func (XdrType_Fattr4_supported_attrs) XdrTypeName() string { return "Fattr4_supported_attrs" } +func (v XdrType_Fattr4_supported_attrs) XdrUnwrap() XdrType { return v.XdrType_Bitmap4 } +type XdrType_Fattr4_type struct { + XdrType_Nfs_ftype4 +} +func XDR_Fattr4_type(v *Fattr4_type) XdrType_Fattr4_type { + return XdrType_Fattr4_type{XDR_Nfs_ftype4(v)} +} +func (XdrType_Fattr4_type) XdrTypeName() string { return "Fattr4_type" } +func (v XdrType_Fattr4_type) XdrUnwrap() XdrType { return v.XdrType_Nfs_ftype4 } +type XdrType_Fattr4_fh_expire_type struct { + XdrType_Uint32_t +} +func XDR_Fattr4_fh_expire_type(v *Fattr4_fh_expire_type) XdrType_Fattr4_fh_expire_type { + return XdrType_Fattr4_fh_expire_type{XDR_Uint32_t(v)} +} +func (XdrType_Fattr4_fh_expire_type) XdrTypeName() string { return "Fattr4_fh_expire_type" } +func (v XdrType_Fattr4_fh_expire_type) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Fattr4_change struct { + XdrType_Changeid4 +} +func XDR_Fattr4_change(v *Fattr4_change) *XdrType_Fattr4_change { + return &XdrType_Fattr4_change{*XDR_Changeid4(v)} +} +func (XdrType_Fattr4_change) XdrTypeName() string { return "Fattr4_change" } +func (v XdrType_Fattr4_change) XdrUnwrap() XdrType { return &v.XdrType_Changeid4 } +type XdrType_Fattr4_size struct { + XdrType_Uint64_t +} +func XDR_Fattr4_size(v *Fattr4_size) XdrType_Fattr4_size { + return XdrType_Fattr4_size{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_size) XdrTypeName() string { return "Fattr4_size" } +func (v XdrType_Fattr4_size) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_link_support struct { + XdrType_bool +} +func XDR_Fattr4_link_support(v *Fattr4_link_support) XdrType_Fattr4_link_support { + return XdrType_Fattr4_link_support{XDR_bool(v)} +} +func (XdrType_Fattr4_link_support) XdrTypeName() string { return "Fattr4_link_support" } +func (v XdrType_Fattr4_link_support) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_symlink_support struct { + XdrType_bool +} +func XDR_Fattr4_symlink_support(v *Fattr4_symlink_support) XdrType_Fattr4_symlink_support { + return XdrType_Fattr4_symlink_support{XDR_bool(v)} +} +func (XdrType_Fattr4_symlink_support) XdrTypeName() string { return "Fattr4_symlink_support" } +func (v XdrType_Fattr4_symlink_support) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_named_attr struct { + XdrType_bool +} +func XDR_Fattr4_named_attr(v *Fattr4_named_attr) XdrType_Fattr4_named_attr { + return XdrType_Fattr4_named_attr{XDR_bool(v)} +} +func (XdrType_Fattr4_named_attr) XdrTypeName() string { return "Fattr4_named_attr" } +func (v XdrType_Fattr4_named_attr) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_fsid struct { + XdrType_Fsid4 +} +func XDR_Fattr4_fsid(v *Fattr4_fsid) XdrType_Fattr4_fsid { + return XdrType_Fattr4_fsid{XDR_Fsid4(v)} +} +func (XdrType_Fattr4_fsid) XdrTypeName() string { return "Fattr4_fsid" } +func (v XdrType_Fattr4_fsid) XdrUnwrap() XdrType { return v.XdrType_Fsid4 } +type XdrType_Fattr4_unique_handles struct { + XdrType_bool +} +func XDR_Fattr4_unique_handles(v *Fattr4_unique_handles) XdrType_Fattr4_unique_handles { + return XdrType_Fattr4_unique_handles{XDR_bool(v)} +} +func (XdrType_Fattr4_unique_handles) XdrTypeName() string { return "Fattr4_unique_handles" } +func (v XdrType_Fattr4_unique_handles) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_lease_time struct { + XdrType_Uint32_t +} +func XDR_Fattr4_lease_time(v *Fattr4_lease_time) XdrType_Fattr4_lease_time { + return XdrType_Fattr4_lease_time{XDR_Uint32_t(v)} +} +func (XdrType_Fattr4_lease_time) XdrTypeName() string { return "Fattr4_lease_time" } +func (v XdrType_Fattr4_lease_time) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Fattr4_rdattr_error struct { + XdrType_Nfsstat4 +} +func XDR_Fattr4_rdattr_error(v *Fattr4_rdattr_error) XdrType_Fattr4_rdattr_error { + return XdrType_Fattr4_rdattr_error{XDR_Nfsstat4(v)} +} +func (XdrType_Fattr4_rdattr_error) XdrTypeName() string { return "Fattr4_rdattr_error" } +func (v XdrType_Fattr4_rdattr_error) XdrUnwrap() XdrType { return v.XdrType_Nfsstat4 } +type _XdrVec_unbounded_Nfsace4 []Nfsace4 +func (_XdrVec_unbounded_Nfsace4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Nfsace4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Nfsace4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Nfsace4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Nfsace4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Nfsace4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Nfsace4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Nfsace4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Nfsace4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Nfsace4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Nfsace4) XdrTypeName() string { return "Nfsace4<>" } +func (v *_XdrVec_unbounded_Nfsace4) XdrPointer() interface{} { return (*[]Nfsace4)(v) } +func (v _XdrVec_unbounded_Nfsace4) XdrValue() interface{} { return ([]Nfsace4)(v) } +func (v *_XdrVec_unbounded_Nfsace4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Fattr4_acl struct { + *_XdrVec_unbounded_Nfsace4 +} +func XDR_Fattr4_acl(v *Fattr4_acl) XdrType_Fattr4_acl { + return XdrType_Fattr4_acl{(*_XdrVec_unbounded_Nfsace4)(v)} +} +func (XdrType_Fattr4_acl) XdrTypeName() string { return "Fattr4_acl" } +func (v XdrType_Fattr4_acl) XdrUnwrap() XdrType { return v._XdrVec_unbounded_Nfsace4 } +type XdrType_Fattr4_aclsupport struct { + XdrType_Uint32_t +} +func XDR_Fattr4_aclsupport(v *Fattr4_aclsupport) XdrType_Fattr4_aclsupport { + return XdrType_Fattr4_aclsupport{XDR_Uint32_t(v)} +} +func (XdrType_Fattr4_aclsupport) XdrTypeName() string { return "Fattr4_aclsupport" } +func (v XdrType_Fattr4_aclsupport) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Fattr4_archive struct { + XdrType_bool +} +func XDR_Fattr4_archive(v *Fattr4_archive) XdrType_Fattr4_archive { + return XdrType_Fattr4_archive{XDR_bool(v)} +} +func (XdrType_Fattr4_archive) XdrTypeName() string { return "Fattr4_archive" } +func (v XdrType_Fattr4_archive) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_cansettime struct { + XdrType_bool +} +func XDR_Fattr4_cansettime(v *Fattr4_cansettime) XdrType_Fattr4_cansettime { + return XdrType_Fattr4_cansettime{XDR_bool(v)} +} +func (XdrType_Fattr4_cansettime) XdrTypeName() string { return "Fattr4_cansettime" } +func (v XdrType_Fattr4_cansettime) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_case_insensitive struct { + XdrType_bool +} +func XDR_Fattr4_case_insensitive(v *Fattr4_case_insensitive) XdrType_Fattr4_case_insensitive { + return XdrType_Fattr4_case_insensitive{XDR_bool(v)} +} +func (XdrType_Fattr4_case_insensitive) XdrTypeName() string { return "Fattr4_case_insensitive" } +func (v XdrType_Fattr4_case_insensitive) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_case_preserving struct { + XdrType_bool +} +func XDR_Fattr4_case_preserving(v *Fattr4_case_preserving) XdrType_Fattr4_case_preserving { + return XdrType_Fattr4_case_preserving{XDR_bool(v)} +} +func (XdrType_Fattr4_case_preserving) XdrTypeName() string { return "Fattr4_case_preserving" } +func (v XdrType_Fattr4_case_preserving) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_chown_restricted struct { + XdrType_bool +} +func XDR_Fattr4_chown_restricted(v *Fattr4_chown_restricted) XdrType_Fattr4_chown_restricted { + return XdrType_Fattr4_chown_restricted{XDR_bool(v)} +} +func (XdrType_Fattr4_chown_restricted) XdrTypeName() string { return "Fattr4_chown_restricted" } +func (v XdrType_Fattr4_chown_restricted) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_fileid struct { + XdrType_Uint64_t +} +func XDR_Fattr4_fileid(v *Fattr4_fileid) XdrType_Fattr4_fileid { + return XdrType_Fattr4_fileid{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_fileid) XdrTypeName() string { return "Fattr4_fileid" } +func (v XdrType_Fattr4_fileid) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_files_avail struct { + XdrType_Uint64_t +} +func XDR_Fattr4_files_avail(v *Fattr4_files_avail) XdrType_Fattr4_files_avail { + return XdrType_Fattr4_files_avail{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_files_avail) XdrTypeName() string { return "Fattr4_files_avail" } +func (v XdrType_Fattr4_files_avail) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_filehandle struct { + XdrType_Nfs_fh4 +} +func XDR_Fattr4_filehandle(v *Fattr4_filehandle) XdrType_Fattr4_filehandle { + return XdrType_Fattr4_filehandle{XDR_Nfs_fh4(v)} +} +func (XdrType_Fattr4_filehandle) XdrTypeName() string { return "Fattr4_filehandle" } +func (v XdrType_Fattr4_filehandle) XdrUnwrap() XdrType { return v.XdrType_Nfs_fh4 } +type XdrType_Fattr4_files_free struct { + XdrType_Uint64_t +} +func XDR_Fattr4_files_free(v *Fattr4_files_free) XdrType_Fattr4_files_free { + return XdrType_Fattr4_files_free{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_files_free) XdrTypeName() string { return "Fattr4_files_free" } +func (v XdrType_Fattr4_files_free) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_files_total struct { + XdrType_Uint64_t +} +func XDR_Fattr4_files_total(v *Fattr4_files_total) XdrType_Fattr4_files_total { + return XdrType_Fattr4_files_total{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_files_total) XdrTypeName() string { return "Fattr4_files_total" } +func (v XdrType_Fattr4_files_total) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_fs_locations struct { + XdrType_Fs_locations4 +} +func XDR_Fattr4_fs_locations(v *Fattr4_fs_locations) XdrType_Fattr4_fs_locations { + return XdrType_Fattr4_fs_locations{XDR_Fs_locations4(v)} +} +func (XdrType_Fattr4_fs_locations) XdrTypeName() string { return "Fattr4_fs_locations" } +func (v XdrType_Fattr4_fs_locations) XdrUnwrap() XdrType { return v.XdrType_Fs_locations4 } +type XdrType_Fattr4_hidden struct { + XdrType_bool +} +func XDR_Fattr4_hidden(v *Fattr4_hidden) XdrType_Fattr4_hidden { + return XdrType_Fattr4_hidden{XDR_bool(v)} +} +func (XdrType_Fattr4_hidden) XdrTypeName() string { return "Fattr4_hidden" } +func (v XdrType_Fattr4_hidden) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_homogeneous struct { + XdrType_bool +} +func XDR_Fattr4_homogeneous(v *Fattr4_homogeneous) XdrType_Fattr4_homogeneous { + return XdrType_Fattr4_homogeneous{XDR_bool(v)} +} +func (XdrType_Fattr4_homogeneous) XdrTypeName() string { return "Fattr4_homogeneous" } +func (v XdrType_Fattr4_homogeneous) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_maxfilesize struct { + XdrType_Uint64_t +} +func XDR_Fattr4_maxfilesize(v *Fattr4_maxfilesize) XdrType_Fattr4_maxfilesize { + return XdrType_Fattr4_maxfilesize{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_maxfilesize) XdrTypeName() string { return "Fattr4_maxfilesize" } +func (v XdrType_Fattr4_maxfilesize) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_maxlink struct { + XdrType_Uint32_t +} +func XDR_Fattr4_maxlink(v *Fattr4_maxlink) XdrType_Fattr4_maxlink { + return XdrType_Fattr4_maxlink{XDR_Uint32_t(v)} +} +func (XdrType_Fattr4_maxlink) XdrTypeName() string { return "Fattr4_maxlink" } +func (v XdrType_Fattr4_maxlink) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Fattr4_maxname struct { + XdrType_Uint32_t +} +func XDR_Fattr4_maxname(v *Fattr4_maxname) XdrType_Fattr4_maxname { + return XdrType_Fattr4_maxname{XDR_Uint32_t(v)} +} +func (XdrType_Fattr4_maxname) XdrTypeName() string { return "Fattr4_maxname" } +func (v XdrType_Fattr4_maxname) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Fattr4_maxread struct { + XdrType_Uint64_t +} +func XDR_Fattr4_maxread(v *Fattr4_maxread) XdrType_Fattr4_maxread { + return XdrType_Fattr4_maxread{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_maxread) XdrTypeName() string { return "Fattr4_maxread" } +func (v XdrType_Fattr4_maxread) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_maxwrite struct { + XdrType_Uint64_t +} +func XDR_Fattr4_maxwrite(v *Fattr4_maxwrite) XdrType_Fattr4_maxwrite { + return XdrType_Fattr4_maxwrite{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_maxwrite) XdrTypeName() string { return "Fattr4_maxwrite" } +func (v XdrType_Fattr4_maxwrite) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_mimetype struct { + XdrType_Utf8str_cs +} +func XDR_Fattr4_mimetype(v *Fattr4_mimetype) XdrType_Fattr4_mimetype { + return XdrType_Fattr4_mimetype{XDR_Utf8str_cs(v)} +} +func (XdrType_Fattr4_mimetype) XdrTypeName() string { return "Fattr4_mimetype" } +func (v XdrType_Fattr4_mimetype) XdrUnwrap() XdrType { return v.XdrType_Utf8str_cs } +type XdrType_Fattr4_mode struct { + XdrType_Mode4 +} +func XDR_Fattr4_mode(v *Fattr4_mode) XdrType_Fattr4_mode { + return XdrType_Fattr4_mode{XDR_Mode4(v)} +} +func (XdrType_Fattr4_mode) XdrTypeName() string { return "Fattr4_mode" } +func (v XdrType_Fattr4_mode) XdrUnwrap() XdrType { return &v.XdrType_Mode4 } +type XdrType_Fattr4_mounted_on_fileid struct { + XdrType_Uint64_t +} +func XDR_Fattr4_mounted_on_fileid(v *Fattr4_mounted_on_fileid) XdrType_Fattr4_mounted_on_fileid { + return XdrType_Fattr4_mounted_on_fileid{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_mounted_on_fileid) XdrTypeName() string { return "Fattr4_mounted_on_fileid" } +func (v XdrType_Fattr4_mounted_on_fileid) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_no_trunc struct { + XdrType_bool +} +func XDR_Fattr4_no_trunc(v *Fattr4_no_trunc) XdrType_Fattr4_no_trunc { + return XdrType_Fattr4_no_trunc{XDR_bool(v)} +} +func (XdrType_Fattr4_no_trunc) XdrTypeName() string { return "Fattr4_no_trunc" } +func (v XdrType_Fattr4_no_trunc) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_numlinks struct { + XdrType_Uint32_t +} +func XDR_Fattr4_numlinks(v *Fattr4_numlinks) XdrType_Fattr4_numlinks { + return XdrType_Fattr4_numlinks{XDR_Uint32_t(v)} +} +func (XdrType_Fattr4_numlinks) XdrTypeName() string { return "Fattr4_numlinks" } +func (v XdrType_Fattr4_numlinks) XdrUnwrap() XdrType { return v.XdrType_Uint32_t } +type XdrType_Fattr4_owner struct { + XdrType_Utf8str_mixed +} +func XDR_Fattr4_owner(v *Fattr4_owner) XdrType_Fattr4_owner { + return XdrType_Fattr4_owner{XDR_Utf8str_mixed(v)} +} +func (XdrType_Fattr4_owner) XdrTypeName() string { return "Fattr4_owner" } +func (v XdrType_Fattr4_owner) XdrUnwrap() XdrType { return v.XdrType_Utf8str_mixed } +type XdrType_Fattr4_owner_group struct { + XdrType_Utf8str_mixed +} +func XDR_Fattr4_owner_group(v *Fattr4_owner_group) XdrType_Fattr4_owner_group { + return XdrType_Fattr4_owner_group{XDR_Utf8str_mixed(v)} +} +func (XdrType_Fattr4_owner_group) XdrTypeName() string { return "Fattr4_owner_group" } +func (v XdrType_Fattr4_owner_group) XdrUnwrap() XdrType { return v.XdrType_Utf8str_mixed } +type XdrType_Fattr4_quota_avail_hard struct { + XdrType_Uint64_t +} +func XDR_Fattr4_quota_avail_hard(v *Fattr4_quota_avail_hard) XdrType_Fattr4_quota_avail_hard { + return XdrType_Fattr4_quota_avail_hard{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_quota_avail_hard) XdrTypeName() string { return "Fattr4_quota_avail_hard" } +func (v XdrType_Fattr4_quota_avail_hard) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_quota_avail_soft struct { + XdrType_Uint64_t +} +func XDR_Fattr4_quota_avail_soft(v *Fattr4_quota_avail_soft) XdrType_Fattr4_quota_avail_soft { + return XdrType_Fattr4_quota_avail_soft{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_quota_avail_soft) XdrTypeName() string { return "Fattr4_quota_avail_soft" } +func (v XdrType_Fattr4_quota_avail_soft) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_quota_used struct { + XdrType_Uint64_t +} +func XDR_Fattr4_quota_used(v *Fattr4_quota_used) XdrType_Fattr4_quota_used { + return XdrType_Fattr4_quota_used{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_quota_used) XdrTypeName() string { return "Fattr4_quota_used" } +func (v XdrType_Fattr4_quota_used) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_rawdev struct { + XdrType_Specdata4 +} +func XDR_Fattr4_rawdev(v *Fattr4_rawdev) XdrType_Fattr4_rawdev { + return XdrType_Fattr4_rawdev{XDR_Specdata4(v)} +} +func (XdrType_Fattr4_rawdev) XdrTypeName() string { return "Fattr4_rawdev" } +func (v XdrType_Fattr4_rawdev) XdrUnwrap() XdrType { return v.XdrType_Specdata4 } +type XdrType_Fattr4_space_avail struct { + XdrType_Uint64_t +} +func XDR_Fattr4_space_avail(v *Fattr4_space_avail) XdrType_Fattr4_space_avail { + return XdrType_Fattr4_space_avail{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_space_avail) XdrTypeName() string { return "Fattr4_space_avail" } +func (v XdrType_Fattr4_space_avail) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_space_free struct { + XdrType_Uint64_t +} +func XDR_Fattr4_space_free(v *Fattr4_space_free) XdrType_Fattr4_space_free { + return XdrType_Fattr4_space_free{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_space_free) XdrTypeName() string { return "Fattr4_space_free" } +func (v XdrType_Fattr4_space_free) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_space_total struct { + XdrType_Uint64_t +} +func XDR_Fattr4_space_total(v *Fattr4_space_total) XdrType_Fattr4_space_total { + return XdrType_Fattr4_space_total{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_space_total) XdrTypeName() string { return "Fattr4_space_total" } +func (v XdrType_Fattr4_space_total) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_space_used struct { + XdrType_Uint64_t +} +func XDR_Fattr4_space_used(v *Fattr4_space_used) XdrType_Fattr4_space_used { + return XdrType_Fattr4_space_used{XDR_Uint64_t(v)} +} +func (XdrType_Fattr4_space_used) XdrTypeName() string { return "Fattr4_space_used" } +func (v XdrType_Fattr4_space_used) XdrUnwrap() XdrType { return v.XdrType_Uint64_t } +type XdrType_Fattr4_system struct { + XdrType_bool +} +func XDR_Fattr4_system(v *Fattr4_system) XdrType_Fattr4_system { + return XdrType_Fattr4_system{XDR_bool(v)} +} +func (XdrType_Fattr4_system) XdrTypeName() string { return "Fattr4_system" } +func (v XdrType_Fattr4_system) XdrUnwrap() XdrType { return v.XdrType_bool } +type XdrType_Fattr4_time_access struct { + XdrType_Nfstime4 +} +func XDR_Fattr4_time_access(v *Fattr4_time_access) XdrType_Fattr4_time_access { + return XdrType_Fattr4_time_access{XDR_Nfstime4(v)} +} +func (XdrType_Fattr4_time_access) XdrTypeName() string { return "Fattr4_time_access" } +func (v XdrType_Fattr4_time_access) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_Fattr4_time_access_set struct { + XdrType_Settime4 +} +func XDR_Fattr4_time_access_set(v *Fattr4_time_access_set) XdrType_Fattr4_time_access_set { + return XdrType_Fattr4_time_access_set{XDR_Settime4(v)} +} +func (XdrType_Fattr4_time_access_set) XdrTypeName() string { return "Fattr4_time_access_set" } +func (v XdrType_Fattr4_time_access_set) XdrUnwrap() XdrType { return v.XdrType_Settime4 } +type XdrType_Fattr4_time_backup struct { + XdrType_Nfstime4 +} +func XDR_Fattr4_time_backup(v *Fattr4_time_backup) XdrType_Fattr4_time_backup { + return XdrType_Fattr4_time_backup{XDR_Nfstime4(v)} +} +func (XdrType_Fattr4_time_backup) XdrTypeName() string { return "Fattr4_time_backup" } +func (v XdrType_Fattr4_time_backup) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_Fattr4_time_create struct { + XdrType_Nfstime4 +} +func XDR_Fattr4_time_create(v *Fattr4_time_create) XdrType_Fattr4_time_create { + return XdrType_Fattr4_time_create{XDR_Nfstime4(v)} +} +func (XdrType_Fattr4_time_create) XdrTypeName() string { return "Fattr4_time_create" } +func (v XdrType_Fattr4_time_create) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_Fattr4_time_delta struct { + XdrType_Nfstime4 +} +func XDR_Fattr4_time_delta(v *Fattr4_time_delta) XdrType_Fattr4_time_delta { + return XdrType_Fattr4_time_delta{XDR_Nfstime4(v)} +} +func (XdrType_Fattr4_time_delta) XdrTypeName() string { return "Fattr4_time_delta" } +func (v XdrType_Fattr4_time_delta) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_Fattr4_time_metadata struct { + XdrType_Nfstime4 +} +func XDR_Fattr4_time_metadata(v *Fattr4_time_metadata) XdrType_Fattr4_time_metadata { + return XdrType_Fattr4_time_metadata{XDR_Nfstime4(v)} +} +func (XdrType_Fattr4_time_metadata) XdrTypeName() string { return "Fattr4_time_metadata" } +func (v XdrType_Fattr4_time_metadata) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_Fattr4_time_modify struct { + XdrType_Nfstime4 +} +func XDR_Fattr4_time_modify(v *Fattr4_time_modify) XdrType_Fattr4_time_modify { + return XdrType_Fattr4_time_modify{XDR_Nfstime4(v)} +} +func (XdrType_Fattr4_time_modify) XdrTypeName() string { return "Fattr4_time_modify" } +func (v XdrType_Fattr4_time_modify) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_Fattr4_time_modify_set struct { + XdrType_Settime4 +} +func XDR_Fattr4_time_modify_set(v *Fattr4_time_modify_set) XdrType_Fattr4_time_modify_set { + return XdrType_Fattr4_time_modify_set{XDR_Settime4(v)} +} +func (XdrType_Fattr4_time_modify_set) XdrTypeName() string { return "Fattr4_time_modify_set" } +func (v XdrType_Fattr4_time_modify_set) XdrUnwrap() XdrType { return v.XdrType_Settime4 } +type XdrType_Attrlist4 struct { + XdrVecOpaque +} +func XDR_Attrlist4(v *Attrlist4) XdrType_Attrlist4 { + return XdrType_Attrlist4{XdrVecOpaque{v, 0xffffffff}} +} +func (XdrType_Attrlist4) XdrTypeName() string { return "Attrlist4" } +func (v XdrType_Attrlist4) XdrUnwrap() XdrType { return v.XdrVecOpaque } +type XdrType_Fattr4 = *Fattr4 +func (v *Fattr4) XdrPointer() interface{} { return v } +func (Fattr4) XdrTypeName() string { return "Fattr4" } +func (v Fattr4) XdrValue() interface{} { return v } +func (v *Fattr4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Fattr4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sattrmask", name), XDR_Bitmap4(&v.Attrmask)) + x.Marshal(x.Sprintf("%sattr_vals", name), XDR_Attrlist4(&v.Attr_vals)) +} +func XDR_Fattr4(v *Fattr4) *Fattr4 { return v } +type XdrType_Change_info4 = *Change_info4 +func (v *Change_info4) XdrPointer() interface{} { return v } +func (Change_info4) XdrTypeName() string { return "Change_info4" } +func (v Change_info4) XdrValue() interface{} { return v } +func (v *Change_info4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Change_info4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%satomic", name), XDR_bool(&v.Atomic)) + x.Marshal(x.Sprintf("%sbefore", name), XDR_Changeid4(&v.Before)) + x.Marshal(x.Sprintf("%safter", name), XDR_Changeid4(&v.After)) +} +func XDR_Change_info4(v *Change_info4) *Change_info4 { return v } +type XdrType_Clientaddr4 = *Clientaddr4 +func (v *Clientaddr4) XdrPointer() interface{} { return v } +func (Clientaddr4) XdrTypeName() string { return "Clientaddr4" } +func (v Clientaddr4) XdrValue() interface{} { return v } +func (v *Clientaddr4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Clientaddr4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sr_netid", name), XdrString{&v.R_netid, 0xffffffff}) + x.Marshal(x.Sprintf("%sr_addr", name), XdrString{&v.R_addr, 0xffffffff}) +} +func XDR_Clientaddr4(v *Clientaddr4) *Clientaddr4 { return v } +type XdrType_Cb_client4 = *Cb_client4 +func (v *Cb_client4) XdrPointer() interface{} { return v } +func (Cb_client4) XdrTypeName() string { return "Cb_client4" } +func (v Cb_client4) XdrValue() interface{} { return v } +func (v *Cb_client4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Cb_client4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scb_program", name), XDR_Uint32_t(&v.Cb_program)) + x.Marshal(x.Sprintf("%scb_location", name), XDR_Clientaddr4(&v.Cb_location)) +} +func XDR_Cb_client4(v *Cb_client4) *Cb_client4 { return v } +type _XdrArray_12_opaque [12]byte +func (v *_XdrArray_12_opaque) GetByteSlice() []byte { return v[:] } +func (v *_XdrArray_12_opaque) XdrTypeName() string { return "opaque[]" } +func (v *_XdrArray_12_opaque) XdrValue() interface{} { return v[:] } +func (v *_XdrArray_12_opaque) XdrPointer() interface{} { return (*[12]byte)(v) } +func (v *_XdrArray_12_opaque) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *_XdrArray_12_opaque) String() string { return fmt.Sprintf("%x", v[:]) } +func (v *_XdrArray_12_opaque) Scan(ss fmt.ScanState, c rune) error { + return XdrArrayOpaqueScan(v[:], ss, c) +} +func (_XdrArray_12_opaque) XdrArraySize() uint32 { + const bound uint32 = 12 // Force error if not const or doesn't fit + return bound +} +type XdrType_Stateid4 = *Stateid4 +func (v *Stateid4) XdrPointer() interface{} { return v } +func (Stateid4) XdrTypeName() string { return "Stateid4" } +func (v Stateid4) XdrValue() interface{} { return v } +func (v *Stateid4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Stateid4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sseqid", name), XDR_Uint32_t(&v.Seqid)) + x.Marshal(x.Sprintf("%sother", name), (*_XdrArray_12_opaque)(&v.Other)) +} +func XDR_Stateid4(v *Stateid4) *Stateid4 { return v } +type XdrType_Nfs_client_id4 = *Nfs_client_id4 +func (v *Nfs_client_id4) XdrPointer() interface{} { return v } +func (Nfs_client_id4) XdrTypeName() string { return "Nfs_client_id4" } +func (v Nfs_client_id4) XdrValue() interface{} { return v } +func (v *Nfs_client_id4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Nfs_client_id4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sverifier", name), XDR_Verifier4(&v.Verifier)) + x.Marshal(x.Sprintf("%sid", name), XdrVecOpaque{&v.Id, NFS4_OPAQUE_LIMIT}) +} +func XDR_Nfs_client_id4(v *Nfs_client_id4) *Nfs_client_id4 { return v } +type XdrType_Open_owner4 = *Open_owner4 +func (v *Open_owner4) XdrPointer() interface{} { return v } +func (Open_owner4) XdrTypeName() string { return "Open_owner4" } +func (v Open_owner4) XdrValue() interface{} { return v } +func (v *Open_owner4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Open_owner4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclientid", name), XDR_Clientid4(&v.Clientid)) + x.Marshal(x.Sprintf("%sowner", name), XdrVecOpaque{&v.Owner, NFS4_OPAQUE_LIMIT}) +} +func XDR_Open_owner4(v *Open_owner4) *Open_owner4 { return v } +type XdrType_Lock_owner4 = *Lock_owner4 +func (v *Lock_owner4) XdrPointer() interface{} { return v } +func (Lock_owner4) XdrTypeName() string { return "Lock_owner4" } +func (v Lock_owner4) XdrValue() interface{} { return v } +func (v *Lock_owner4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Lock_owner4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclientid", name), XDR_Clientid4(&v.Clientid)) + x.Marshal(x.Sprintf("%sowner", name), XdrVecOpaque{&v.Owner, NFS4_OPAQUE_LIMIT}) +} +func XDR_Lock_owner4(v *Lock_owner4) *Lock_owner4 { return v } +var _XdrNames_Nfs_lock_type4 = map[int32]string{ + int32(READ_LT): "READ_LT", + int32(WRITE_LT): "WRITE_LT", + int32(READW_LT): "READW_LT", + int32(WRITEW_LT): "WRITEW_LT", +} +var _XdrValues_Nfs_lock_type4 = map[string]int32{ + "READ_LT": int32(READ_LT), + "WRITE_LT": int32(WRITE_LT), + "READW_LT": int32(READW_LT), + "WRITEW_LT": int32(WRITEW_LT), +} +func (Nfs_lock_type4) XdrEnumNames() map[int32]string { + return _XdrNames_Nfs_lock_type4 +} +func (v Nfs_lock_type4) String() string { + if s, ok := _XdrNames_Nfs_lock_type4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Nfs_lock_type4#%d", v) +} +func (v *Nfs_lock_type4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Nfs_lock_type4[stok]; ok { + *v = Nfs_lock_type4(val) + return nil + } else if stok == "Nfs_lock_type4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Nfs_lock_type4.", stok)) + } +} +func (v Nfs_lock_type4) GetU32() uint32 { return uint32(v) } +func (v *Nfs_lock_type4) SetU32(n uint32) { *v = Nfs_lock_type4(n) } +func (v *Nfs_lock_type4) XdrPointer() interface{} { return v } +func (Nfs_lock_type4) XdrTypeName() string { return "Nfs_lock_type4" } +func (v Nfs_lock_type4) XdrValue() interface{} { return v } +func (v *Nfs_lock_type4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Nfs_lock_type4 = *Nfs_lock_type4 +func XDR_Nfs_lock_type4(v *Nfs_lock_type4) *Nfs_lock_type4 { return v } +func (v *Nfs_lock_type4) XdrInitialize() { + switch Nfs_lock_type4(0) { + case READ_LT, WRITE_LT, READW_LT, WRITEW_LT: + default: + if *v == Nfs_lock_type4(0) { *v = READ_LT } + } +} +type XdrType_ACCESS4args = *ACCESS4args +func (v *ACCESS4args) XdrPointer() interface{} { return v } +func (ACCESS4args) XdrTypeName() string { return "ACCESS4args" } +func (v ACCESS4args) XdrValue() interface{} { return v } +func (v *ACCESS4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *ACCESS4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%saccess", name), XDR_Uint32_t(&v.Access)) +} +func XDR_ACCESS4args(v *ACCESS4args) *ACCESS4args { return v } +type XdrType_ACCESS4resok = *ACCESS4resok +func (v *ACCESS4resok) XdrPointer() interface{} { return v } +func (ACCESS4resok) XdrTypeName() string { return "ACCESS4resok" } +func (v ACCESS4resok) XdrValue() interface{} { return v } +func (v *ACCESS4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *ACCESS4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%ssupported", name), XDR_Uint32_t(&v.Supported)) + x.Marshal(x.Sprintf("%saccess", name), XDR_Uint32_t(&v.Access)) +} +func XDR_ACCESS4resok(v *ACCESS4resok) *ACCESS4resok { return v } +func (u *ACCESS4res) Resok4() *ACCESS4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*ACCESS4resok); ok { + return v + } else { + var zero ACCESS4resok + u.U = &zero + return &zero + } + default: + XdrPanic("ACCESS4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u ACCESS4res) XdrValid() bool { + return true +} +func (u *ACCESS4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *ACCESS4res) XdrUnionTagName() string { + return "Status" +} +func (u *ACCESS4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_ACCESS4resok(u.Resok4()) + default: + return nil + } +} +func (u *ACCESS4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_ACCESS4res = *ACCESS4res +func (v *ACCESS4res) XdrPointer() interface{} { return v } +func (ACCESS4res) XdrTypeName() string { return "ACCESS4res" } +func (v ACCESS4res) XdrValue() interface{} { return v } +func (v *ACCESS4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *ACCESS4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_ACCESS4resok(u.Resok4())) + return + default: + return + } +} +func XDR_ACCESS4res(v *ACCESS4res) *ACCESS4res { return v} +type XdrType_CLOSE4args = *CLOSE4args +func (v *CLOSE4args) XdrPointer() interface{} { return v } +func (CLOSE4args) XdrTypeName() string { return "CLOSE4args" } +func (v CLOSE4args) XdrValue() interface{} { return v } +func (v *CLOSE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CLOSE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sseqid", name), XDR_Seqid4(&v.Seqid)) + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(&v.Open_stateid)) +} +func XDR_CLOSE4args(v *CLOSE4args) *CLOSE4args { return v } +func (u *CLOSE4res) Open_stateid() *Stateid4 { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*Stateid4); ok { + return v + } else { + var zero Stateid4 + u.U = &zero + return &zero + } + default: + XdrPanic("CLOSE4res.Open_stateid accessed when Status == %v", u.Status) + return nil + } +} +func (u CLOSE4res) XdrValid() bool { + return true +} +func (u *CLOSE4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *CLOSE4res) XdrUnionTagName() string { + return "Status" +} +func (u *CLOSE4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_Stateid4(u.Open_stateid()) + default: + return nil + } +} +func (u *CLOSE4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Open_stateid" + default: + return "" + } +} +type XdrType_CLOSE4res = *CLOSE4res +func (v *CLOSE4res) XdrPointer() interface{} { return v } +func (CLOSE4res) XdrTypeName() string { return "CLOSE4res" } +func (v CLOSE4res) XdrValue() interface{} { return v } +func (v *CLOSE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *CLOSE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(u.Open_stateid())) + return + default: + return + } +} +func XDR_CLOSE4res(v *CLOSE4res) *CLOSE4res { return v} +type XdrType_COMMIT4args = *COMMIT4args +func (v *COMMIT4args) XdrPointer() interface{} { return v } +func (COMMIT4args) XdrTypeName() string { return "COMMIT4args" } +func (v COMMIT4args) XdrValue() interface{} { return v } +func (v *COMMIT4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *COMMIT4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%scount", name), XDR_Count4(&v.Count)) +} +func XDR_COMMIT4args(v *COMMIT4args) *COMMIT4args { return v } +type XdrType_COMMIT4resok = *COMMIT4resok +func (v *COMMIT4resok) XdrPointer() interface{} { return v } +func (COMMIT4resok) XdrTypeName() string { return "COMMIT4resok" } +func (v COMMIT4resok) XdrValue() interface{} { return v } +func (v *COMMIT4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *COMMIT4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%swriteverf", name), XDR_Verifier4(&v.Writeverf)) +} +func XDR_COMMIT4resok(v *COMMIT4resok) *COMMIT4resok { return v } +func (u *COMMIT4res) Resok4() *COMMIT4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*COMMIT4resok); ok { + return v + } else { + var zero COMMIT4resok + u.U = &zero + return &zero + } + default: + XdrPanic("COMMIT4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u COMMIT4res) XdrValid() bool { + return true +} +func (u *COMMIT4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *COMMIT4res) XdrUnionTagName() string { + return "Status" +} +func (u *COMMIT4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_COMMIT4resok(u.Resok4()) + default: + return nil + } +} +func (u *COMMIT4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_COMMIT4res = *COMMIT4res +func (v *COMMIT4res) XdrPointer() interface{} { return v } +func (COMMIT4res) XdrTypeName() string { return "COMMIT4res" } +func (v COMMIT4res) XdrValue() interface{} { return v } +func (v *COMMIT4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *COMMIT4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_COMMIT4resok(u.Resok4())) + return + default: + return + } +} +func XDR_COMMIT4res(v *COMMIT4res) *COMMIT4res { return v} +func (u *Createtype4) Linkdata() *Linktext4 { + switch u.Type { + case NF4LNK: + if v, ok := u.U.(*Linktext4); ok { + return v + } else { + var zero Linktext4 + u.U = &zero + return &zero + } + default: + XdrPanic("Createtype4.Linkdata accessed when Type == %v", u.Type) + return nil + } +} +func (u *Createtype4) Devdata() *Specdata4 { + switch u.Type { + case NF4BLK, NF4CHR: + if v, ok := u.U.(*Specdata4); ok { + return v + } else { + var zero Specdata4 + u.U = &zero + return &zero + } + default: + XdrPanic("Createtype4.Devdata accessed when Type == %v", u.Type) + return nil + } +} +func (u Createtype4) XdrValid() bool { + return true +} +func (u *Createtype4) XdrUnionTag() XdrNum32 { + return XDR_Nfs_ftype4(&u.Type) +} +func (u *Createtype4) XdrUnionTagName() string { + return "Type" +} +func (u *Createtype4) XdrUnionBody() XdrType { + switch u.Type { + case NF4LNK: + return XDR_Linktext4(u.Linkdata()) + case NF4BLK, NF4CHR: + return XDR_Specdata4(u.Devdata()) + case NF4SOCK, NF4FIFO, NF4DIR: + return nil + default: + return nil + } +} +func (u *Createtype4) XdrUnionBodyName() string { + switch u.Type { + case NF4LNK: + return "Linkdata" + case NF4BLK, NF4CHR: + return "Devdata" + case NF4SOCK, NF4FIFO, NF4DIR: + return "" + default: + return "" + } +} +type XdrType_Createtype4 = *Createtype4 +func (v *Createtype4) XdrPointer() interface{} { return v } +func (Createtype4) XdrTypeName() string { return "Createtype4" } +func (v Createtype4) XdrValue() interface{} { return v } +func (v *Createtype4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Createtype4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfs_ftype4(&u.Type).XdrMarshal(x, x.Sprintf("%stype", name)) + switch u.Type { + case NF4LNK: + x.Marshal(x.Sprintf("%slinkdata", name), XDR_Linktext4(u.Linkdata())) + return + case NF4BLK, NF4CHR: + x.Marshal(x.Sprintf("%sdevdata", name), XDR_Specdata4(u.Devdata())) + return + case NF4SOCK, NF4FIFO, NF4DIR: + return + default: + return + } +} +func XDR_Createtype4(v *Createtype4) *Createtype4 { return v} +type XdrType_CREATE4args = *CREATE4args +func (v *CREATE4args) XdrPointer() interface{} { return v } +func (CREATE4args) XdrTypeName() string { return "CREATE4args" } +func (v CREATE4args) XdrValue() interface{} { return v } +func (v *CREATE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CREATE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobjtype", name), XDR_Createtype4(&v.Objtype)) + x.Marshal(x.Sprintf("%sobjname", name), XDR_Component4(&v.Objname)) + x.Marshal(x.Sprintf("%screateattrs", name), XDR_Fattr4(&v.Createattrs)) +} +func XDR_CREATE4args(v *CREATE4args) *CREATE4args { return v } +type XdrType_CREATE4resok = *CREATE4resok +func (v *CREATE4resok) XdrPointer() interface{} { return v } +func (CREATE4resok) XdrTypeName() string { return "CREATE4resok" } +func (v CREATE4resok) XdrValue() interface{} { return v } +func (v *CREATE4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CREATE4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scinfo", name), XDR_Change_info4(&v.Cinfo)) + x.Marshal(x.Sprintf("%sattrset", name), XDR_Bitmap4(&v.Attrset)) +} +func XDR_CREATE4resok(v *CREATE4resok) *CREATE4resok { return v } +func (u *CREATE4res) Resok4() *CREATE4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*CREATE4resok); ok { + return v + } else { + var zero CREATE4resok + u.U = &zero + return &zero + } + default: + XdrPanic("CREATE4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u CREATE4res) XdrValid() bool { + return true +} +func (u *CREATE4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *CREATE4res) XdrUnionTagName() string { + return "Status" +} +func (u *CREATE4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_CREATE4resok(u.Resok4()) + default: + return nil + } +} +func (u *CREATE4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_CREATE4res = *CREATE4res +func (v *CREATE4res) XdrPointer() interface{} { return v } +func (CREATE4res) XdrTypeName() string { return "CREATE4res" } +func (v CREATE4res) XdrValue() interface{} { return v } +func (v *CREATE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *CREATE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_CREATE4resok(u.Resok4())) + return + default: + return + } +} +func XDR_CREATE4res(v *CREATE4res) *CREATE4res { return v} +type XdrType_DELEGPURGE4args = *DELEGPURGE4args +func (v *DELEGPURGE4args) XdrPointer() interface{} { return v } +func (DELEGPURGE4args) XdrTypeName() string { return "DELEGPURGE4args" } +func (v DELEGPURGE4args) XdrValue() interface{} { return v } +func (v *DELEGPURGE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DELEGPURGE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclientid", name), XDR_Clientid4(&v.Clientid)) +} +func XDR_DELEGPURGE4args(v *DELEGPURGE4args) *DELEGPURGE4args { return v } +type XdrType_DELEGPURGE4res = *DELEGPURGE4res +func (v *DELEGPURGE4res) XdrPointer() interface{} { return v } +func (DELEGPURGE4res) XdrTypeName() string { return "DELEGPURGE4res" } +func (v DELEGPURGE4res) XdrValue() interface{} { return v } +func (v *DELEGPURGE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DELEGPURGE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_DELEGPURGE4res(v *DELEGPURGE4res) *DELEGPURGE4res { return v } +type XdrType_DELEGRETURN4args = *DELEGRETURN4args +func (v *DELEGRETURN4args) XdrPointer() interface{} { return v } +func (DELEGRETURN4args) XdrTypeName() string { return "DELEGRETURN4args" } +func (v DELEGRETURN4args) XdrValue() interface{} { return v } +func (v *DELEGRETURN4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DELEGRETURN4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sdeleg_stateid", name), XDR_Stateid4(&v.Deleg_stateid)) +} +func XDR_DELEGRETURN4args(v *DELEGRETURN4args) *DELEGRETURN4args { return v } +type XdrType_DELEGRETURN4res = *DELEGRETURN4res +func (v *DELEGRETURN4res) XdrPointer() interface{} { return v } +func (DELEGRETURN4res) XdrTypeName() string { return "DELEGRETURN4res" } +func (v DELEGRETURN4res) XdrValue() interface{} { return v } +func (v *DELEGRETURN4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DELEGRETURN4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_DELEGRETURN4res(v *DELEGRETURN4res) *DELEGRETURN4res { return v } +type XdrType_GETATTR4args = *GETATTR4args +func (v *GETATTR4args) XdrPointer() interface{} { return v } +func (GETATTR4args) XdrTypeName() string { return "GETATTR4args" } +func (v GETATTR4args) XdrValue() interface{} { return v } +func (v *GETATTR4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETATTR4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sattr_request", name), XDR_Bitmap4(&v.Attr_request)) +} +func XDR_GETATTR4args(v *GETATTR4args) *GETATTR4args { return v } +type XdrType_GETATTR4resok = *GETATTR4resok +func (v *GETATTR4resok) XdrPointer() interface{} { return v } +func (GETATTR4resok) XdrTypeName() string { return "GETATTR4resok" } +func (v GETATTR4resok) XdrValue() interface{} { return v } +func (v *GETATTR4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETATTR4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobj_attributes", name), XDR_Fattr4(&v.Obj_attributes)) +} +func XDR_GETATTR4resok(v *GETATTR4resok) *GETATTR4resok { return v } +func (u *GETATTR4res) Resok4() *GETATTR4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*GETATTR4resok); ok { + return v + } else { + var zero GETATTR4resok + u.U = &zero + return &zero + } + default: + XdrPanic("GETATTR4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u GETATTR4res) XdrValid() bool { + return true +} +func (u *GETATTR4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *GETATTR4res) XdrUnionTagName() string { + return "Status" +} +func (u *GETATTR4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_GETATTR4resok(u.Resok4()) + default: + return nil + } +} +func (u *GETATTR4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_GETATTR4res = *GETATTR4res +func (v *GETATTR4res) XdrPointer() interface{} { return v } +func (GETATTR4res) XdrTypeName() string { return "GETATTR4res" } +func (v GETATTR4res) XdrValue() interface{} { return v } +func (v *GETATTR4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *GETATTR4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_GETATTR4resok(u.Resok4())) + return + default: + return + } +} +func XDR_GETATTR4res(v *GETATTR4res) *GETATTR4res { return v} +type XdrType_GETFH4resok = *GETFH4resok +func (v *GETFH4resok) XdrPointer() interface{} { return v } +func (GETFH4resok) XdrTypeName() string { return "GETFH4resok" } +func (v GETFH4resok) XdrValue() interface{} { return v } +func (v *GETFH4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETFH4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobject", name), XDR_Nfs_fh4(&v.Object)) +} +func XDR_GETFH4resok(v *GETFH4resok) *GETFH4resok { return v } +func (u *GETFH4res) Resok4() *GETFH4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*GETFH4resok); ok { + return v + } else { + var zero GETFH4resok + u.U = &zero + return &zero + } + default: + XdrPanic("GETFH4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u GETFH4res) XdrValid() bool { + return true +} +func (u *GETFH4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *GETFH4res) XdrUnionTagName() string { + return "Status" +} +func (u *GETFH4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_GETFH4resok(u.Resok4()) + default: + return nil + } +} +func (u *GETFH4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_GETFH4res = *GETFH4res +func (v *GETFH4res) XdrPointer() interface{} { return v } +func (GETFH4res) XdrTypeName() string { return "GETFH4res" } +func (v GETFH4res) XdrValue() interface{} { return v } +func (v *GETFH4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *GETFH4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_GETFH4resok(u.Resok4())) + return + default: + return + } +} +func XDR_GETFH4res(v *GETFH4res) *GETFH4res { return v} +type XdrType_LINK4args = *LINK4args +func (v *LINK4args) XdrPointer() interface{} { return v } +func (LINK4args) XdrTypeName() string { return "LINK4args" } +func (v LINK4args) XdrValue() interface{} { return v } +func (v *LINK4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LINK4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%snewname", name), XDR_Component4(&v.Newname)) +} +func XDR_LINK4args(v *LINK4args) *LINK4args { return v } +type XdrType_LINK4resok = *LINK4resok +func (v *LINK4resok) XdrPointer() interface{} { return v } +func (LINK4resok) XdrTypeName() string { return "LINK4resok" } +func (v LINK4resok) XdrValue() interface{} { return v } +func (v *LINK4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LINK4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scinfo", name), XDR_Change_info4(&v.Cinfo)) +} +func XDR_LINK4resok(v *LINK4resok) *LINK4resok { return v } +func (u *LINK4res) Resok4() *LINK4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*LINK4resok); ok { + return v + } else { + var zero LINK4resok + u.U = &zero + return &zero + } + default: + XdrPanic("LINK4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u LINK4res) XdrValid() bool { + return true +} +func (u *LINK4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *LINK4res) XdrUnionTagName() string { + return "Status" +} +func (u *LINK4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_LINK4resok(u.Resok4()) + default: + return nil + } +} +func (u *LINK4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_LINK4res = *LINK4res +func (v *LINK4res) XdrPointer() interface{} { return v } +func (LINK4res) XdrTypeName() string { return "LINK4res" } +func (v LINK4res) XdrValue() interface{} { return v } +func (v *LINK4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LINK4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_LINK4resok(u.Resok4())) + return + default: + return + } +} +func XDR_LINK4res(v *LINK4res) *LINK4res { return v} +type XdrType_Open_to_lock_owner4 = *Open_to_lock_owner4 +func (v *Open_to_lock_owner4) XdrPointer() interface{} { return v } +func (Open_to_lock_owner4) XdrTypeName() string { return "Open_to_lock_owner4" } +func (v Open_to_lock_owner4) XdrValue() interface{} { return v } +func (v *Open_to_lock_owner4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Open_to_lock_owner4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sopen_seqid", name), XDR_Seqid4(&v.Open_seqid)) + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(&v.Open_stateid)) + x.Marshal(x.Sprintf("%slock_seqid", name), XDR_Seqid4(&v.Lock_seqid)) + x.Marshal(x.Sprintf("%slock_owner", name), XDR_Lock_owner4(&v.Lock_owner)) +} +func XDR_Open_to_lock_owner4(v *Open_to_lock_owner4) *Open_to_lock_owner4 { return v } +type XdrType_Exist_lock_owner4 = *Exist_lock_owner4 +func (v *Exist_lock_owner4) XdrPointer() interface{} { return v } +func (Exist_lock_owner4) XdrTypeName() string { return "Exist_lock_owner4" } +func (v Exist_lock_owner4) XdrValue() interface{} { return v } +func (v *Exist_lock_owner4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Exist_lock_owner4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slock_stateid", name), XDR_Stateid4(&v.Lock_stateid)) + x.Marshal(x.Sprintf("%slock_seqid", name), XDR_Seqid4(&v.Lock_seqid)) +} +func XDR_Exist_lock_owner4(v *Exist_lock_owner4) *Exist_lock_owner4 { return v } +var _XdrTags_Locker4 = map[int32]bool{ + XdrToI32(true): true, + XdrToI32(false): true, +} +func (_ Locker4) XdrValidTags() map[int32]bool { + return _XdrTags_Locker4 +} +func (u *Locker4) Open_owner() *Open_to_lock_owner4 { + switch u.New_lock_owner { + case true: + if v, ok := u.U.(*Open_to_lock_owner4); ok { + return v + } else { + var zero Open_to_lock_owner4 + u.U = &zero + return &zero + } + default: + XdrPanic("Locker4.Open_owner accessed when New_lock_owner == %v", u.New_lock_owner) + return nil + } +} +func (u *Locker4) Lock_owner() *Exist_lock_owner4 { + switch u.New_lock_owner { + case false: + if v, ok := u.U.(*Exist_lock_owner4); ok { + return v + } else { + var zero Exist_lock_owner4 + u.U = &zero + return &zero + } + default: + XdrPanic("Locker4.Lock_owner accessed when New_lock_owner == %v", u.New_lock_owner) + return nil + } +} +func (u Locker4) XdrValid() bool { + switch u.New_lock_owner { + case true,false: + return true + } + return false +} +func (u *Locker4) XdrUnionTag() XdrNum32 { + return XDR_bool(&u.New_lock_owner) +} +func (u *Locker4) XdrUnionTagName() string { + return "New_lock_owner" +} +func (u *Locker4) XdrUnionBody() XdrType { + switch u.New_lock_owner { + case true: + return XDR_Open_to_lock_owner4(u.Open_owner()) + case false: + return XDR_Exist_lock_owner4(u.Lock_owner()) + } + return nil +} +func (u *Locker4) XdrUnionBodyName() string { + switch u.New_lock_owner { + case true: + return "Open_owner" + case false: + return "Lock_owner" + } + return "" +} +type XdrType_Locker4 = *Locker4 +func (v *Locker4) XdrPointer() interface{} { return v } +func (Locker4) XdrTypeName() string { return "Locker4" } +func (v Locker4) XdrValue() interface{} { return v } +func (v *Locker4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Locker4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_bool(&u.New_lock_owner).XdrMarshal(x, x.Sprintf("%snew_lock_owner", name)) + switch u.New_lock_owner { + case true: + x.Marshal(x.Sprintf("%sopen_owner", name), XDR_Open_to_lock_owner4(u.Open_owner())) + return + case false: + x.Marshal(x.Sprintf("%slock_owner", name), XDR_Exist_lock_owner4(u.Lock_owner())) + return + } + XdrPanic("invalid New_lock_owner (%v) in Locker4", u.New_lock_owner) +} +func XDR_Locker4(v *Locker4) *Locker4 { return v} +type XdrType_LOCK4args = *LOCK4args +func (v *LOCK4args) XdrPointer() interface{} { return v } +func (LOCK4args) XdrTypeName() string { return "LOCK4args" } +func (v LOCK4args) XdrValue() interface{} { return v } +func (v *LOCK4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOCK4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slocktype", name), XDR_Nfs_lock_type4(&v.Locktype)) + x.Marshal(x.Sprintf("%sreclaim", name), XDR_bool(&v.Reclaim)) + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%slength", name), XDR_Length4(&v.Length)) + x.Marshal(x.Sprintf("%slocker", name), XDR_Locker4(&v.Locker)) +} +func XDR_LOCK4args(v *LOCK4args) *LOCK4args { return v } +type XdrType_LOCK4denied = *LOCK4denied +func (v *LOCK4denied) XdrPointer() interface{} { return v } +func (LOCK4denied) XdrTypeName() string { return "LOCK4denied" } +func (v LOCK4denied) XdrValue() interface{} { return v } +func (v *LOCK4denied) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOCK4denied) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%slength", name), XDR_Length4(&v.Length)) + x.Marshal(x.Sprintf("%slocktype", name), XDR_Nfs_lock_type4(&v.Locktype)) + x.Marshal(x.Sprintf("%sowner", name), XDR_Lock_owner4(&v.Owner)) +} +func XDR_LOCK4denied(v *LOCK4denied) *LOCK4denied { return v } +type XdrType_LOCK4resok = *LOCK4resok +func (v *LOCK4resok) XdrPointer() interface{} { return v } +func (LOCK4resok) XdrTypeName() string { return "LOCK4resok" } +func (v LOCK4resok) XdrValue() interface{} { return v } +func (v *LOCK4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOCK4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slock_stateid", name), XDR_Stateid4(&v.Lock_stateid)) +} +func XDR_LOCK4resok(v *LOCK4resok) *LOCK4resok { return v } +func (u *LOCK4res) Resok4() *LOCK4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*LOCK4resok); ok { + return v + } else { + var zero LOCK4resok + u.U = &zero + return &zero + } + default: + XdrPanic("LOCK4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u *LOCK4res) Denied() *LOCK4denied { + switch u.Status { + case NFS4ERR_DENIED: + if v, ok := u.U.(*LOCK4denied); ok { + return v + } else { + var zero LOCK4denied + u.U = &zero + return &zero + } + default: + XdrPanic("LOCK4res.Denied accessed when Status == %v", u.Status) + return nil + } +} +func (u LOCK4res) XdrValid() bool { + return true +} +func (u *LOCK4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *LOCK4res) XdrUnionTagName() string { + return "Status" +} +func (u *LOCK4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_LOCK4resok(u.Resok4()) + case NFS4ERR_DENIED: + return XDR_LOCK4denied(u.Denied()) + default: + return nil + } +} +func (u *LOCK4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + case NFS4ERR_DENIED: + return "Denied" + default: + return "" + } +} +type XdrType_LOCK4res = *LOCK4res +func (v *LOCK4res) XdrPointer() interface{} { return v } +func (LOCK4res) XdrTypeName() string { return "LOCK4res" } +func (v LOCK4res) XdrValue() interface{} { return v } +func (v *LOCK4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LOCK4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_LOCK4resok(u.Resok4())) + return + case NFS4ERR_DENIED: + x.Marshal(x.Sprintf("%sdenied", name), XDR_LOCK4denied(u.Denied())) + return + default: + return + } +} +func XDR_LOCK4res(v *LOCK4res) *LOCK4res { return v} +type XdrType_LOCKT4args = *LOCKT4args +func (v *LOCKT4args) XdrPointer() interface{} { return v } +func (LOCKT4args) XdrTypeName() string { return "LOCKT4args" } +func (v LOCKT4args) XdrValue() interface{} { return v } +func (v *LOCKT4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOCKT4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slocktype", name), XDR_Nfs_lock_type4(&v.Locktype)) + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%slength", name), XDR_Length4(&v.Length)) + x.Marshal(x.Sprintf("%sowner", name), XDR_Lock_owner4(&v.Owner)) +} +func XDR_LOCKT4args(v *LOCKT4args) *LOCKT4args { return v } +func (u *LOCKT4res) Denied() *LOCK4denied { + switch u.Status { + case NFS4ERR_DENIED: + if v, ok := u.U.(*LOCK4denied); ok { + return v + } else { + var zero LOCK4denied + u.U = &zero + return &zero + } + default: + XdrPanic("LOCKT4res.Denied accessed when Status == %v", u.Status) + return nil + } +} +func (u LOCKT4res) XdrValid() bool { + return true +} +func (u *LOCKT4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *LOCKT4res) XdrUnionTagName() string { + return "Status" +} +func (u *LOCKT4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4ERR_DENIED: + return XDR_LOCK4denied(u.Denied()) + case NFS4_OK: + return nil + default: + return nil + } +} +func (u *LOCKT4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4ERR_DENIED: + return "Denied" + case NFS4_OK: + return "" + default: + return "" + } +} +type XdrType_LOCKT4res = *LOCKT4res +func (v *LOCKT4res) XdrPointer() interface{} { return v } +func (LOCKT4res) XdrTypeName() string { return "LOCKT4res" } +func (v LOCKT4res) XdrValue() interface{} { return v } +func (v *LOCKT4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LOCKT4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4ERR_DENIED: + x.Marshal(x.Sprintf("%sdenied", name), XDR_LOCK4denied(u.Denied())) + return + case NFS4_OK: + return + default: + return + } +} +func XDR_LOCKT4res(v *LOCKT4res) *LOCKT4res { return v} +type XdrType_LOCKU4args = *LOCKU4args +func (v *LOCKU4args) XdrPointer() interface{} { return v } +func (LOCKU4args) XdrTypeName() string { return "LOCKU4args" } +func (v LOCKU4args) XdrValue() interface{} { return v } +func (v *LOCKU4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOCKU4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slocktype", name), XDR_Nfs_lock_type4(&v.Locktype)) + x.Marshal(x.Sprintf("%sseqid", name), XDR_Seqid4(&v.Seqid)) + x.Marshal(x.Sprintf("%slock_stateid", name), XDR_Stateid4(&v.Lock_stateid)) + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%slength", name), XDR_Length4(&v.Length)) +} +func XDR_LOCKU4args(v *LOCKU4args) *LOCKU4args { return v } +func (u *LOCKU4res) Lock_stateid() *Stateid4 { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*Stateid4); ok { + return v + } else { + var zero Stateid4 + u.U = &zero + return &zero + } + default: + XdrPanic("LOCKU4res.Lock_stateid accessed when Status == %v", u.Status) + return nil + } +} +func (u LOCKU4res) XdrValid() bool { + return true +} +func (u *LOCKU4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *LOCKU4res) XdrUnionTagName() string { + return "Status" +} +func (u *LOCKU4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_Stateid4(u.Lock_stateid()) + default: + return nil + } +} +func (u *LOCKU4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Lock_stateid" + default: + return "" + } +} +type XdrType_LOCKU4res = *LOCKU4res +func (v *LOCKU4res) XdrPointer() interface{} { return v } +func (LOCKU4res) XdrTypeName() string { return "LOCKU4res" } +func (v LOCKU4res) XdrValue() interface{} { return v } +func (v *LOCKU4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LOCKU4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%slock_stateid", name), XDR_Stateid4(u.Lock_stateid())) + return + default: + return + } +} +func XDR_LOCKU4res(v *LOCKU4res) *LOCKU4res { return v} +type XdrType_LOOKUP4args = *LOOKUP4args +func (v *LOOKUP4args) XdrPointer() interface{} { return v } +func (LOOKUP4args) XdrTypeName() string { return "LOOKUP4args" } +func (v LOOKUP4args) XdrValue() interface{} { return v } +func (v *LOOKUP4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOOKUP4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobjname", name), XDR_Component4(&v.Objname)) +} +func XDR_LOOKUP4args(v *LOOKUP4args) *LOOKUP4args { return v } +type XdrType_LOOKUP4res = *LOOKUP4res +func (v *LOOKUP4res) XdrPointer() interface{} { return v } +func (LOOKUP4res) XdrTypeName() string { return "LOOKUP4res" } +func (v LOOKUP4res) XdrValue() interface{} { return v } +func (v *LOOKUP4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOOKUP4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_LOOKUP4res(v *LOOKUP4res) *LOOKUP4res { return v } +type XdrType_LOOKUPP4res = *LOOKUPP4res +func (v *LOOKUPP4res) XdrPointer() interface{} { return v } +func (LOOKUPP4res) XdrTypeName() string { return "LOOKUPP4res" } +func (v LOOKUPP4res) XdrValue() interface{} { return v } +func (v *LOOKUPP4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LOOKUPP4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_LOOKUPP4res(v *LOOKUPP4res) *LOOKUPP4res { return v } +type XdrType_NVERIFY4args = *NVERIFY4args +func (v *NVERIFY4args) XdrPointer() interface{} { return v } +func (NVERIFY4args) XdrTypeName() string { return "NVERIFY4args" } +func (v NVERIFY4args) XdrValue() interface{} { return v } +func (v *NVERIFY4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *NVERIFY4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobj_attributes", name), XDR_Fattr4(&v.Obj_attributes)) +} +func XDR_NVERIFY4args(v *NVERIFY4args) *NVERIFY4args { return v } +type XdrType_NVERIFY4res = *NVERIFY4res +func (v *NVERIFY4res) XdrPointer() interface{} { return v } +func (NVERIFY4res) XdrTypeName() string { return "NVERIFY4res" } +func (v NVERIFY4res) XdrValue() interface{} { return v } +func (v *NVERIFY4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *NVERIFY4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_NVERIFY4res(v *NVERIFY4res) *NVERIFY4res { return v } +var _XdrNames_Createmode4 = map[int32]string{ + int32(UNCHECKED4): "UNCHECKED4", + int32(GUARDED4): "GUARDED4", + int32(EXCLUSIVE4): "EXCLUSIVE4", +} +var _XdrValues_Createmode4 = map[string]int32{ + "UNCHECKED4": int32(UNCHECKED4), + "GUARDED4": int32(GUARDED4), + "EXCLUSIVE4": int32(EXCLUSIVE4), +} +func (Createmode4) XdrEnumNames() map[int32]string { + return _XdrNames_Createmode4 +} +func (v Createmode4) String() string { + if s, ok := _XdrNames_Createmode4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Createmode4#%d", v) +} +func (v *Createmode4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Createmode4[stok]; ok { + *v = Createmode4(val) + return nil + } else if stok == "Createmode4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Createmode4.", stok)) + } +} +func (v Createmode4) GetU32() uint32 { return uint32(v) } +func (v *Createmode4) SetU32(n uint32) { *v = Createmode4(n) } +func (v *Createmode4) XdrPointer() interface{} { return v } +func (Createmode4) XdrTypeName() string { return "Createmode4" } +func (v Createmode4) XdrValue() interface{} { return v } +func (v *Createmode4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Createmode4 = *Createmode4 +func XDR_Createmode4(v *Createmode4) *Createmode4 { return v } +var _XdrTags_Createhow4 = map[int32]bool{ + XdrToI32(UNCHECKED4): true, + XdrToI32(GUARDED4): true, + XdrToI32(EXCLUSIVE4): true, +} +func (_ Createhow4) XdrValidTags() map[int32]bool { + return _XdrTags_Createhow4 +} +func (u *Createhow4) Createattrs() *Fattr4 { + switch u.Mode { + case UNCHECKED4, GUARDED4: + if v, ok := u.U.(*Fattr4); ok { + return v + } else { + var zero Fattr4 + u.U = &zero + return &zero + } + default: + XdrPanic("Createhow4.Createattrs accessed when Mode == %v", u.Mode) + return nil + } +} +func (u *Createhow4) Createverf() *Verifier4 { + switch u.Mode { + case EXCLUSIVE4: + if v, ok := u.U.(*Verifier4); ok { + return v + } else { + var zero Verifier4 + u.U = &zero + return &zero + } + default: + XdrPanic("Createhow4.Createverf accessed when Mode == %v", u.Mode) + return nil + } +} +func (u Createhow4) XdrValid() bool { + switch u.Mode { + case UNCHECKED4, GUARDED4,EXCLUSIVE4: + return true + } + return false +} +func (u *Createhow4) XdrUnionTag() XdrNum32 { + return XDR_Createmode4(&u.Mode) +} +func (u *Createhow4) XdrUnionTagName() string { + return "Mode" +} +func (u *Createhow4) XdrUnionBody() XdrType { + switch u.Mode { + case UNCHECKED4, GUARDED4: + return XDR_Fattr4(u.Createattrs()) + case EXCLUSIVE4: + return XDR_Verifier4(u.Createverf()) + } + return nil +} +func (u *Createhow4) XdrUnionBodyName() string { + switch u.Mode { + case UNCHECKED4, GUARDED4: + return "Createattrs" + case EXCLUSIVE4: + return "Createverf" + } + return "" +} +type XdrType_Createhow4 = *Createhow4 +func (v *Createhow4) XdrPointer() interface{} { return v } +func (Createhow4) XdrTypeName() string { return "Createhow4" } +func (v Createhow4) XdrValue() interface{} { return v } +func (v *Createhow4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Createhow4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Createmode4(&u.Mode).XdrMarshal(x, x.Sprintf("%smode", name)) + switch u.Mode { + case UNCHECKED4, GUARDED4: + x.Marshal(x.Sprintf("%screateattrs", name), XDR_Fattr4(u.Createattrs())) + return + case EXCLUSIVE4: + x.Marshal(x.Sprintf("%screateverf", name), XDR_Verifier4(u.Createverf())) + return + } + XdrPanic("invalid Mode (%v) in Createhow4", u.Mode) +} +func XDR_Createhow4(v *Createhow4) *Createhow4 { return v} +var _XdrNames_Opentype4 = map[int32]string{ + int32(OPEN4_NOCREATE): "OPEN4_NOCREATE", + int32(OPEN4_CREATE): "OPEN4_CREATE", +} +var _XdrValues_Opentype4 = map[string]int32{ + "OPEN4_NOCREATE": int32(OPEN4_NOCREATE), + "OPEN4_CREATE": int32(OPEN4_CREATE), +} +func (Opentype4) XdrEnumNames() map[int32]string { + return _XdrNames_Opentype4 +} +func (v Opentype4) String() string { + if s, ok := _XdrNames_Opentype4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Opentype4#%d", v) +} +func (v *Opentype4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Opentype4[stok]; ok { + *v = Opentype4(val) + return nil + } else if stok == "Opentype4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Opentype4.", stok)) + } +} +func (v Opentype4) GetU32() uint32 { return uint32(v) } +func (v *Opentype4) SetU32(n uint32) { *v = Opentype4(n) } +func (v *Opentype4) XdrPointer() interface{} { return v } +func (Opentype4) XdrTypeName() string { return "Opentype4" } +func (v Opentype4) XdrValue() interface{} { return v } +func (v *Opentype4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Opentype4 = *Opentype4 +func XDR_Opentype4(v *Opentype4) *Opentype4 { return v } +func (u *Openflag4) How() *Createhow4 { + switch u.Opentype { + case OPEN4_CREATE: + if v, ok := u.U.(*Createhow4); ok { + return v + } else { + var zero Createhow4 + u.U = &zero + return &zero + } + default: + XdrPanic("Openflag4.How accessed when Opentype == %v", u.Opentype) + return nil + } +} +func (u Openflag4) XdrValid() bool { + return true +} +func (u *Openflag4) XdrUnionTag() XdrNum32 { + return XDR_Opentype4(&u.Opentype) +} +func (u *Openflag4) XdrUnionTagName() string { + return "Opentype" +} +func (u *Openflag4) XdrUnionBody() XdrType { + switch u.Opentype { + case OPEN4_CREATE: + return XDR_Createhow4(u.How()) + default: + return nil + } +} +func (u *Openflag4) XdrUnionBodyName() string { + switch u.Opentype { + case OPEN4_CREATE: + return "How" + default: + return "" + } +} +type XdrType_Openflag4 = *Openflag4 +func (v *Openflag4) XdrPointer() interface{} { return v } +func (Openflag4) XdrTypeName() string { return "Openflag4" } +func (v Openflag4) XdrValue() interface{} { return v } +func (v *Openflag4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Openflag4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Opentype4(&u.Opentype).XdrMarshal(x, x.Sprintf("%sopentype", name)) + switch u.Opentype { + case OPEN4_CREATE: + x.Marshal(x.Sprintf("%show", name), XDR_Createhow4(u.How())) + return + default: + return + } +} +func XDR_Openflag4(v *Openflag4) *Openflag4 { return v} +var _XdrNames_Limit_by4 = map[int32]string{ + int32(NFS_LIMIT_SIZE): "NFS_LIMIT_SIZE", + int32(NFS_LIMIT_BLOCKS): "NFS_LIMIT_BLOCKS", +} +var _XdrValues_Limit_by4 = map[string]int32{ + "NFS_LIMIT_SIZE": int32(NFS_LIMIT_SIZE), + "NFS_LIMIT_BLOCKS": int32(NFS_LIMIT_BLOCKS), +} +func (Limit_by4) XdrEnumNames() map[int32]string { + return _XdrNames_Limit_by4 +} +func (v Limit_by4) String() string { + if s, ok := _XdrNames_Limit_by4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Limit_by4#%d", v) +} +func (v *Limit_by4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Limit_by4[stok]; ok { + *v = Limit_by4(val) + return nil + } else if stok == "Limit_by4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Limit_by4.", stok)) + } +} +func (v Limit_by4) GetU32() uint32 { return uint32(v) } +func (v *Limit_by4) SetU32(n uint32) { *v = Limit_by4(n) } +func (v *Limit_by4) XdrPointer() interface{} { return v } +func (Limit_by4) XdrTypeName() string { return "Limit_by4" } +func (v Limit_by4) XdrValue() interface{} { return v } +func (v *Limit_by4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Limit_by4 = *Limit_by4 +func XDR_Limit_by4(v *Limit_by4) *Limit_by4 { return v } +func (v *Limit_by4) XdrInitialize() { + switch Limit_by4(0) { + case NFS_LIMIT_SIZE, NFS_LIMIT_BLOCKS: + default: + if *v == Limit_by4(0) { *v = NFS_LIMIT_SIZE } + } +} +type XdrType_Nfs_modified_limit4 = *Nfs_modified_limit4 +func (v *Nfs_modified_limit4) XdrPointer() interface{} { return v } +func (Nfs_modified_limit4) XdrTypeName() string { return "Nfs_modified_limit4" } +func (v Nfs_modified_limit4) XdrValue() interface{} { return v } +func (v *Nfs_modified_limit4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Nfs_modified_limit4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%snum_blocks", name), XDR_Uint32_t(&v.Num_blocks)) + x.Marshal(x.Sprintf("%sbytes_per_block", name), XDR_Uint32_t(&v.Bytes_per_block)) +} +func XDR_Nfs_modified_limit4(v *Nfs_modified_limit4) *Nfs_modified_limit4 { return v } +var _XdrTags_Nfs_space_limit4 = map[int32]bool{ + XdrToI32(NFS_LIMIT_SIZE): true, + XdrToI32(NFS_LIMIT_BLOCKS): true, +} +func (_ Nfs_space_limit4) XdrValidTags() map[int32]bool { + return _XdrTags_Nfs_space_limit4 +} +func (u *Nfs_space_limit4) Filesize() *Uint64_t { + switch u.Limitby { + case NFS_LIMIT_SIZE: + if v, ok := u.U.(*Uint64_t); ok { + return v + } else { + var zero Uint64_t + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_space_limit4.Filesize accessed when Limitby == %v", u.Limitby) + return nil + } +} +func (u *Nfs_space_limit4) Mod_blocks() *Nfs_modified_limit4 { + switch u.Limitby { + case NFS_LIMIT_BLOCKS: + if v, ok := u.U.(*Nfs_modified_limit4); ok { + return v + } else { + var zero Nfs_modified_limit4 + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_space_limit4.Mod_blocks accessed when Limitby == %v", u.Limitby) + return nil + } +} +func (u Nfs_space_limit4) XdrValid() bool { + switch u.Limitby { + case NFS_LIMIT_SIZE,NFS_LIMIT_BLOCKS: + return true + } + return false +} +func (u *Nfs_space_limit4) XdrUnionTag() XdrNum32 { + return XDR_Limit_by4(&u.Limitby) +} +func (u *Nfs_space_limit4) XdrUnionTagName() string { + return "Limitby" +} +func (u *Nfs_space_limit4) XdrUnionBody() XdrType { + switch u.Limitby { + case NFS_LIMIT_SIZE: + return XDR_Uint64_t(u.Filesize()) + case NFS_LIMIT_BLOCKS: + return XDR_Nfs_modified_limit4(u.Mod_blocks()) + } + return nil +} +func (u *Nfs_space_limit4) XdrUnionBodyName() string { + switch u.Limitby { + case NFS_LIMIT_SIZE: + return "Filesize" + case NFS_LIMIT_BLOCKS: + return "Mod_blocks" + } + return "" +} +type XdrType_Nfs_space_limit4 = *Nfs_space_limit4 +func (v *Nfs_space_limit4) XdrPointer() interface{} { return v } +func (Nfs_space_limit4) XdrTypeName() string { return "Nfs_space_limit4" } +func (v Nfs_space_limit4) XdrValue() interface{} { return v } +func (v *Nfs_space_limit4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Nfs_space_limit4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Limit_by4(&u.Limitby).XdrMarshal(x, x.Sprintf("%slimitby", name)) + switch u.Limitby { + case NFS_LIMIT_SIZE: + x.Marshal(x.Sprintf("%sfilesize", name), XDR_Uint64_t(u.Filesize())) + return + case NFS_LIMIT_BLOCKS: + x.Marshal(x.Sprintf("%smod_blocks", name), XDR_Nfs_modified_limit4(u.Mod_blocks())) + return + } + XdrPanic("invalid Limitby (%v) in Nfs_space_limit4", u.Limitby) +} +func (v *Nfs_space_limit4) XdrInitialize() { + var zero Limit_by4 + switch zero { + case NFS_LIMIT_SIZE, NFS_LIMIT_BLOCKS: + default: + if v.Limitby == zero { v.Limitby = NFS_LIMIT_SIZE } + } +} +func XDR_Nfs_space_limit4(v *Nfs_space_limit4) *Nfs_space_limit4 { return v} +var _XdrNames_Open_delegation_type4 = map[int32]string{ + int32(OPEN_DELEGATE_NONE): "OPEN_DELEGATE_NONE", + int32(OPEN_DELEGATE_READ): "OPEN_DELEGATE_READ", + int32(OPEN_DELEGATE_WRITE): "OPEN_DELEGATE_WRITE", +} +var _XdrValues_Open_delegation_type4 = map[string]int32{ + "OPEN_DELEGATE_NONE": int32(OPEN_DELEGATE_NONE), + "OPEN_DELEGATE_READ": int32(OPEN_DELEGATE_READ), + "OPEN_DELEGATE_WRITE": int32(OPEN_DELEGATE_WRITE), +} +func (Open_delegation_type4) XdrEnumNames() map[int32]string { + return _XdrNames_Open_delegation_type4 +} +func (v Open_delegation_type4) String() string { + if s, ok := _XdrNames_Open_delegation_type4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Open_delegation_type4#%d", v) +} +func (v *Open_delegation_type4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Open_delegation_type4[stok]; ok { + *v = Open_delegation_type4(val) + return nil + } else if stok == "Open_delegation_type4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Open_delegation_type4.", stok)) + } +} +func (v Open_delegation_type4) GetU32() uint32 { return uint32(v) } +func (v *Open_delegation_type4) SetU32(n uint32) { *v = Open_delegation_type4(n) } +func (v *Open_delegation_type4) XdrPointer() interface{} { return v } +func (Open_delegation_type4) XdrTypeName() string { return "Open_delegation_type4" } +func (v Open_delegation_type4) XdrValue() interface{} { return v } +func (v *Open_delegation_type4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Open_delegation_type4 = *Open_delegation_type4 +func XDR_Open_delegation_type4(v *Open_delegation_type4) *Open_delegation_type4 { return v } +var _XdrNames_Open_claim_type4 = map[int32]string{ + int32(CLAIM_NULL): "CLAIM_NULL", + int32(CLAIM_PREVIOUS): "CLAIM_PREVIOUS", + int32(CLAIM_DELEGATE_CUR): "CLAIM_DELEGATE_CUR", + int32(CLAIM_DELEGATE_PREV): "CLAIM_DELEGATE_PREV", + int32(CLAIM_FH): "CLAIM_FH", + int32(CLAIM_DELEG_CUR_FH): "CLAIM_DELEG_CUR_FH", + int32(CLAIM_DELEG_PREV_FH): "CLAIM_DELEG_PREV_FH", +} +var _XdrValues_Open_claim_type4 = map[string]int32{ + "CLAIM_NULL": int32(CLAIM_NULL), + "CLAIM_PREVIOUS": int32(CLAIM_PREVIOUS), + "CLAIM_DELEGATE_CUR": int32(CLAIM_DELEGATE_CUR), + "CLAIM_DELEGATE_PREV": int32(CLAIM_DELEGATE_PREV), + "CLAIM_FH": int32(CLAIM_FH), + "CLAIM_DELEG_CUR_FH": int32(CLAIM_DELEG_CUR_FH), + "CLAIM_DELEG_PREV_FH": int32(CLAIM_DELEG_PREV_FH), +} +func (Open_claim_type4) XdrEnumNames() map[int32]string { + return _XdrNames_Open_claim_type4 +} +func (v Open_claim_type4) String() string { + if s, ok := _XdrNames_Open_claim_type4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Open_claim_type4#%d", v) +} +func (v *Open_claim_type4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Open_claim_type4[stok]; ok { + *v = Open_claim_type4(val) + return nil + } else if stok == "Open_claim_type4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Open_claim_type4.", stok)) + } +} +func (v Open_claim_type4) GetU32() uint32 { return uint32(v) } +func (v *Open_claim_type4) SetU32(n uint32) { *v = Open_claim_type4(n) } +func (v *Open_claim_type4) XdrPointer() interface{} { return v } +func (Open_claim_type4) XdrTypeName() string { return "Open_claim_type4" } +func (v Open_claim_type4) XdrValue() interface{} { return v } +func (v *Open_claim_type4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Open_claim_type4 = *Open_claim_type4 +func XDR_Open_claim_type4(v *Open_claim_type4) *Open_claim_type4 { return v } +type XdrType_Open_claim_delegate_cur4 = *Open_claim_delegate_cur4 +func (v *Open_claim_delegate_cur4) XdrPointer() interface{} { return v } +func (Open_claim_delegate_cur4) XdrTypeName() string { return "Open_claim_delegate_cur4" } +func (v Open_claim_delegate_cur4) XdrValue() interface{} { return v } +func (v *Open_claim_delegate_cur4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Open_claim_delegate_cur4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sdelegate_stateid", name), XDR_Stateid4(&v.Delegate_stateid)) + x.Marshal(x.Sprintf("%sfile", name), XDR_Component4(&v.File)) +} +func XDR_Open_claim_delegate_cur4(v *Open_claim_delegate_cur4) *Open_claim_delegate_cur4 { return v } +var _XdrTags_Open_claim4 = map[int32]bool{ + XdrToI32(CLAIM_NULL): true, + XdrToI32(CLAIM_PREVIOUS): true, + XdrToI32(CLAIM_DELEGATE_CUR): true, + XdrToI32(CLAIM_DELEGATE_PREV): true, +} +func (_ Open_claim4) XdrValidTags() map[int32]bool { + return _XdrTags_Open_claim4 +} +/* CURRENT_FH: directory */ +func (u *Open_claim4) File() *Component4 { + switch u.Claim { + case CLAIM_NULL: + if v, ok := u.U.(*Component4); ok { + return v + } else { + var zero Component4 + u.U = &zero + return &zero + } + default: + XdrPanic("Open_claim4.File accessed when Claim == %v", u.Claim) + return nil + } +} +/* CURRENT_FH: file being reclaimed */ +func (u *Open_claim4) Delegate_type() *Open_delegation_type4 { + switch u.Claim { + case CLAIM_PREVIOUS: + if v, ok := u.U.(*Open_delegation_type4); ok { + return v + } else { + var zero Open_delegation_type4 + u.U = &zero + return &zero + } + default: + XdrPanic("Open_claim4.Delegate_type accessed when Claim == %v", u.Claim) + return nil + } +} +/* CURRENT_FH: directory */ +func (u *Open_claim4) Delegate_cur_info() *Open_claim_delegate_cur4 { + switch u.Claim { + case CLAIM_DELEGATE_CUR: + if v, ok := u.U.(*Open_claim_delegate_cur4); ok { + return v + } else { + var zero Open_claim_delegate_cur4 + u.U = &zero + return &zero + } + default: + XdrPanic("Open_claim4.Delegate_cur_info accessed when Claim == %v", u.Claim) + return nil + } +} +/* CURRENT_FH: directory */ +func (u *Open_claim4) File_delegate_prev() *Component4 { + switch u.Claim { + case CLAIM_DELEGATE_PREV: + if v, ok := u.U.(*Component4); ok { + return v + } else { + var zero Component4 + u.U = &zero + return &zero + } + default: + XdrPanic("Open_claim4.File_delegate_prev accessed when Claim == %v", u.Claim) + return nil + } +} +func (u Open_claim4) XdrValid() bool { + switch u.Claim { + case CLAIM_NULL,CLAIM_PREVIOUS,CLAIM_DELEGATE_CUR,CLAIM_DELEGATE_PREV: + return true + } + return false +} +func (u *Open_claim4) XdrUnionTag() XdrNum32 { + return XDR_Open_claim_type4(&u.Claim) +} +func (u *Open_claim4) XdrUnionTagName() string { + return "Claim" +} +func (u *Open_claim4) XdrUnionBody() XdrType { + switch u.Claim { + case CLAIM_NULL: + return XDR_Component4(u.File()) + case CLAIM_PREVIOUS: + return XDR_Open_delegation_type4(u.Delegate_type()) + case CLAIM_DELEGATE_CUR: + return XDR_Open_claim_delegate_cur4(u.Delegate_cur_info()) + case CLAIM_DELEGATE_PREV: + return XDR_Component4(u.File_delegate_prev()) + } + return nil +} +func (u *Open_claim4) XdrUnionBodyName() string { + switch u.Claim { + case CLAIM_NULL: + return "File" + case CLAIM_PREVIOUS: + return "Delegate_type" + case CLAIM_DELEGATE_CUR: + return "Delegate_cur_info" + case CLAIM_DELEGATE_PREV: + return "File_delegate_prev" + } + return "" +} +type XdrType_Open_claim4 = *Open_claim4 +func (v *Open_claim4) XdrPointer() interface{} { return v } +func (Open_claim4) XdrTypeName() string { return "Open_claim4" } +func (v Open_claim4) XdrValue() interface{} { return v } +func (v *Open_claim4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Open_claim4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Open_claim_type4(&u.Claim).XdrMarshal(x, x.Sprintf("%sclaim", name)) + switch u.Claim { + case CLAIM_NULL: + x.Marshal(x.Sprintf("%sfile", name), XDR_Component4(u.File())) + return + case CLAIM_PREVIOUS: + x.Marshal(x.Sprintf("%sdelegate_type", name), XDR_Open_delegation_type4(u.Delegate_type())) + return + case CLAIM_DELEGATE_CUR: + x.Marshal(x.Sprintf("%sdelegate_cur_info", name), XDR_Open_claim_delegate_cur4(u.Delegate_cur_info())) + return + case CLAIM_DELEGATE_PREV: + x.Marshal(x.Sprintf("%sfile_delegate_prev", name), XDR_Component4(u.File_delegate_prev())) + return + } + XdrPanic("invalid Claim (%v) in Open_claim4", u.Claim) +} +func XDR_Open_claim4(v *Open_claim4) *Open_claim4 { return v} +type XdrType_OPEN4args = *OPEN4args +func (v *OPEN4args) XdrPointer() interface{} { return v } +func (OPEN4args) XdrTypeName() string { return "OPEN4args" } +func (v OPEN4args) XdrValue() interface{} { return v } +func (v *OPEN4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPEN4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sseqid", name), XDR_Seqid4(&v.Seqid)) + x.Marshal(x.Sprintf("%sshare_access", name), XDR_Uint32_t(&v.Share_access)) + x.Marshal(x.Sprintf("%sshare_deny", name), XDR_Uint32_t(&v.Share_deny)) + x.Marshal(x.Sprintf("%sowner", name), XDR_Open_owner4(&v.Owner)) + x.Marshal(x.Sprintf("%sopenhow", name), XDR_Openflag4(&v.Openhow)) + x.Marshal(x.Sprintf("%sclaim", name), XDR_Open_claim4(&v.Claim)) +} +func XDR_OPEN4args(v *OPEN4args) *OPEN4args { return v } +type XdrType_Open_read_delegation4 = *Open_read_delegation4 +func (v *Open_read_delegation4) XdrPointer() interface{} { return v } +func (Open_read_delegation4) XdrTypeName() string { return "Open_read_delegation4" } +func (v Open_read_delegation4) XdrValue() interface{} { return v } +func (v *Open_read_delegation4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Open_read_delegation4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%srecall", name), XDR_bool(&v.Recall)) + x.Marshal(x.Sprintf("%spermissions", name), XDR_Nfsace4(&v.Permissions)) +} +func XDR_Open_read_delegation4(v *Open_read_delegation4) *Open_read_delegation4 { return v } +type XdrType_Open_write_delegation4 = *Open_write_delegation4 +func (v *Open_write_delegation4) XdrPointer() interface{} { return v } +func (Open_write_delegation4) XdrTypeName() string { return "Open_write_delegation4" } +func (v Open_write_delegation4) XdrValue() interface{} { return v } +func (v *Open_write_delegation4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Open_write_delegation4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%srecall", name), XDR_bool(&v.Recall)) + x.Marshal(x.Sprintf("%sspace_limit", name), XDR_Nfs_space_limit4(&v.Space_limit)) + x.Marshal(x.Sprintf("%spermissions", name), XDR_Nfsace4(&v.Permissions)) +} +func XDR_Open_write_delegation4(v *Open_write_delegation4) *Open_write_delegation4 { return v } +var _XdrTags_Open_delegation4 = map[int32]bool{ + XdrToI32(OPEN_DELEGATE_NONE): true, + XdrToI32(OPEN_DELEGATE_READ): true, + XdrToI32(OPEN_DELEGATE_WRITE): true, +} +func (_ Open_delegation4) XdrValidTags() map[int32]bool { + return _XdrTags_Open_delegation4 +} +func (u *Open_delegation4) Read() *Open_read_delegation4 { + switch u.Delegation_type { + case OPEN_DELEGATE_READ: + if v, ok := u.U.(*Open_read_delegation4); ok { + return v + } else { + var zero Open_read_delegation4 + u.U = &zero + return &zero + } + default: + XdrPanic("Open_delegation4.Read accessed when Delegation_type == %v", u.Delegation_type) + return nil + } +} +func (u *Open_delegation4) Write() *Open_write_delegation4 { + switch u.Delegation_type { + case OPEN_DELEGATE_WRITE: + if v, ok := u.U.(*Open_write_delegation4); ok { + return v + } else { + var zero Open_write_delegation4 + u.U = &zero + return &zero + } + default: + XdrPanic("Open_delegation4.Write accessed when Delegation_type == %v", u.Delegation_type) + return nil + } +} +func (u Open_delegation4) XdrValid() bool { + switch u.Delegation_type { + case OPEN_DELEGATE_NONE,OPEN_DELEGATE_READ,OPEN_DELEGATE_WRITE: + return true + } + return false +} +func (u *Open_delegation4) XdrUnionTag() XdrNum32 { + return XDR_Open_delegation_type4(&u.Delegation_type) +} +func (u *Open_delegation4) XdrUnionTagName() string { + return "Delegation_type" +} +func (u *Open_delegation4) XdrUnionBody() XdrType { + switch u.Delegation_type { + case OPEN_DELEGATE_NONE: + return nil + case OPEN_DELEGATE_READ: + return XDR_Open_read_delegation4(u.Read()) + case OPEN_DELEGATE_WRITE: + return XDR_Open_write_delegation4(u.Write()) + } + return nil +} +func (u *Open_delegation4) XdrUnionBodyName() string { + switch u.Delegation_type { + case OPEN_DELEGATE_NONE: + return "" + case OPEN_DELEGATE_READ: + return "Read" + case OPEN_DELEGATE_WRITE: + return "Write" + } + return "" +} +type XdrType_Open_delegation4 = *Open_delegation4 +func (v *Open_delegation4) XdrPointer() interface{} { return v } +func (Open_delegation4) XdrTypeName() string { return "Open_delegation4" } +func (v Open_delegation4) XdrValue() interface{} { return v } +func (v *Open_delegation4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Open_delegation4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Open_delegation_type4(&u.Delegation_type).XdrMarshal(x, x.Sprintf("%sdelegation_type", name)) + switch u.Delegation_type { + case OPEN_DELEGATE_NONE: + return + case OPEN_DELEGATE_READ: + x.Marshal(x.Sprintf("%sread", name), XDR_Open_read_delegation4(u.Read())) + return + case OPEN_DELEGATE_WRITE: + x.Marshal(x.Sprintf("%swrite", name), XDR_Open_write_delegation4(u.Write())) + return + } + XdrPanic("invalid Delegation_type (%v) in Open_delegation4", u.Delegation_type) +} +func XDR_Open_delegation4(v *Open_delegation4) *Open_delegation4 { return v} +type XdrType_OPEN4resok = *OPEN4resok +func (v *OPEN4resok) XdrPointer() interface{} { return v } +func (OPEN4resok) XdrTypeName() string { return "OPEN4resok" } +func (v OPEN4resok) XdrValue() interface{} { return v } +func (v *OPEN4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPEN4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%scinfo", name), XDR_Change_info4(&v.Cinfo)) + x.Marshal(x.Sprintf("%srflags", name), XDR_Uint32_t(&v.Rflags)) + x.Marshal(x.Sprintf("%sattrset", name), XDR_Bitmap4(&v.Attrset)) + x.Marshal(x.Sprintf("%sdelegation", name), XDR_Open_delegation4(&v.Delegation)) +} +func XDR_OPEN4resok(v *OPEN4resok) *OPEN4resok { return v } +/* CURRENT_FH: opened file */ +func (u *OPEN4res) Resok4() *OPEN4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*OPEN4resok); ok { + return v + } else { + var zero OPEN4resok + u.U = &zero + return &zero + } + default: + XdrPanic("OPEN4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u OPEN4res) XdrValid() bool { + return true +} +func (u *OPEN4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *OPEN4res) XdrUnionTagName() string { + return "Status" +} +func (u *OPEN4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_OPEN4resok(u.Resok4()) + default: + return nil + } +} +func (u *OPEN4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_OPEN4res = *OPEN4res +func (v *OPEN4res) XdrPointer() interface{} { return v } +func (OPEN4res) XdrTypeName() string { return "OPEN4res" } +func (v OPEN4res) XdrValue() interface{} { return v } +func (v *OPEN4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *OPEN4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_OPEN4resok(u.Resok4())) + return + default: + return + } +} +func XDR_OPEN4res(v *OPEN4res) *OPEN4res { return v} +type XdrType_OPENATTR4args = *OPENATTR4args +func (v *OPENATTR4args) XdrPointer() interface{} { return v } +func (OPENATTR4args) XdrTypeName() string { return "OPENATTR4args" } +func (v OPENATTR4args) XdrValue() interface{} { return v } +func (v *OPENATTR4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPENATTR4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%screatedir", name), XDR_bool(&v.Createdir)) +} +func XDR_OPENATTR4args(v *OPENATTR4args) *OPENATTR4args { return v } +type XdrType_OPENATTR4res = *OPENATTR4res +func (v *OPENATTR4res) XdrPointer() interface{} { return v } +func (OPENATTR4res) XdrTypeName() string { return "OPENATTR4res" } +func (v OPENATTR4res) XdrValue() interface{} { return v } +func (v *OPENATTR4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPENATTR4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_OPENATTR4res(v *OPENATTR4res) *OPENATTR4res { return v } +type XdrType_OPEN_CONFIRM4args = *OPEN_CONFIRM4args +func (v *OPEN_CONFIRM4args) XdrPointer() interface{} { return v } +func (OPEN_CONFIRM4args) XdrTypeName() string { return "OPEN_CONFIRM4args" } +func (v OPEN_CONFIRM4args) XdrValue() interface{} { return v } +func (v *OPEN_CONFIRM4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPEN_CONFIRM4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(&v.Open_stateid)) + x.Marshal(x.Sprintf("%sseqid", name), XDR_Seqid4(&v.Seqid)) +} +func XDR_OPEN_CONFIRM4args(v *OPEN_CONFIRM4args) *OPEN_CONFIRM4args { return v } +type XdrType_OPEN_CONFIRM4resok = *OPEN_CONFIRM4resok +func (v *OPEN_CONFIRM4resok) XdrPointer() interface{} { return v } +func (OPEN_CONFIRM4resok) XdrTypeName() string { return "OPEN_CONFIRM4resok" } +func (v OPEN_CONFIRM4resok) XdrValue() interface{} { return v } +func (v *OPEN_CONFIRM4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPEN_CONFIRM4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(&v.Open_stateid)) +} +func XDR_OPEN_CONFIRM4resok(v *OPEN_CONFIRM4resok) *OPEN_CONFIRM4resok { return v } +func (u *OPEN_CONFIRM4res) Resok4() *OPEN_CONFIRM4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*OPEN_CONFIRM4resok); ok { + return v + } else { + var zero OPEN_CONFIRM4resok + u.U = &zero + return &zero + } + default: + XdrPanic("OPEN_CONFIRM4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u OPEN_CONFIRM4res) XdrValid() bool { + return true +} +func (u *OPEN_CONFIRM4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *OPEN_CONFIRM4res) XdrUnionTagName() string { + return "Status" +} +func (u *OPEN_CONFIRM4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_OPEN_CONFIRM4resok(u.Resok4()) + default: + return nil + } +} +func (u *OPEN_CONFIRM4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_OPEN_CONFIRM4res = *OPEN_CONFIRM4res +func (v *OPEN_CONFIRM4res) XdrPointer() interface{} { return v } +func (OPEN_CONFIRM4res) XdrTypeName() string { return "OPEN_CONFIRM4res" } +func (v OPEN_CONFIRM4res) XdrValue() interface{} { return v } +func (v *OPEN_CONFIRM4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *OPEN_CONFIRM4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_OPEN_CONFIRM4resok(u.Resok4())) + return + default: + return + } +} +func XDR_OPEN_CONFIRM4res(v *OPEN_CONFIRM4res) *OPEN_CONFIRM4res { return v} +type XdrType_OPEN_DOWNGRADE4args = *OPEN_DOWNGRADE4args +func (v *OPEN_DOWNGRADE4args) XdrPointer() interface{} { return v } +func (OPEN_DOWNGRADE4args) XdrTypeName() string { return "OPEN_DOWNGRADE4args" } +func (v OPEN_DOWNGRADE4args) XdrValue() interface{} { return v } +func (v *OPEN_DOWNGRADE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPEN_DOWNGRADE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(&v.Open_stateid)) + x.Marshal(x.Sprintf("%sseqid", name), XDR_Seqid4(&v.Seqid)) + x.Marshal(x.Sprintf("%sshare_access", name), XDR_Uint32_t(&v.Share_access)) + x.Marshal(x.Sprintf("%sshare_deny", name), XDR_Uint32_t(&v.Share_deny)) +} +func XDR_OPEN_DOWNGRADE4args(v *OPEN_DOWNGRADE4args) *OPEN_DOWNGRADE4args { return v } +type XdrType_OPEN_DOWNGRADE4resok = *OPEN_DOWNGRADE4resok +func (v *OPEN_DOWNGRADE4resok) XdrPointer() interface{} { return v } +func (OPEN_DOWNGRADE4resok) XdrTypeName() string { return "OPEN_DOWNGRADE4resok" } +func (v OPEN_DOWNGRADE4resok) XdrValue() interface{} { return v } +func (v *OPEN_DOWNGRADE4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *OPEN_DOWNGRADE4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sopen_stateid", name), XDR_Stateid4(&v.Open_stateid)) +} +func XDR_OPEN_DOWNGRADE4resok(v *OPEN_DOWNGRADE4resok) *OPEN_DOWNGRADE4resok { return v } +func (u *OPEN_DOWNGRADE4res) Resok4() *OPEN_DOWNGRADE4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*OPEN_DOWNGRADE4resok); ok { + return v + } else { + var zero OPEN_DOWNGRADE4resok + u.U = &zero + return &zero + } + default: + XdrPanic("OPEN_DOWNGRADE4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u OPEN_DOWNGRADE4res) XdrValid() bool { + return true +} +func (u *OPEN_DOWNGRADE4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *OPEN_DOWNGRADE4res) XdrUnionTagName() string { + return "Status" +} +func (u *OPEN_DOWNGRADE4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_OPEN_DOWNGRADE4resok(u.Resok4()) + default: + return nil + } +} +func (u *OPEN_DOWNGRADE4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_OPEN_DOWNGRADE4res = *OPEN_DOWNGRADE4res +func (v *OPEN_DOWNGRADE4res) XdrPointer() interface{} { return v } +func (OPEN_DOWNGRADE4res) XdrTypeName() string { return "OPEN_DOWNGRADE4res" } +func (v OPEN_DOWNGRADE4res) XdrValue() interface{} { return v } +func (v *OPEN_DOWNGRADE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *OPEN_DOWNGRADE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_OPEN_DOWNGRADE4resok(u.Resok4())) + return + default: + return + } +} +func XDR_OPEN_DOWNGRADE4res(v *OPEN_DOWNGRADE4res) *OPEN_DOWNGRADE4res { return v} +type XdrType_PUTFH4args = *PUTFH4args +func (v *PUTFH4args) XdrPointer() interface{} { return v } +func (PUTFH4args) XdrTypeName() string { return "PUTFH4args" } +func (v PUTFH4args) XdrValue() interface{} { return v } +func (v *PUTFH4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *PUTFH4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobject", name), XDR_Nfs_fh4(&v.Object)) +} +func XDR_PUTFH4args(v *PUTFH4args) *PUTFH4args { return v } +type XdrType_PUTFH4res = *PUTFH4res +func (v *PUTFH4res) XdrPointer() interface{} { return v } +func (PUTFH4res) XdrTypeName() string { return "PUTFH4res" } +func (v PUTFH4res) XdrValue() interface{} { return v } +func (v *PUTFH4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *PUTFH4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_PUTFH4res(v *PUTFH4res) *PUTFH4res { return v } +type XdrType_PUTPUBFH4res = *PUTPUBFH4res +func (v *PUTPUBFH4res) XdrPointer() interface{} { return v } +func (PUTPUBFH4res) XdrTypeName() string { return "PUTPUBFH4res" } +func (v PUTPUBFH4res) XdrValue() interface{} { return v } +func (v *PUTPUBFH4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *PUTPUBFH4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_PUTPUBFH4res(v *PUTPUBFH4res) *PUTPUBFH4res { return v } +type XdrType_PUTROOTFH4res = *PUTROOTFH4res +func (v *PUTROOTFH4res) XdrPointer() interface{} { return v } +func (PUTROOTFH4res) XdrTypeName() string { return "PUTROOTFH4res" } +func (v PUTROOTFH4res) XdrValue() interface{} { return v } +func (v *PUTROOTFH4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *PUTROOTFH4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_PUTROOTFH4res(v *PUTROOTFH4res) *PUTROOTFH4res { return v } +type XdrType_READ4args = *READ4args +func (v *READ4args) XdrPointer() interface{} { return v } +func (READ4args) XdrTypeName() string { return "READ4args" } +func (v READ4args) XdrValue() interface{} { return v } +func (v *READ4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *READ4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%scount", name), XDR_Count4(&v.Count)) +} +func XDR_READ4args(v *READ4args) *READ4args { return v } +type XdrType_READ4resok = *READ4resok +func (v *READ4resok) XdrPointer() interface{} { return v } +func (READ4resok) XdrTypeName() string { return "READ4resok" } +func (v READ4resok) XdrValue() interface{} { return v } +func (v *READ4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *READ4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%seof", name), XDR_bool(&v.Eof)) + x.Marshal(x.Sprintf("%sdata", name), XdrVecOpaque{&v.Data, 0xffffffff}) +} +func XDR_READ4resok(v *READ4resok) *READ4resok { return v } +func (u *READ4res) Resok4() *READ4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*READ4resok); ok { + return v + } else { + var zero READ4resok + u.U = &zero + return &zero + } + default: + XdrPanic("READ4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u READ4res) XdrValid() bool { + return true +} +func (u *READ4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *READ4res) XdrUnionTagName() string { + return "Status" +} +func (u *READ4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_READ4resok(u.Resok4()) + default: + return nil + } +} +func (u *READ4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_READ4res = *READ4res +func (v *READ4res) XdrPointer() interface{} { return v } +func (READ4res) XdrTypeName() string { return "READ4res" } +func (v READ4res) XdrValue() interface{} { return v } +func (v *READ4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *READ4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_READ4resok(u.Resok4())) + return + default: + return + } +} +func XDR_READ4res(v *READ4res) *READ4res { return v} +type XdrType_READDIR4args = *READDIR4args +func (v *READDIR4args) XdrPointer() interface{} { return v } +func (READDIR4args) XdrTypeName() string { return "READDIR4args" } +func (v READDIR4args) XdrValue() interface{} { return v } +func (v *READDIR4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *READDIR4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scookie", name), XDR_Nfs_cookie4(&v.Cookie)) + x.Marshal(x.Sprintf("%scookieverf", name), XDR_Verifier4(&v.Cookieverf)) + x.Marshal(x.Sprintf("%sdircount", name), XDR_Count4(&v.Dircount)) + x.Marshal(x.Sprintf("%smaxcount", name), XDR_Count4(&v.Maxcount)) + x.Marshal(x.Sprintf("%sattr_request", name), XDR_Bitmap4(&v.Attr_request)) +} +func XDR_READDIR4args(v *READDIR4args) *READDIR4args { return v } +type _XdrPtr_Entry4 struct { + p **Entry4 +} +type _ptrflag_Entry4 _XdrPtr_Entry4 +func (v _ptrflag_Entry4) String() string { + if *v.p == nil { + return "nil" + } + return "non-nil" +} +func (v _ptrflag_Entry4) Scan(ss fmt.ScanState, r rune) error { + tok, err := ss.Token(true, func(c rune) bool { + return c == '-' || (c >= 'a' && c <= 'z') + }) + if err != nil { + return err + } + switch string(tok) { + case "nil": + v.SetU32(0) + case "non-nil": + v.SetU32(1) + default: + return XdrError("Entry4 flag should be \"nil\" or \"non-nil\"") + } + return nil +} +func (v _ptrflag_Entry4) GetU32() uint32 { + if *v.p == nil { + return 0 + } + return 1 +} +func (v _ptrflag_Entry4) SetU32(nv uint32) { + switch nv { + case 0: + *v.p = nil + case 1: + if *v.p == nil { + *v.p = new(Entry4) + } + default: + XdrPanic("*Entry4 present flag value %d should be 0 or 1", nv) + } +} +func (_ptrflag_Entry4) XdrTypeName() string { return "Entry4?" } +func (v _ptrflag_Entry4) XdrPointer() interface{} { return nil } +func (v _ptrflag_Entry4) XdrValue() interface{} { return v.GetU32() != 0 } +func (v _ptrflag_Entry4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v _ptrflag_Entry4) XdrBound() uint32 { return 1 } +func (v _XdrPtr_Entry4) GetPresent() bool { return *v.p != nil } +func (v _XdrPtr_Entry4) SetPresent(present bool) { + if !present { + *v.p = nil + } else if *v.p == nil { + *v.p = new(Entry4) + } +} +func (v _XdrPtr_Entry4) XdrMarshalValue(x XDR, name string) { + if *v.p != nil { + XDR_Entry4(*v.p).XdrMarshal(x, name) + } +} +func (v _XdrPtr_Entry4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v _XdrPtr_Entry4) XdrRecurse(x XDR, name string) { + x.Marshal(name, _ptrflag_Entry4(v)) + v.XdrMarshalValue(x, name) +} +func (_XdrPtr_Entry4) XdrTypeName() string { return "Entry4*" } +func (v _XdrPtr_Entry4) XdrPointer() interface{} { return v.p } +func (v _XdrPtr_Entry4) XdrValue() interface{} { return *v.p } +type XdrType_Entry4 = *Entry4 +func (v *Entry4) XdrPointer() interface{} { return v } +func (Entry4) XdrTypeName() string { return "Entry4" } +func (v Entry4) XdrValue() interface{} { return v } +func (v *Entry4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Entry4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scookie", name), XDR_Nfs_cookie4(&v.Cookie)) + x.Marshal(x.Sprintf("%sname", name), XDR_Component4(&v.Name)) + x.Marshal(x.Sprintf("%sattrs", name), XDR_Fattr4(&v.Attrs)) + x.Marshal(x.Sprintf("%snextentry", name), _XdrPtr_Entry4{&v.Nextentry}) +} +func XDR_Entry4(v *Entry4) *Entry4 { return v } +type XdrType_Dirlist4 = *Dirlist4 +func (v *Dirlist4) XdrPointer() interface{} { return v } +func (Dirlist4) XdrTypeName() string { return "Dirlist4" } +func (v Dirlist4) XdrValue() interface{} { return v } +func (v *Dirlist4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Dirlist4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sentries", name), _XdrPtr_Entry4{&v.Entries}) + x.Marshal(x.Sprintf("%seof", name), XDR_bool(&v.Eof)) +} +func XDR_Dirlist4(v *Dirlist4) *Dirlist4 { return v } +type XdrType_READDIR4resok = *READDIR4resok +func (v *READDIR4resok) XdrPointer() interface{} { return v } +func (READDIR4resok) XdrTypeName() string { return "READDIR4resok" } +func (v READDIR4resok) XdrValue() interface{} { return v } +func (v *READDIR4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *READDIR4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scookieverf", name), XDR_Verifier4(&v.Cookieverf)) + x.Marshal(x.Sprintf("%sreply", name), XDR_Dirlist4(&v.Reply)) +} +func XDR_READDIR4resok(v *READDIR4resok) *READDIR4resok { return v } +func (u *READDIR4res) Resok4() *READDIR4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*READDIR4resok); ok { + return v + } else { + var zero READDIR4resok + u.U = &zero + return &zero + } + default: + XdrPanic("READDIR4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u READDIR4res) XdrValid() bool { + return true +} +func (u *READDIR4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *READDIR4res) XdrUnionTagName() string { + return "Status" +} +func (u *READDIR4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_READDIR4resok(u.Resok4()) + default: + return nil + } +} +func (u *READDIR4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_READDIR4res = *READDIR4res +func (v *READDIR4res) XdrPointer() interface{} { return v } +func (READDIR4res) XdrTypeName() string { return "READDIR4res" } +func (v READDIR4res) XdrValue() interface{} { return v } +func (v *READDIR4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *READDIR4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_READDIR4resok(u.Resok4())) + return + default: + return + } +} +func XDR_READDIR4res(v *READDIR4res) *READDIR4res { return v} +type XdrType_READLINK4resok = *READLINK4resok +func (v *READLINK4resok) XdrPointer() interface{} { return v } +func (READLINK4resok) XdrTypeName() string { return "READLINK4resok" } +func (v READLINK4resok) XdrValue() interface{} { return v } +func (v *READLINK4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *READLINK4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slink", name), XDR_Linktext4(&v.Link)) +} +func XDR_READLINK4resok(v *READLINK4resok) *READLINK4resok { return v } +func (u *READLINK4res) Resok4() *READLINK4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*READLINK4resok); ok { + return v + } else { + var zero READLINK4resok + u.U = &zero + return &zero + } + default: + XdrPanic("READLINK4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u READLINK4res) XdrValid() bool { + return true +} +func (u *READLINK4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *READLINK4res) XdrUnionTagName() string { + return "Status" +} +func (u *READLINK4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_READLINK4resok(u.Resok4()) + default: + return nil + } +} +func (u *READLINK4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_READLINK4res = *READLINK4res +func (v *READLINK4res) XdrPointer() interface{} { return v } +func (READLINK4res) XdrTypeName() string { return "READLINK4res" } +func (v READLINK4res) XdrValue() interface{} { return v } +func (v *READLINK4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *READLINK4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_READLINK4resok(u.Resok4())) + return + default: + return + } +} +func XDR_READLINK4res(v *READLINK4res) *READLINK4res { return v} +type XdrType_REMOVE4args = *REMOVE4args +func (v *REMOVE4args) XdrPointer() interface{} { return v } +func (REMOVE4args) XdrTypeName() string { return "REMOVE4args" } +func (v REMOVE4args) XdrValue() interface{} { return v } +func (v *REMOVE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *REMOVE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%starget", name), XDR_Component4(&v.Target)) +} +func XDR_REMOVE4args(v *REMOVE4args) *REMOVE4args { return v } +type XdrType_REMOVE4resok = *REMOVE4resok +func (v *REMOVE4resok) XdrPointer() interface{} { return v } +func (REMOVE4resok) XdrTypeName() string { return "REMOVE4resok" } +func (v REMOVE4resok) XdrValue() interface{} { return v } +func (v *REMOVE4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *REMOVE4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scinfo", name), XDR_Change_info4(&v.Cinfo)) +} +func XDR_REMOVE4resok(v *REMOVE4resok) *REMOVE4resok { return v } +func (u *REMOVE4res) Resok4() *REMOVE4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*REMOVE4resok); ok { + return v + } else { + var zero REMOVE4resok + u.U = &zero + return &zero + } + default: + XdrPanic("REMOVE4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u REMOVE4res) XdrValid() bool { + return true +} +func (u *REMOVE4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *REMOVE4res) XdrUnionTagName() string { + return "Status" +} +func (u *REMOVE4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_REMOVE4resok(u.Resok4()) + default: + return nil + } +} +func (u *REMOVE4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_REMOVE4res = *REMOVE4res +func (v *REMOVE4res) XdrPointer() interface{} { return v } +func (REMOVE4res) XdrTypeName() string { return "REMOVE4res" } +func (v REMOVE4res) XdrValue() interface{} { return v } +func (v *REMOVE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *REMOVE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_REMOVE4resok(u.Resok4())) + return + default: + return + } +} +func XDR_REMOVE4res(v *REMOVE4res) *REMOVE4res { return v} +type XdrType_RENAME4args = *RENAME4args +func (v *RENAME4args) XdrPointer() interface{} { return v } +func (RENAME4args) XdrTypeName() string { return "RENAME4args" } +func (v RENAME4args) XdrValue() interface{} { return v } +func (v *RENAME4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RENAME4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%soldname", name), XDR_Component4(&v.Oldname)) + x.Marshal(x.Sprintf("%snewname", name), XDR_Component4(&v.Newname)) +} +func XDR_RENAME4args(v *RENAME4args) *RENAME4args { return v } +type XdrType_RENAME4resok = *RENAME4resok +func (v *RENAME4resok) XdrPointer() interface{} { return v } +func (RENAME4resok) XdrTypeName() string { return "RENAME4resok" } +func (v RENAME4resok) XdrValue() interface{} { return v } +func (v *RENAME4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RENAME4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%ssource_cinfo", name), XDR_Change_info4(&v.Source_cinfo)) + x.Marshal(x.Sprintf("%starget_cinfo", name), XDR_Change_info4(&v.Target_cinfo)) +} +func XDR_RENAME4resok(v *RENAME4resok) *RENAME4resok { return v } +func (u *RENAME4res) Resok4() *RENAME4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*RENAME4resok); ok { + return v + } else { + var zero RENAME4resok + u.U = &zero + return &zero + } + default: + XdrPanic("RENAME4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u RENAME4res) XdrValid() bool { + return true +} +func (u *RENAME4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *RENAME4res) XdrUnionTagName() string { + return "Status" +} +func (u *RENAME4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_RENAME4resok(u.Resok4()) + default: + return nil + } +} +func (u *RENAME4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_RENAME4res = *RENAME4res +func (v *RENAME4res) XdrPointer() interface{} { return v } +func (RENAME4res) XdrTypeName() string { return "RENAME4res" } +func (v RENAME4res) XdrValue() interface{} { return v } +func (v *RENAME4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *RENAME4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_RENAME4resok(u.Resok4())) + return + default: + return + } +} +func XDR_RENAME4res(v *RENAME4res) *RENAME4res { return v} +type XdrType_RENEW4args = *RENEW4args +func (v *RENEW4args) XdrPointer() interface{} { return v } +func (RENEW4args) XdrTypeName() string { return "RENEW4args" } +func (v RENEW4args) XdrValue() interface{} { return v } +func (v *RENEW4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RENEW4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclientid", name), XDR_Clientid4(&v.Clientid)) +} +func XDR_RENEW4args(v *RENEW4args) *RENEW4args { return v } +type XdrType_RENEW4res = *RENEW4res +func (v *RENEW4res) XdrPointer() interface{} { return v } +func (RENEW4res) XdrTypeName() string { return "RENEW4res" } +func (v RENEW4res) XdrValue() interface{} { return v } +func (v *RENEW4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RENEW4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_RENEW4res(v *RENEW4res) *RENEW4res { return v } +type XdrType_RESTOREFH4res = *RESTOREFH4res +func (v *RESTOREFH4res) XdrPointer() interface{} { return v } +func (RESTOREFH4res) XdrTypeName() string { return "RESTOREFH4res" } +func (v RESTOREFH4res) XdrValue() interface{} { return v } +func (v *RESTOREFH4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RESTOREFH4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_RESTOREFH4res(v *RESTOREFH4res) *RESTOREFH4res { return v } +type XdrType_SAVEFH4res = *SAVEFH4res +func (v *SAVEFH4res) XdrPointer() interface{} { return v } +func (SAVEFH4res) XdrTypeName() string { return "SAVEFH4res" } +func (v SAVEFH4res) XdrValue() interface{} { return v } +func (v *SAVEFH4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SAVEFH4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_SAVEFH4res(v *SAVEFH4res) *SAVEFH4res { return v } +type XdrType_SECINFO4args = *SECINFO4args +func (v *SECINFO4args) XdrPointer() interface{} { return v } +func (SECINFO4args) XdrTypeName() string { return "SECINFO4args" } +func (v SECINFO4args) XdrValue() interface{} { return v } +func (v *SECINFO4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SECINFO4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sname", name), XDR_Component4(&v.Name)) +} +func XDR_SECINFO4args(v *SECINFO4args) *SECINFO4args { return v } +var _XdrNames_Rpc_gss_svc_t = map[int32]string{ + int32(RPC_GSS_SVC_NONE): "RPC_GSS_SVC_NONE", + int32(RPC_GSS_SVC_INTEGRITY): "RPC_GSS_SVC_INTEGRITY", + int32(RPC_GSS_SVC_PRIVACY): "RPC_GSS_SVC_PRIVACY", +} +var _XdrValues_Rpc_gss_svc_t = map[string]int32{ + "RPC_GSS_SVC_NONE": int32(RPC_GSS_SVC_NONE), + "RPC_GSS_SVC_INTEGRITY": int32(RPC_GSS_SVC_INTEGRITY), + "RPC_GSS_SVC_PRIVACY": int32(RPC_GSS_SVC_PRIVACY), +} +func (Rpc_gss_svc_t) XdrEnumNames() map[int32]string { + return _XdrNames_Rpc_gss_svc_t +} +func (v Rpc_gss_svc_t) String() string { + if s, ok := _XdrNames_Rpc_gss_svc_t[int32(v)]; ok { + return s + } + return fmt.Sprintf("Rpc_gss_svc_t#%d", v) +} +func (v *Rpc_gss_svc_t) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Rpc_gss_svc_t[stok]; ok { + *v = Rpc_gss_svc_t(val) + return nil + } else if stok == "Rpc_gss_svc_t" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Rpc_gss_svc_t.", stok)) + } +} +func (v Rpc_gss_svc_t) GetU32() uint32 { return uint32(v) } +func (v *Rpc_gss_svc_t) SetU32(n uint32) { *v = Rpc_gss_svc_t(n) } +func (v *Rpc_gss_svc_t) XdrPointer() interface{} { return v } +func (Rpc_gss_svc_t) XdrTypeName() string { return "Rpc_gss_svc_t" } +func (v Rpc_gss_svc_t) XdrValue() interface{} { return v } +func (v *Rpc_gss_svc_t) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Rpc_gss_svc_t = *Rpc_gss_svc_t +func XDR_Rpc_gss_svc_t(v *Rpc_gss_svc_t) *Rpc_gss_svc_t { return v } +func (v *Rpc_gss_svc_t) XdrInitialize() { + switch Rpc_gss_svc_t(0) { + case RPC_GSS_SVC_NONE, RPC_GSS_SVC_INTEGRITY, RPC_GSS_SVC_PRIVACY: + default: + if *v == Rpc_gss_svc_t(0) { *v = RPC_GSS_SVC_NONE } + } +} +type XdrType_Rpcsec_gss_info = *Rpcsec_gss_info +func (v *Rpcsec_gss_info) XdrPointer() interface{} { return v } +func (Rpcsec_gss_info) XdrTypeName() string { return "Rpcsec_gss_info" } +func (v Rpcsec_gss_info) XdrValue() interface{} { return v } +func (v *Rpcsec_gss_info) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Rpcsec_gss_info) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%soid", name), XDR_Sec_oid4(&v.Oid)) + x.Marshal(x.Sprintf("%sqop", name), XDR_Qop4(&v.Qop)) + x.Marshal(x.Sprintf("%sservice", name), XDR_Rpc_gss_svc_t(&v.Service)) +} +func XDR_Rpcsec_gss_info(v *Rpcsec_gss_info) *Rpcsec_gss_info { return v } +func (u *Secinfo4) Flavor_info() *Rpcsec_gss_info { + switch u.Flavor { + case RPCSEC_GSS: + if v, ok := u.U.(*Rpcsec_gss_info); ok { + return v + } else { + var zero Rpcsec_gss_info + u.U = &zero + return &zero + } + default: + XdrPanic("Secinfo4.Flavor_info accessed when Flavor == %v", u.Flavor) + return nil + } +} +func (u Secinfo4) XdrValid() bool { + return true +} +func (u *Secinfo4) XdrUnionTag() XdrNum32 { + return XDR_Uint32_t(&u.Flavor) +} +func (u *Secinfo4) XdrUnionTagName() string { + return "Flavor" +} +func (u *Secinfo4) XdrUnionBody() XdrType { + switch u.Flavor { + case RPCSEC_GSS: + return XDR_Rpcsec_gss_info(u.Flavor_info()) + default: + return nil + } +} +func (u *Secinfo4) XdrUnionBodyName() string { + switch u.Flavor { + case RPCSEC_GSS: + return "Flavor_info" + default: + return "" + } +} +type XdrType_Secinfo4 = *Secinfo4 +func (v *Secinfo4) XdrPointer() interface{} { return v } +func (Secinfo4) XdrTypeName() string { return "Secinfo4" } +func (v Secinfo4) XdrValue() interface{} { return v } +func (v *Secinfo4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Secinfo4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Uint32_t(&u.Flavor).XdrMarshal(x, x.Sprintf("%sflavor", name)) + switch u.Flavor { + case RPCSEC_GSS: + x.Marshal(x.Sprintf("%sflavor_info", name), XDR_Rpcsec_gss_info(u.Flavor_info())) + return + default: + return + } +} +func XDR_Secinfo4(v *Secinfo4) *Secinfo4 { return v} +type _XdrVec_unbounded_Secinfo4 []Secinfo4 +func (_XdrVec_unbounded_Secinfo4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Secinfo4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Secinfo4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Secinfo4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Secinfo4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Secinfo4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Secinfo4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Secinfo4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Secinfo4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Secinfo4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Secinfo4) XdrTypeName() string { return "Secinfo4<>" } +func (v *_XdrVec_unbounded_Secinfo4) XdrPointer() interface{} { return (*[]Secinfo4)(v) } +func (v _XdrVec_unbounded_Secinfo4) XdrValue() interface{} { return ([]Secinfo4)(v) } +func (v *_XdrVec_unbounded_Secinfo4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_SECINFO4resok struct { + *_XdrVec_unbounded_Secinfo4 +} +func XDR_SECINFO4resok(v *SECINFO4resok) XdrType_SECINFO4resok { + return XdrType_SECINFO4resok{(*_XdrVec_unbounded_Secinfo4)(v)} +} +func (XdrType_SECINFO4resok) XdrTypeName() string { return "SECINFO4resok" } +func (v XdrType_SECINFO4resok) XdrUnwrap() XdrType { return v._XdrVec_unbounded_Secinfo4 } +func (u *SECINFO4res) Resok4() *SECINFO4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*SECINFO4resok); ok { + return v + } else { + var zero SECINFO4resok + u.U = &zero + return &zero + } + default: + XdrPanic("SECINFO4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u SECINFO4res) XdrValid() bool { + return true +} +func (u *SECINFO4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *SECINFO4res) XdrUnionTagName() string { + return "Status" +} +func (u *SECINFO4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_SECINFO4resok(u.Resok4()) + default: + return nil + } +} +func (u *SECINFO4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_SECINFO4res = *SECINFO4res +func (v *SECINFO4res) XdrPointer() interface{} { return v } +func (SECINFO4res) XdrTypeName() string { return "SECINFO4res" } +func (v SECINFO4res) XdrValue() interface{} { return v } +func (v *SECINFO4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *SECINFO4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_SECINFO4resok(u.Resok4())) + return + default: + return + } +} +func XDR_SECINFO4res(v *SECINFO4res) *SECINFO4res { return v} +type XdrType_SETATTR4args = *SETATTR4args +func (v *SETATTR4args) XdrPointer() interface{} { return v } +func (SETATTR4args) XdrTypeName() string { return "SETATTR4args" } +func (v SETATTR4args) XdrValue() interface{} { return v } +func (v *SETATTR4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SETATTR4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%sobj_attributes", name), XDR_Fattr4(&v.Obj_attributes)) +} +func XDR_SETATTR4args(v *SETATTR4args) *SETATTR4args { return v } +type XdrType_SETATTR4res = *SETATTR4res +func (v *SETATTR4res) XdrPointer() interface{} { return v } +func (SETATTR4res) XdrTypeName() string { return "SETATTR4res" } +func (v SETATTR4res) XdrValue() interface{} { return v } +func (v *SETATTR4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SETATTR4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) + x.Marshal(x.Sprintf("%sattrsset", name), XDR_Bitmap4(&v.Attrsset)) +} +func XDR_SETATTR4res(v *SETATTR4res) *SETATTR4res { return v } +type XdrType_SETCLIENTID4args = *SETCLIENTID4args +func (v *SETCLIENTID4args) XdrPointer() interface{} { return v } +func (SETCLIENTID4args) XdrTypeName() string { return "SETCLIENTID4args" } +func (v SETCLIENTID4args) XdrValue() interface{} { return v } +func (v *SETCLIENTID4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SETCLIENTID4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclient", name), XDR_Nfs_client_id4(&v.Client)) + x.Marshal(x.Sprintf("%scallback", name), XDR_Cb_client4(&v.Callback)) + x.Marshal(x.Sprintf("%scallback_ident", name), XDR_Uint32_t(&v.Callback_ident)) +} +func XDR_SETCLIENTID4args(v *SETCLIENTID4args) *SETCLIENTID4args { return v } +type XdrType_SETCLIENTID4resok = *SETCLIENTID4resok +func (v *SETCLIENTID4resok) XdrPointer() interface{} { return v } +func (SETCLIENTID4resok) XdrTypeName() string { return "SETCLIENTID4resok" } +func (v SETCLIENTID4resok) XdrValue() interface{} { return v } +func (v *SETCLIENTID4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SETCLIENTID4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclientid", name), XDR_Clientid4(&v.Clientid)) + x.Marshal(x.Sprintf("%ssetclientid_confirm", name), XDR_Verifier4(&v.Setclientid_confirm)) +} +func XDR_SETCLIENTID4resok(v *SETCLIENTID4resok) *SETCLIENTID4resok { return v } +func (u *SETCLIENTID4res) Resok4() *SETCLIENTID4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*SETCLIENTID4resok); ok { + return v + } else { + var zero SETCLIENTID4resok + u.U = &zero + return &zero + } + default: + XdrPanic("SETCLIENTID4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u *SETCLIENTID4res) Client_using() *Clientaddr4 { + switch u.Status { + case NFS4ERR_CLID_INUSE: + if v, ok := u.U.(*Clientaddr4); ok { + return v + } else { + var zero Clientaddr4 + u.U = &zero + return &zero + } + default: + XdrPanic("SETCLIENTID4res.Client_using accessed when Status == %v", u.Status) + return nil + } +} +func (u SETCLIENTID4res) XdrValid() bool { + return true +} +func (u *SETCLIENTID4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *SETCLIENTID4res) XdrUnionTagName() string { + return "Status" +} +func (u *SETCLIENTID4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_SETCLIENTID4resok(u.Resok4()) + case NFS4ERR_CLID_INUSE: + return XDR_Clientaddr4(u.Client_using()) + default: + return nil + } +} +func (u *SETCLIENTID4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + case NFS4ERR_CLID_INUSE: + return "Client_using" + default: + return "" + } +} +type XdrType_SETCLIENTID4res = *SETCLIENTID4res +func (v *SETCLIENTID4res) XdrPointer() interface{} { return v } +func (SETCLIENTID4res) XdrTypeName() string { return "SETCLIENTID4res" } +func (v SETCLIENTID4res) XdrValue() interface{} { return v } +func (v *SETCLIENTID4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *SETCLIENTID4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_SETCLIENTID4resok(u.Resok4())) + return + case NFS4ERR_CLID_INUSE: + x.Marshal(x.Sprintf("%sclient_using", name), XDR_Clientaddr4(u.Client_using())) + return + default: + return + } +} +func XDR_SETCLIENTID4res(v *SETCLIENTID4res) *SETCLIENTID4res { return v} +type XdrType_SETCLIENTID_CONFIRM4args = *SETCLIENTID_CONFIRM4args +func (v *SETCLIENTID_CONFIRM4args) XdrPointer() interface{} { return v } +func (SETCLIENTID_CONFIRM4args) XdrTypeName() string { return "SETCLIENTID_CONFIRM4args" } +func (v SETCLIENTID_CONFIRM4args) XdrValue() interface{} { return v } +func (v *SETCLIENTID_CONFIRM4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SETCLIENTID_CONFIRM4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sclientid", name), XDR_Clientid4(&v.Clientid)) + x.Marshal(x.Sprintf("%ssetclientid_confirm", name), XDR_Verifier4(&v.Setclientid_confirm)) +} +func XDR_SETCLIENTID_CONFIRM4args(v *SETCLIENTID_CONFIRM4args) *SETCLIENTID_CONFIRM4args { return v } +type XdrType_SETCLIENTID_CONFIRM4res = *SETCLIENTID_CONFIRM4res +func (v *SETCLIENTID_CONFIRM4res) XdrPointer() interface{} { return v } +func (SETCLIENTID_CONFIRM4res) XdrTypeName() string { return "SETCLIENTID_CONFIRM4res" } +func (v SETCLIENTID_CONFIRM4res) XdrValue() interface{} { return v } +func (v *SETCLIENTID_CONFIRM4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SETCLIENTID_CONFIRM4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_SETCLIENTID_CONFIRM4res(v *SETCLIENTID_CONFIRM4res) *SETCLIENTID_CONFIRM4res { return v } +type XdrType_VERIFY4args = *VERIFY4args +func (v *VERIFY4args) XdrPointer() interface{} { return v } +func (VERIFY4args) XdrTypeName() string { return "VERIFY4args" } +func (v VERIFY4args) XdrValue() interface{} { return v } +func (v *VERIFY4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *VERIFY4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobj_attributes", name), XDR_Fattr4(&v.Obj_attributes)) +} +func XDR_VERIFY4args(v *VERIFY4args) *VERIFY4args { return v } +type XdrType_VERIFY4res = *VERIFY4res +func (v *VERIFY4res) XdrPointer() interface{} { return v } +func (VERIFY4res) XdrTypeName() string { return "VERIFY4res" } +func (v VERIFY4res) XdrValue() interface{} { return v } +func (v *VERIFY4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *VERIFY4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_VERIFY4res(v *VERIFY4res) *VERIFY4res { return v } +var _XdrNames_Stable_how4 = map[int32]string{ + int32(UNSTABLE4): "UNSTABLE4", + int32(DATA_SYNC4): "DATA_SYNC4", + int32(FILE_SYNC4): "FILE_SYNC4", +} +var _XdrValues_Stable_how4 = map[string]int32{ + "UNSTABLE4": int32(UNSTABLE4), + "DATA_SYNC4": int32(DATA_SYNC4), + "FILE_SYNC4": int32(FILE_SYNC4), +} +func (Stable_how4) XdrEnumNames() map[int32]string { + return _XdrNames_Stable_how4 +} +func (v Stable_how4) String() string { + if s, ok := _XdrNames_Stable_how4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Stable_how4#%d", v) +} +func (v *Stable_how4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Stable_how4[stok]; ok { + *v = Stable_how4(val) + return nil + } else if stok == "Stable_how4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Stable_how4.", stok)) + } +} +func (v Stable_how4) GetU32() uint32 { return uint32(v) } +func (v *Stable_how4) SetU32(n uint32) { *v = Stable_how4(n) } +func (v *Stable_how4) XdrPointer() interface{} { return v } +func (Stable_how4) XdrTypeName() string { return "Stable_how4" } +func (v Stable_how4) XdrValue() interface{} { return v } +func (v *Stable_how4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Stable_how4 = *Stable_how4 +func XDR_Stable_how4(v *Stable_how4) *Stable_how4 { return v } +type XdrType_WRITE4args = *WRITE4args +func (v *WRITE4args) XdrPointer() interface{} { return v } +func (WRITE4args) XdrTypeName() string { return "WRITE4args" } +func (v WRITE4args) XdrValue() interface{} { return v } +func (v *WRITE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *WRITE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%soffset", name), XDR_Offset4(&v.Offset)) + x.Marshal(x.Sprintf("%sstable", name), XDR_Stable_how4(&v.Stable)) + x.Marshal(x.Sprintf("%sdata", name), XdrVecOpaque{&v.Data, 0xffffffff}) +} +func XDR_WRITE4args(v *WRITE4args) *WRITE4args { return v } +type XdrType_WRITE4resok = *WRITE4resok +func (v *WRITE4resok) XdrPointer() interface{} { return v } +func (WRITE4resok) XdrTypeName() string { return "WRITE4resok" } +func (v WRITE4resok) XdrValue() interface{} { return v } +func (v *WRITE4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *WRITE4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scount", name), XDR_Count4(&v.Count)) + x.Marshal(x.Sprintf("%scommitted", name), XDR_Stable_how4(&v.Committed)) + x.Marshal(x.Sprintf("%swriteverf", name), XDR_Verifier4(&v.Writeverf)) +} +func XDR_WRITE4resok(v *WRITE4resok) *WRITE4resok { return v } +func (u *WRITE4res) Resok4() *WRITE4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*WRITE4resok); ok { + return v + } else { + var zero WRITE4resok + u.U = &zero + return &zero + } + default: + XdrPanic("WRITE4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u WRITE4res) XdrValid() bool { + return true +} +func (u *WRITE4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *WRITE4res) XdrUnionTagName() string { + return "Status" +} +func (u *WRITE4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_WRITE4resok(u.Resok4()) + default: + return nil + } +} +func (u *WRITE4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_WRITE4res = *WRITE4res +func (v *WRITE4res) XdrPointer() interface{} { return v } +func (WRITE4res) XdrTypeName() string { return "WRITE4res" } +func (v WRITE4res) XdrValue() interface{} { return v } +func (v *WRITE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *WRITE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_WRITE4resok(u.Resok4())) + return + default: + return + } +} +func XDR_WRITE4res(v *WRITE4res) *WRITE4res { return v} +type XdrType_RELEASE_LOCKOWNER4args = *RELEASE_LOCKOWNER4args +func (v *RELEASE_LOCKOWNER4args) XdrPointer() interface{} { return v } +func (RELEASE_LOCKOWNER4args) XdrTypeName() string { return "RELEASE_LOCKOWNER4args" } +func (v RELEASE_LOCKOWNER4args) XdrValue() interface{} { return v } +func (v *RELEASE_LOCKOWNER4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RELEASE_LOCKOWNER4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slock_owner", name), XDR_Lock_owner4(&v.Lock_owner)) +} +func XDR_RELEASE_LOCKOWNER4args(v *RELEASE_LOCKOWNER4args) *RELEASE_LOCKOWNER4args { return v } +type XdrType_RELEASE_LOCKOWNER4res = *RELEASE_LOCKOWNER4res +func (v *RELEASE_LOCKOWNER4res) XdrPointer() interface{} { return v } +func (RELEASE_LOCKOWNER4res) XdrTypeName() string { return "RELEASE_LOCKOWNER4res" } +func (v RELEASE_LOCKOWNER4res) XdrValue() interface{} { return v } +func (v *RELEASE_LOCKOWNER4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RELEASE_LOCKOWNER4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_RELEASE_LOCKOWNER4res(v *RELEASE_LOCKOWNER4res) *RELEASE_LOCKOWNER4res { return v } +var _XdrTags_Callback_sec_parms4 = map[int32]bool{ + XdrToI32(AUTH_NONE): true, + XdrToI32(AUTH_SYS): true, +} +func (_ Callback_sec_parms4) XdrValidTags() map[int32]bool { + return _XdrTags_Callback_sec_parms4 +} +/* RFC 1831 */ +func (u *Callback_sec_parms4) Cbsp_sys_cred() *Authsys_parms { + switch Auth_flavor(u.Cb_secflavor) { + case AUTH_SYS: + if v, ok := u.U.(*Authsys_parms); ok { + return v + } else { + var zero Authsys_parms + u.U = &zero + return &zero + } + default: + XdrPanic("Callback_sec_parms4.Cbsp_sys_cred accessed when Cb_secflavor == %v", u.Cb_secflavor) + return nil + } +} +func (u Callback_sec_parms4) XdrValid() bool { + switch Auth_flavor(u.Cb_secflavor) { + case AUTH_NONE,AUTH_SYS: + return true + } + return false +} +func (u *Callback_sec_parms4) XdrUnionTag() XdrNum32 { + return XDR_Uint32_t(&u.Cb_secflavor) +} +func (u *Callback_sec_parms4) XdrUnionTagName() string { + return "Cb_secflavor" +} +func (u *Callback_sec_parms4) XdrUnionBody() XdrType { + switch Auth_flavor(u.Cb_secflavor) { + case AUTH_NONE: + return nil + case AUTH_SYS: + return XDR_Authsys_parms(u.Cbsp_sys_cred()) + } + return nil +} +func (u *Callback_sec_parms4) XdrUnionBodyName() string { + switch Auth_flavor(u.Cb_secflavor) { + case AUTH_NONE: + return "" + case AUTH_SYS: + return "Cbsp_sys_cred" + } + return "" +} +type XdrType_Callback_sec_parms4 = *Callback_sec_parms4 +func (v *Callback_sec_parms4) XdrPointer() interface{} { return v } +func (Callback_sec_parms4) XdrTypeName() string { return "Callback_sec_parms4" } +func (v Callback_sec_parms4) XdrValue() interface{} { return v } +func (v *Callback_sec_parms4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Callback_sec_parms4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Uint32_t(&u.Cb_secflavor).XdrMarshal(x, x.Sprintf("%scb_secflavor", name)) + switch Auth_flavor(u.Cb_secflavor) { + case AUTH_NONE: + return + case AUTH_SYS: + x.Marshal(x.Sprintf("%scbsp_sys_cred", name), XDR_Authsys_parms(u.Cbsp_sys_cred())) + return + } + XdrPanic("invalid Cb_secflavor (%v) in Callback_sec_parms4", u.Cb_secflavor) +} +func (v *Callback_sec_parms4) XdrInitialize() { + var zero Uint32_t + switch Auth_flavor(zero) { + case AUTH_NONE, AUTH_SYS: + default: + if v.Cb_secflavor == zero { v.Cb_secflavor = uint32(AUTH_NONE) } + } +} +func XDR_Callback_sec_parms4(v *Callback_sec_parms4) *Callback_sec_parms4 { return v} +type _XdrVec_1_Uint32_t []Uint32_t +func (_XdrVec_1_Uint32_t) XdrBound() uint32 { + const bound uint32 = 1 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_1_Uint32_t) XdrCheckLen(length uint32) { + if length > uint32(1) { + XdrPanic("_XdrVec_1_Uint32_t length %d exceeds bound 1", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_1_Uint32_t length %d exceeds max int", length) + } +} +func (v _XdrVec_1_Uint32_t) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_1_Uint32_t) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(1); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Uint32_t, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_1_Uint32_t) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Uint32_t(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_1_Uint32_t) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 1 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_1_Uint32_t) XdrTypeName() string { return "Uint32_t<>" } +func (v *_XdrVec_1_Uint32_t) XdrPointer() interface{} { return (*[]Uint32_t)(v) } +func (v _XdrVec_1_Uint32_t) XdrValue() interface{} { return ([]Uint32_t)(v) } +func (v *_XdrVec_1_Uint32_t) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Channel_attrs4 = *Channel_attrs4 +func (v *Channel_attrs4) XdrPointer() interface{} { return v } +func (Channel_attrs4) XdrTypeName() string { return "Channel_attrs4" } +func (v Channel_attrs4) XdrValue() interface{} { return v } +func (v *Channel_attrs4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Channel_attrs4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sca_headerpadsize", name), XDR_Count4(&v.Ca_headerpadsize)) + x.Marshal(x.Sprintf("%sca_maxrequestsize", name), XDR_Count4(&v.Ca_maxrequestsize)) + x.Marshal(x.Sprintf("%sca_maxresponsesize", name), XDR_Count4(&v.Ca_maxresponsesize)) + x.Marshal(x.Sprintf("%sca_maxresponsesize_cached", name), XDR_Count4(&v.Ca_maxresponsesize_cached)) + x.Marshal(x.Sprintf("%sca_maxoperations", name), XDR_Count4(&v.Ca_maxoperations)) + x.Marshal(x.Sprintf("%sca_maxrequests", name), XDR_Count4(&v.Ca_maxrequests)) + x.Marshal(x.Sprintf("%sca_rdma_ird", name), (*_XdrVec_1_Uint32_t)(&v.Ca_rdma_ird)) +} +func XDR_Channel_attrs4(v *Channel_attrs4) *Channel_attrs4 { return v } +type _XdrVec_unbounded_Callback_sec_parms4 []Callback_sec_parms4 +func (_XdrVec_unbounded_Callback_sec_parms4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Callback_sec_parms4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Callback_sec_parms4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Callback_sec_parms4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Callback_sec_parms4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Callback_sec_parms4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Callback_sec_parms4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Callback_sec_parms4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Callback_sec_parms4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Callback_sec_parms4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Callback_sec_parms4) XdrTypeName() string { return "Callback_sec_parms4<>" } +func (v *_XdrVec_unbounded_Callback_sec_parms4) XdrPointer() interface{} { return (*[]Callback_sec_parms4)(v) } +func (v _XdrVec_unbounded_Callback_sec_parms4) XdrValue() interface{} { return ([]Callback_sec_parms4)(v) } +func (v *_XdrVec_unbounded_Callback_sec_parms4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_CREATE_SESSION4args = *CREATE_SESSION4args +func (v *CREATE_SESSION4args) XdrPointer() interface{} { return v } +func (CREATE_SESSION4args) XdrTypeName() string { return "CREATE_SESSION4args" } +func (v CREATE_SESSION4args) XdrValue() interface{} { return v } +func (v *CREATE_SESSION4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CREATE_SESSION4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scsa_clientid", name), XDR_Clientid4(&v.Csa_clientid)) + x.Marshal(x.Sprintf("%scsa_sequence", name), XDR_Sequenceid4(&v.Csa_sequence)) + x.Marshal(x.Sprintf("%scsa_flags", name), XDR_Uint32_t(&v.Csa_flags)) + x.Marshal(x.Sprintf("%scsa_fore_chan_attrs", name), XDR_Channel_attrs4(&v.Csa_fore_chan_attrs)) + x.Marshal(x.Sprintf("%scsa_back_chan_attrs", name), XDR_Channel_attrs4(&v.Csa_back_chan_attrs)) + x.Marshal(x.Sprintf("%scsa_cb_program", name), XDR_Uint32_t(&v.Csa_cb_program)) + x.Marshal(x.Sprintf("%scsa_sec_parms", name), (*_XdrVec_unbounded_Callback_sec_parms4)(&v.Csa_sec_parms)) +} +func XDR_CREATE_SESSION4args(v *CREATE_SESSION4args) *CREATE_SESSION4args { return v } +type XdrType_CREATE_SESSION4resok = *CREATE_SESSION4resok +func (v *CREATE_SESSION4resok) XdrPointer() interface{} { return v } +func (CREATE_SESSION4resok) XdrTypeName() string { return "CREATE_SESSION4resok" } +func (v CREATE_SESSION4resok) XdrValue() interface{} { return v } +func (v *CREATE_SESSION4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CREATE_SESSION4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%scsr_sessionid", name), XDR_Sessionid4(&v.Csr_sessionid)) + x.Marshal(x.Sprintf("%scsr_sequence", name), XDR_Sequenceid4(&v.Csr_sequence)) + x.Marshal(x.Sprintf("%scsr_flags", name), XDR_Uint32_t(&v.Csr_flags)) + x.Marshal(x.Sprintf("%scsr_fore_chan_attrs", name), XDR_Channel_attrs4(&v.Csr_fore_chan_attrs)) + x.Marshal(x.Sprintf("%scsr_back_chan_attrs", name), XDR_Channel_attrs4(&v.Csr_back_chan_attrs)) +} +func XDR_CREATE_SESSION4resok(v *CREATE_SESSION4resok) *CREATE_SESSION4resok { return v } +func (u *CREATE_SESSION4res) Csr_resok4() *CREATE_SESSION4resok { + switch u.Csr_status { + case NFS4_OK: + if v, ok := u.U.(*CREATE_SESSION4resok); ok { + return v + } else { + var zero CREATE_SESSION4resok + u.U = &zero + return &zero + } + default: + XdrPanic("CREATE_SESSION4res.Csr_resok4 accessed when Csr_status == %v", u.Csr_status) + return nil + } +} +func (u CREATE_SESSION4res) XdrValid() bool { + return true +} +func (u *CREATE_SESSION4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Csr_status) +} +func (u *CREATE_SESSION4res) XdrUnionTagName() string { + return "Csr_status" +} +func (u *CREATE_SESSION4res) XdrUnionBody() XdrType { + switch u.Csr_status { + case NFS4_OK: + return XDR_CREATE_SESSION4resok(u.Csr_resok4()) + default: + return nil + } +} +func (u *CREATE_SESSION4res) XdrUnionBodyName() string { + switch u.Csr_status { + case NFS4_OK: + return "Csr_resok4" + default: + return "" + } +} +type XdrType_CREATE_SESSION4res = *CREATE_SESSION4res +func (v *CREATE_SESSION4res) XdrPointer() interface{} { return v } +func (CREATE_SESSION4res) XdrTypeName() string { return "CREATE_SESSION4res" } +func (v CREATE_SESSION4res) XdrValue() interface{} { return v } +func (v *CREATE_SESSION4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *CREATE_SESSION4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Csr_status).XdrMarshal(x, x.Sprintf("%scsr_status", name)) + switch u.Csr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%scsr_resok4", name), XDR_CREATE_SESSION4resok(u.Csr_resok4())) + return + default: + return + } +} +func XDR_CREATE_SESSION4res(v *CREATE_SESSION4res) *CREATE_SESSION4res { return v} +type XdrType_DESTROY_SESSION4args = *DESTROY_SESSION4args +func (v *DESTROY_SESSION4args) XdrPointer() interface{} { return v } +func (DESTROY_SESSION4args) XdrTypeName() string { return "DESTROY_SESSION4args" } +func (v DESTROY_SESSION4args) XdrValue() interface{} { return v } +func (v *DESTROY_SESSION4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DESTROY_SESSION4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sdsa_sessionid", name), XDR_Sessionid4(&v.Dsa_sessionid)) +} +func XDR_DESTROY_SESSION4args(v *DESTROY_SESSION4args) *DESTROY_SESSION4args { return v } +type XdrType_DESTROY_SESSION4res = *DESTROY_SESSION4res +func (v *DESTROY_SESSION4res) XdrPointer() interface{} { return v } +func (DESTROY_SESSION4res) XdrTypeName() string { return "DESTROY_SESSION4res" } +func (v DESTROY_SESSION4res) XdrValue() interface{} { return v } +func (v *DESTROY_SESSION4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DESTROY_SESSION4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sdsr_status", name), XDR_Nfsstat4(&v.Dsr_status)) +} +func XDR_DESTROY_SESSION4res(v *DESTROY_SESSION4res) *DESTROY_SESSION4res { return v } +type XdrType_FREE_STATEID4args = *FREE_STATEID4args +func (v *FREE_STATEID4args) XdrPointer() interface{} { return v } +func (FREE_STATEID4args) XdrTypeName() string { return "FREE_STATEID4args" } +func (v FREE_STATEID4args) XdrValue() interface{} { return v } +func (v *FREE_STATEID4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *FREE_STATEID4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sfsa_stateid", name), XDR_Stateid4(&v.Fsa_stateid)) +} +func XDR_FREE_STATEID4args(v *FREE_STATEID4args) *FREE_STATEID4args { return v } +type XdrType_FREE_STATEID4res = *FREE_STATEID4res +func (v *FREE_STATEID4res) XdrPointer() interface{} { return v } +func (FREE_STATEID4res) XdrTypeName() string { return "FREE_STATEID4res" } +func (v FREE_STATEID4res) XdrValue() interface{} { return v } +func (v *FREE_STATEID4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *FREE_STATEID4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sfsr_status", name), XDR_Nfsstat4(&v.Fsr_status)) +} +func XDR_FREE_STATEID4res(v *FREE_STATEID4res) *FREE_STATEID4res { return v } +type XdrType_Attr_notice4 struct { + XdrType_Nfstime4 +} +func XDR_Attr_notice4(v *Attr_notice4) *XdrType_Attr_notice4 { + return &XdrType_Attr_notice4{XDR_Nfstime4(v)} +} +func (XdrType_Attr_notice4) XdrTypeName() string { return "Attr_notice4" } +func (v XdrType_Attr_notice4) XdrUnwrap() XdrType { return v.XdrType_Nfstime4 } +type XdrType_GET_DIR_DELEGATION4args = *GET_DIR_DELEGATION4args +func (v *GET_DIR_DELEGATION4args) XdrPointer() interface{} { return v } +func (GET_DIR_DELEGATION4args) XdrTypeName() string { return "GET_DIR_DELEGATION4args" } +func (v GET_DIR_DELEGATION4args) XdrValue() interface{} { return v } +func (v *GET_DIR_DELEGATION4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GET_DIR_DELEGATION4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sgdda_signal_deleg_avail", name), XDR_bool(&v.Gdda_signal_deleg_avail)) + x.Marshal(x.Sprintf("%sgdda_notification_types", name), XDR_Bitmap4(&v.Gdda_notification_types)) + x.Marshal(x.Sprintf("%sgdda_child_attr_delay", name), XDR_Attr_notice4(&v.Gdda_child_attr_delay)) + x.Marshal(x.Sprintf("%sgdda_dir_attr_delay", name), XDR_Attr_notice4(&v.Gdda_dir_attr_delay)) + x.Marshal(x.Sprintf("%sgdda_child_attributes", name), XDR_Bitmap4(&v.Gdda_child_attributes)) + x.Marshal(x.Sprintf("%sgdda_dir_attributes", name), XDR_Bitmap4(&v.Gdda_dir_attributes)) +} +func XDR_GET_DIR_DELEGATION4args(v *GET_DIR_DELEGATION4args) *GET_DIR_DELEGATION4args { return v } +type XdrType_GET_DIR_DELEGATION4resok = *GET_DIR_DELEGATION4resok +func (v *GET_DIR_DELEGATION4resok) XdrPointer() interface{} { return v } +func (GET_DIR_DELEGATION4resok) XdrTypeName() string { return "GET_DIR_DELEGATION4resok" } +func (v GET_DIR_DELEGATION4resok) XdrValue() interface{} { return v } +func (v *GET_DIR_DELEGATION4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GET_DIR_DELEGATION4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sgddr_cookieverf", name), XDR_Verifier4(&v.Gddr_cookieverf)) + x.Marshal(x.Sprintf("%sgddr_stateid", name), XDR_Stateid4(&v.Gddr_stateid)) + x.Marshal(x.Sprintf("%sgddr_notification", name), XDR_Bitmap4(&v.Gddr_notification)) + x.Marshal(x.Sprintf("%sgddr_child_attributes", name), XDR_Bitmap4(&v.Gddr_child_attributes)) + x.Marshal(x.Sprintf("%sgddr_dir_attributes", name), XDR_Bitmap4(&v.Gddr_dir_attributes)) +} +func XDR_GET_DIR_DELEGATION4resok(v *GET_DIR_DELEGATION4resok) *GET_DIR_DELEGATION4resok { return v } +var _XdrNames_Gddrnf4_status = map[int32]string{ + int32(GDD4_OK): "GDD4_OK", + int32(GDD4_UNAVAIL): "GDD4_UNAVAIL", +} +var _XdrValues_Gddrnf4_status = map[string]int32{ + "GDD4_OK": int32(GDD4_OK), + "GDD4_UNAVAIL": int32(GDD4_UNAVAIL), +} +func (Gddrnf4_status) XdrEnumNames() map[int32]string { + return _XdrNames_Gddrnf4_status +} +func (v Gddrnf4_status) String() string { + if s, ok := _XdrNames_Gddrnf4_status[int32(v)]; ok { + return s + } + return fmt.Sprintf("Gddrnf4_status#%d", v) +} +func (v *Gddrnf4_status) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Gddrnf4_status[stok]; ok { + *v = Gddrnf4_status(val) + return nil + } else if stok == "Gddrnf4_status" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Gddrnf4_status.", stok)) + } +} +func (v Gddrnf4_status) GetU32() uint32 { return uint32(v) } +func (v *Gddrnf4_status) SetU32(n uint32) { *v = Gddrnf4_status(n) } +func (v *Gddrnf4_status) XdrPointer() interface{} { return v } +func (Gddrnf4_status) XdrTypeName() string { return "Gddrnf4_status" } +func (v Gddrnf4_status) XdrValue() interface{} { return v } +func (v *Gddrnf4_status) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Gddrnf4_status = *Gddrnf4_status +func XDR_Gddrnf4_status(v *Gddrnf4_status) *Gddrnf4_status { return v } +var _XdrTags_GET_DIR_DELEGATION4res_non_fatal = map[int32]bool{ + XdrToI32(GDD4_OK): true, + XdrToI32(GDD4_UNAVAIL): true, +} +func (_ GET_DIR_DELEGATION4res_non_fatal) XdrValidTags() map[int32]bool { + return _XdrTags_GET_DIR_DELEGATION4res_non_fatal +} +func (u *GET_DIR_DELEGATION4res_non_fatal) Gddrnf_resok4() *GET_DIR_DELEGATION4resok { + switch u.Gddrnf_status { + case GDD4_OK: + if v, ok := u.U.(*GET_DIR_DELEGATION4resok); ok { + return v + } else { + var zero GET_DIR_DELEGATION4resok + u.U = &zero + return &zero + } + default: + XdrPanic("GET_DIR_DELEGATION4res_non_fatal.Gddrnf_resok4 accessed when Gddrnf_status == %v", u.Gddrnf_status) + return nil + } +} +func (u *GET_DIR_DELEGATION4res_non_fatal) Gddrnf_will_signal_deleg_avail() *bool { + switch u.Gddrnf_status { + case GDD4_UNAVAIL: + if v, ok := u.U.(*bool); ok { + return v + } else { + var zero bool + u.U = &zero + return &zero + } + default: + XdrPanic("GET_DIR_DELEGATION4res_non_fatal.Gddrnf_will_signal_deleg_avail accessed when Gddrnf_status == %v", u.Gddrnf_status) + return nil + } +} +func (u GET_DIR_DELEGATION4res_non_fatal) XdrValid() bool { + switch u.Gddrnf_status { + case GDD4_OK,GDD4_UNAVAIL: + return true + } + return false +} +func (u *GET_DIR_DELEGATION4res_non_fatal) XdrUnionTag() XdrNum32 { + return XDR_Gddrnf4_status(&u.Gddrnf_status) +} +func (u *GET_DIR_DELEGATION4res_non_fatal) XdrUnionTagName() string { + return "Gddrnf_status" +} +func (u *GET_DIR_DELEGATION4res_non_fatal) XdrUnionBody() XdrType { + switch u.Gddrnf_status { + case GDD4_OK: + return XDR_GET_DIR_DELEGATION4resok(u.Gddrnf_resok4()) + case GDD4_UNAVAIL: + return XDR_bool(u.Gddrnf_will_signal_deleg_avail()) + } + return nil +} +func (u *GET_DIR_DELEGATION4res_non_fatal) XdrUnionBodyName() string { + switch u.Gddrnf_status { + case GDD4_OK: + return "Gddrnf_resok4" + case GDD4_UNAVAIL: + return "Gddrnf_will_signal_deleg_avail" + } + return "" +} +type XdrType_GET_DIR_DELEGATION4res_non_fatal = *GET_DIR_DELEGATION4res_non_fatal +func (v *GET_DIR_DELEGATION4res_non_fatal) XdrPointer() interface{} { return v } +func (GET_DIR_DELEGATION4res_non_fatal) XdrTypeName() string { return "GET_DIR_DELEGATION4res_non_fatal" } +func (v GET_DIR_DELEGATION4res_non_fatal) XdrValue() interface{} { return v } +func (v *GET_DIR_DELEGATION4res_non_fatal) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *GET_DIR_DELEGATION4res_non_fatal) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Gddrnf4_status(&u.Gddrnf_status).XdrMarshal(x, x.Sprintf("%sgddrnf_status", name)) + switch u.Gddrnf_status { + case GDD4_OK: + x.Marshal(x.Sprintf("%sgddrnf_resok4", name), XDR_GET_DIR_DELEGATION4resok(u.Gddrnf_resok4())) + return + case GDD4_UNAVAIL: + x.Marshal(x.Sprintf("%sgddrnf_will_signal_deleg_avail", name), XDR_bool(u.Gddrnf_will_signal_deleg_avail())) + return + } + XdrPanic("invalid Gddrnf_status (%v) in GET_DIR_DELEGATION4res_non_fatal", u.Gddrnf_status) +} +func XDR_GET_DIR_DELEGATION4res_non_fatal(v *GET_DIR_DELEGATION4res_non_fatal) *GET_DIR_DELEGATION4res_non_fatal { return v} +func (u *GET_DIR_DELEGATION4res) Gddr_res_non_fatal4() *GET_DIR_DELEGATION4res_non_fatal { + switch u.Gddr_status { + case NFS4_OK: + if v, ok := u.U.(*GET_DIR_DELEGATION4res_non_fatal); ok { + return v + } else { + var zero GET_DIR_DELEGATION4res_non_fatal + u.U = &zero + return &zero + } + default: + XdrPanic("GET_DIR_DELEGATION4res.Gddr_res_non_fatal4 accessed when Gddr_status == %v", u.Gddr_status) + return nil + } +} +func (u GET_DIR_DELEGATION4res) XdrValid() bool { + return true +} +func (u *GET_DIR_DELEGATION4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Gddr_status) +} +func (u *GET_DIR_DELEGATION4res) XdrUnionTagName() string { + return "Gddr_status" +} +func (u *GET_DIR_DELEGATION4res) XdrUnionBody() XdrType { + switch u.Gddr_status { + case NFS4_OK: + return XDR_GET_DIR_DELEGATION4res_non_fatal(u.Gddr_res_non_fatal4()) + default: + return nil + } +} +func (u *GET_DIR_DELEGATION4res) XdrUnionBodyName() string { + switch u.Gddr_status { + case NFS4_OK: + return "Gddr_res_non_fatal4" + default: + return "" + } +} +type XdrType_GET_DIR_DELEGATION4res = *GET_DIR_DELEGATION4res +func (v *GET_DIR_DELEGATION4res) XdrPointer() interface{} { return v } +func (GET_DIR_DELEGATION4res) XdrTypeName() string { return "GET_DIR_DELEGATION4res" } +func (v GET_DIR_DELEGATION4res) XdrValue() interface{} { return v } +func (v *GET_DIR_DELEGATION4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *GET_DIR_DELEGATION4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Gddr_status).XdrMarshal(x, x.Sprintf("%sgddr_status", name)) + switch u.Gddr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sgddr_res_non_fatal4", name), XDR_GET_DIR_DELEGATION4res_non_fatal(u.Gddr_res_non_fatal4())) + return + default: + return + } +} +func XDR_GET_DIR_DELEGATION4res(v *GET_DIR_DELEGATION4res) *GET_DIR_DELEGATION4res { return v} +type XdrType_GETDEVICEINFO4args = *GETDEVICEINFO4args +func (v *GETDEVICEINFO4args) XdrPointer() interface{} { return v } +func (GETDEVICEINFO4args) XdrTypeName() string { return "GETDEVICEINFO4args" } +func (v GETDEVICEINFO4args) XdrValue() interface{} { return v } +func (v *GETDEVICEINFO4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETDEVICEINFO4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sgdia_device_id", name), XDR_Deviceid4(&v.Gdia_device_id)) + x.Marshal(x.Sprintf("%sgdia_layout_type", name), XDR_Layouttype4(&v.Gdia_layout_type)) + x.Marshal(x.Sprintf("%sgdia_maxcount", name), XDR_Count4(&v.Gdia_maxcount)) + x.Marshal(x.Sprintf("%sgdia_notify_types", name), XDR_Bitmap4(&v.Gdia_notify_types)) +} +func XDR_GETDEVICEINFO4args(v *GETDEVICEINFO4args) *GETDEVICEINFO4args { return v } +type XdrType_GETDEVICEINFO4resok = *GETDEVICEINFO4resok +func (v *GETDEVICEINFO4resok) XdrPointer() interface{} { return v } +func (GETDEVICEINFO4resok) XdrTypeName() string { return "GETDEVICEINFO4resok" } +func (v GETDEVICEINFO4resok) XdrValue() interface{} { return v } +func (v *GETDEVICEINFO4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETDEVICEINFO4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sgdir_device_addr", name), XDR_Device_addr4(&v.Gdir_device_addr)) + x.Marshal(x.Sprintf("%sgdir_notification", name), XDR_Bitmap4(&v.Gdir_notification)) +} +func XDR_GETDEVICEINFO4resok(v *GETDEVICEINFO4resok) *GETDEVICEINFO4resok { return v } +func (u *GETDEVICEINFO4res) Gdir_resok4() *GETDEVICEINFO4resok { + switch u.Gdir_status { + case NFS4_OK: + if v, ok := u.U.(*GETDEVICEINFO4resok); ok { + return v + } else { + var zero GETDEVICEINFO4resok + u.U = &zero + return &zero + } + default: + XdrPanic("GETDEVICEINFO4res.Gdir_resok4 accessed when Gdir_status == %v", u.Gdir_status) + return nil + } +} +func (u *GETDEVICEINFO4res) Gdir_mincount() *Count4 { + switch u.Gdir_status { + case NFS4ERR_TOOSMALL: + if v, ok := u.U.(*Count4); ok { + return v + } else { + var zero Count4 + u.U = &zero + return &zero + } + default: + XdrPanic("GETDEVICEINFO4res.Gdir_mincount accessed when Gdir_status == %v", u.Gdir_status) + return nil + } +} +func (u GETDEVICEINFO4res) XdrValid() bool { + return true +} +func (u *GETDEVICEINFO4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Gdir_status) +} +func (u *GETDEVICEINFO4res) XdrUnionTagName() string { + return "Gdir_status" +} +func (u *GETDEVICEINFO4res) XdrUnionBody() XdrType { + switch u.Gdir_status { + case NFS4_OK: + return XDR_GETDEVICEINFO4resok(u.Gdir_resok4()) + case NFS4ERR_TOOSMALL: + return XDR_Count4(u.Gdir_mincount()) + default: + return nil + } +} +func (u *GETDEVICEINFO4res) XdrUnionBodyName() string { + switch u.Gdir_status { + case NFS4_OK: + return "Gdir_resok4" + case NFS4ERR_TOOSMALL: + return "Gdir_mincount" + default: + return "" + } +} +type XdrType_GETDEVICEINFO4res = *GETDEVICEINFO4res +func (v *GETDEVICEINFO4res) XdrPointer() interface{} { return v } +func (GETDEVICEINFO4res) XdrTypeName() string { return "GETDEVICEINFO4res" } +func (v GETDEVICEINFO4res) XdrValue() interface{} { return v } +func (v *GETDEVICEINFO4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *GETDEVICEINFO4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Gdir_status).XdrMarshal(x, x.Sprintf("%sgdir_status", name)) + switch u.Gdir_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sgdir_resok4", name), XDR_GETDEVICEINFO4resok(u.Gdir_resok4())) + return + case NFS4ERR_TOOSMALL: + x.Marshal(x.Sprintf("%sgdir_mincount", name), XDR_Count4(u.Gdir_mincount())) + return + default: + return + } +} +func XDR_GETDEVICEINFO4res(v *GETDEVICEINFO4res) *GETDEVICEINFO4res { return v} +type XdrType_GETDEVICELIST4args = *GETDEVICELIST4args +func (v *GETDEVICELIST4args) XdrPointer() interface{} { return v } +func (GETDEVICELIST4args) XdrTypeName() string { return "GETDEVICELIST4args" } +func (v GETDEVICELIST4args) XdrValue() interface{} { return v } +func (v *GETDEVICELIST4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETDEVICELIST4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sgdla_layout_type", name), XDR_Layouttype4(&v.Gdla_layout_type)) + x.Marshal(x.Sprintf("%sgdla_maxdevices", name), XDR_Count4(&v.Gdla_maxdevices)) + x.Marshal(x.Sprintf("%sgdla_cookie", name), XDR_Nfs_cookie4(&v.Gdla_cookie)) + x.Marshal(x.Sprintf("%sgdla_cookieverf", name), XDR_Verifier4(&v.Gdla_cookieverf)) +} +func XDR_GETDEVICELIST4args(v *GETDEVICELIST4args) *GETDEVICELIST4args { return v } +type _XdrVec_unbounded_Deviceid4 []Deviceid4 +func (_XdrVec_unbounded_Deviceid4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Deviceid4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Deviceid4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Deviceid4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Deviceid4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Deviceid4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Deviceid4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Deviceid4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Deviceid4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Deviceid4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Deviceid4) XdrTypeName() string { return "Deviceid4<>" } +func (v *_XdrVec_unbounded_Deviceid4) XdrPointer() interface{} { return (*[]Deviceid4)(v) } +func (v _XdrVec_unbounded_Deviceid4) XdrValue() interface{} { return ([]Deviceid4)(v) } +func (v *_XdrVec_unbounded_Deviceid4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_GETDEVICELIST4resok = *GETDEVICELIST4resok +func (v *GETDEVICELIST4resok) XdrPointer() interface{} { return v } +func (GETDEVICELIST4resok) XdrTypeName() string { return "GETDEVICELIST4resok" } +func (v GETDEVICELIST4resok) XdrValue() interface{} { return v } +func (v *GETDEVICELIST4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *GETDEVICELIST4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sgdlr_cookie", name), XDR_Nfs_cookie4(&v.Gdlr_cookie)) + x.Marshal(x.Sprintf("%sgdlr_cookieverf", name), XDR_Verifier4(&v.Gdlr_cookieverf)) + x.Marshal(x.Sprintf("%sgdlr_deviceid_list", name), (*_XdrVec_unbounded_Deviceid4)(&v.Gdlr_deviceid_list)) + x.Marshal(x.Sprintf("%sgdlr_eof", name), XDR_bool(&v.Gdlr_eof)) +} +func XDR_GETDEVICELIST4resok(v *GETDEVICELIST4resok) *GETDEVICELIST4resok { return v } +func (u *GETDEVICELIST4res) Gdlr_resok4() *GETDEVICELIST4resok { + switch u.Gdlr_status { + case NFS4_OK: + if v, ok := u.U.(*GETDEVICELIST4resok); ok { + return v + } else { + var zero GETDEVICELIST4resok + u.U = &zero + return &zero + } + default: + XdrPanic("GETDEVICELIST4res.Gdlr_resok4 accessed when Gdlr_status == %v", u.Gdlr_status) + return nil + } +} +func (u GETDEVICELIST4res) XdrValid() bool { + return true +} +func (u *GETDEVICELIST4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Gdlr_status) +} +func (u *GETDEVICELIST4res) XdrUnionTagName() string { + return "Gdlr_status" +} +func (u *GETDEVICELIST4res) XdrUnionBody() XdrType { + switch u.Gdlr_status { + case NFS4_OK: + return XDR_GETDEVICELIST4resok(u.Gdlr_resok4()) + default: + return nil + } +} +func (u *GETDEVICELIST4res) XdrUnionBodyName() string { + switch u.Gdlr_status { + case NFS4_OK: + return "Gdlr_resok4" + default: + return "" + } +} +type XdrType_GETDEVICELIST4res = *GETDEVICELIST4res +func (v *GETDEVICELIST4res) XdrPointer() interface{} { return v } +func (GETDEVICELIST4res) XdrTypeName() string { return "GETDEVICELIST4res" } +func (v GETDEVICELIST4res) XdrValue() interface{} { return v } +func (v *GETDEVICELIST4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *GETDEVICELIST4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Gdlr_status).XdrMarshal(x, x.Sprintf("%sgdlr_status", name)) + switch u.Gdlr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sgdlr_resok4", name), XDR_GETDEVICELIST4resok(u.Gdlr_resok4())) + return + default: + return + } +} +func XDR_GETDEVICELIST4res(v *GETDEVICELIST4res) *GETDEVICELIST4res { return v} +var _XdrTags_Newtime4 = map[int32]bool{ + XdrToI32(true): true, + XdrToI32(false): true, +} +func (_ Newtime4) XdrValidTags() map[int32]bool { + return _XdrTags_Newtime4 +} +func (u *Newtime4) Nt_time() *Nfstime4 { + switch u.Nt_timechanged { + case true: + if v, ok := u.U.(*Nfstime4); ok { + return v + } else { + var zero Nfstime4 + u.U = &zero + return &zero + } + default: + XdrPanic("Newtime4.Nt_time accessed when Nt_timechanged == %v", u.Nt_timechanged) + return nil + } +} +func (u Newtime4) XdrValid() bool { + switch u.Nt_timechanged { + case true,false: + return true + } + return false +} +func (u *Newtime4) XdrUnionTag() XdrNum32 { + return XDR_bool(&u.Nt_timechanged) +} +func (u *Newtime4) XdrUnionTagName() string { + return "Nt_timechanged" +} +func (u *Newtime4) XdrUnionBody() XdrType { + switch u.Nt_timechanged { + case true: + return XDR_Nfstime4(u.Nt_time()) + case false: + return nil + } + return nil +} +func (u *Newtime4) XdrUnionBodyName() string { + switch u.Nt_timechanged { + case true: + return "Nt_time" + case false: + return "" + } + return "" +} +type XdrType_Newtime4 = *Newtime4 +func (v *Newtime4) XdrPointer() interface{} { return v } +func (Newtime4) XdrTypeName() string { return "Newtime4" } +func (v Newtime4) XdrValue() interface{} { return v } +func (v *Newtime4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Newtime4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_bool(&u.Nt_timechanged).XdrMarshal(x, x.Sprintf("%snt_timechanged", name)) + switch u.Nt_timechanged { + case true: + x.Marshal(x.Sprintf("%snt_time", name), XDR_Nfstime4(u.Nt_time())) + return + case false: + return + } + XdrPanic("invalid Nt_timechanged (%v) in Newtime4", u.Nt_timechanged) +} +func XDR_Newtime4(v *Newtime4) *Newtime4 { return v} +var _XdrTags_Newoffset4 = map[int32]bool{ + XdrToI32(true): true, + XdrToI32(false): true, +} +func (_ Newoffset4) XdrValidTags() map[int32]bool { + return _XdrTags_Newoffset4 +} +func (u *Newoffset4) No_offset() *Offset4 { + switch u.No_newoffset { + case true: + if v, ok := u.U.(*Offset4); ok { + return v + } else { + var zero Offset4 + u.U = &zero + return &zero + } + default: + XdrPanic("Newoffset4.No_offset accessed when No_newoffset == %v", u.No_newoffset) + return nil + } +} +func (u Newoffset4) XdrValid() bool { + switch u.No_newoffset { + case true,false: + return true + } + return false +} +func (u *Newoffset4) XdrUnionTag() XdrNum32 { + return XDR_bool(&u.No_newoffset) +} +func (u *Newoffset4) XdrUnionTagName() string { + return "No_newoffset" +} +func (u *Newoffset4) XdrUnionBody() XdrType { + switch u.No_newoffset { + case true: + return XDR_Offset4(u.No_offset()) + case false: + return nil + } + return nil +} +func (u *Newoffset4) XdrUnionBodyName() string { + switch u.No_newoffset { + case true: + return "No_offset" + case false: + return "" + } + return "" +} +type XdrType_Newoffset4 = *Newoffset4 +func (v *Newoffset4) XdrPointer() interface{} { return v } +func (Newoffset4) XdrTypeName() string { return "Newoffset4" } +func (v Newoffset4) XdrValue() interface{} { return v } +func (v *Newoffset4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Newoffset4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_bool(&u.No_newoffset).XdrMarshal(x, x.Sprintf("%sno_newoffset", name)) + switch u.No_newoffset { + case true: + x.Marshal(x.Sprintf("%sno_offset", name), XDR_Offset4(u.No_offset())) + return + case false: + return + } + XdrPanic("invalid No_newoffset (%v) in Newoffset4", u.No_newoffset) +} +func XDR_Newoffset4(v *Newoffset4) *Newoffset4 { return v} +type XdrType_LAYOUTCOMMIT4args = *LAYOUTCOMMIT4args +func (v *LAYOUTCOMMIT4args) XdrPointer() interface{} { return v } +func (LAYOUTCOMMIT4args) XdrTypeName() string { return "LAYOUTCOMMIT4args" } +func (v LAYOUTCOMMIT4args) XdrValue() interface{} { return v } +func (v *LAYOUTCOMMIT4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LAYOUTCOMMIT4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sloca_offset", name), XDR_Offset4(&v.Loca_offset)) + x.Marshal(x.Sprintf("%sloca_length", name), XDR_Length4(&v.Loca_length)) + x.Marshal(x.Sprintf("%sloca_reclaim", name), XDR_bool(&v.Loca_reclaim)) + x.Marshal(x.Sprintf("%sloca_stateid", name), XDR_Stateid4(&v.Loca_stateid)) + x.Marshal(x.Sprintf("%sloca_last_write_offset", name), XDR_Newoffset4(&v.Loca_last_write_offset)) + x.Marshal(x.Sprintf("%sloca_time_modify", name), XDR_Newtime4(&v.Loca_time_modify)) + x.Marshal(x.Sprintf("%sloca_layoutupdate", name), XDR_Layoutupdate4(&v.Loca_layoutupdate)) +} +func XDR_LAYOUTCOMMIT4args(v *LAYOUTCOMMIT4args) *LAYOUTCOMMIT4args { return v } +var _XdrTags_Newsize4 = map[int32]bool{ + XdrToI32(true): true, + XdrToI32(false): true, +} +func (_ Newsize4) XdrValidTags() map[int32]bool { + return _XdrTags_Newsize4 +} +func (u *Newsize4) Ns_size() *Length4 { + switch u.Ns_sizechanged { + case true: + if v, ok := u.U.(*Length4); ok { + return v + } else { + var zero Length4 + u.U = &zero + return &zero + } + default: + XdrPanic("Newsize4.Ns_size accessed when Ns_sizechanged == %v", u.Ns_sizechanged) + return nil + } +} +func (u Newsize4) XdrValid() bool { + switch u.Ns_sizechanged { + case true,false: + return true + } + return false +} +func (u *Newsize4) XdrUnionTag() XdrNum32 { + return XDR_bool(&u.Ns_sizechanged) +} +func (u *Newsize4) XdrUnionTagName() string { + return "Ns_sizechanged" +} +func (u *Newsize4) XdrUnionBody() XdrType { + switch u.Ns_sizechanged { + case true: + return XDR_Length4(u.Ns_size()) + case false: + return nil + } + return nil +} +func (u *Newsize4) XdrUnionBodyName() string { + switch u.Ns_sizechanged { + case true: + return "Ns_size" + case false: + return "" + } + return "" +} +type XdrType_Newsize4 = *Newsize4 +func (v *Newsize4) XdrPointer() interface{} { return v } +func (Newsize4) XdrTypeName() string { return "Newsize4" } +func (v Newsize4) XdrValue() interface{} { return v } +func (v *Newsize4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Newsize4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_bool(&u.Ns_sizechanged).XdrMarshal(x, x.Sprintf("%sns_sizechanged", name)) + switch u.Ns_sizechanged { + case true: + x.Marshal(x.Sprintf("%sns_size", name), XDR_Length4(u.Ns_size())) + return + case false: + return + } + XdrPanic("invalid Ns_sizechanged (%v) in Newsize4", u.Ns_sizechanged) +} +func XDR_Newsize4(v *Newsize4) *Newsize4 { return v} +type XdrType_LAYOUTCOMMIT4resok = *LAYOUTCOMMIT4resok +func (v *LAYOUTCOMMIT4resok) XdrPointer() interface{} { return v } +func (LAYOUTCOMMIT4resok) XdrTypeName() string { return "LAYOUTCOMMIT4resok" } +func (v LAYOUTCOMMIT4resok) XdrValue() interface{} { return v } +func (v *LAYOUTCOMMIT4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LAYOUTCOMMIT4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slocr_newsize", name), XDR_Newsize4(&v.Locr_newsize)) +} +func XDR_LAYOUTCOMMIT4resok(v *LAYOUTCOMMIT4resok) *LAYOUTCOMMIT4resok { return v } +func (u *LAYOUTCOMMIT4res) Locr_resok4() *LAYOUTCOMMIT4resok { + switch u.Locr_status { + case NFS4_OK: + if v, ok := u.U.(*LAYOUTCOMMIT4resok); ok { + return v + } else { + var zero LAYOUTCOMMIT4resok + u.U = &zero + return &zero + } + default: + XdrPanic("LAYOUTCOMMIT4res.Locr_resok4 accessed when Locr_status == %v", u.Locr_status) + return nil + } +} +func (u LAYOUTCOMMIT4res) XdrValid() bool { + return true +} +func (u *LAYOUTCOMMIT4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Locr_status) +} +func (u *LAYOUTCOMMIT4res) XdrUnionTagName() string { + return "Locr_status" +} +func (u *LAYOUTCOMMIT4res) XdrUnionBody() XdrType { + switch u.Locr_status { + case NFS4_OK: + return XDR_LAYOUTCOMMIT4resok(u.Locr_resok4()) + default: + return nil + } +} +func (u *LAYOUTCOMMIT4res) XdrUnionBodyName() string { + switch u.Locr_status { + case NFS4_OK: + return "Locr_resok4" + default: + return "" + } +} +type XdrType_LAYOUTCOMMIT4res = *LAYOUTCOMMIT4res +func (v *LAYOUTCOMMIT4res) XdrPointer() interface{} { return v } +func (LAYOUTCOMMIT4res) XdrTypeName() string { return "LAYOUTCOMMIT4res" } +func (v LAYOUTCOMMIT4res) XdrValue() interface{} { return v } +func (v *LAYOUTCOMMIT4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LAYOUTCOMMIT4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Locr_status).XdrMarshal(x, x.Sprintf("%slocr_status", name)) + switch u.Locr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%slocr_resok4", name), XDR_LAYOUTCOMMIT4resok(u.Locr_resok4())) + return + default: + return + } +} +func XDR_LAYOUTCOMMIT4res(v *LAYOUTCOMMIT4res) *LAYOUTCOMMIT4res { return v} +type XdrType_LAYOUTGET4args = *LAYOUTGET4args +func (v *LAYOUTGET4args) XdrPointer() interface{} { return v } +func (LAYOUTGET4args) XdrTypeName() string { return "LAYOUTGET4args" } +func (v LAYOUTGET4args) XdrValue() interface{} { return v } +func (v *LAYOUTGET4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LAYOUTGET4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sloga_signal_layout_avail", name), XDR_bool(&v.Loga_signal_layout_avail)) + x.Marshal(x.Sprintf("%sloga_layout_type", name), XDR_Layouttype4(&v.Loga_layout_type)) + x.Marshal(x.Sprintf("%sloga_iomode", name), XDR_Layoutiomode4(&v.Loga_iomode)) + x.Marshal(x.Sprintf("%sloga_offset", name), XDR_Offset4(&v.Loga_offset)) + x.Marshal(x.Sprintf("%sloga_length", name), XDR_Length4(&v.Loga_length)) + x.Marshal(x.Sprintf("%sloga_minlength", name), XDR_Length4(&v.Loga_minlength)) + x.Marshal(x.Sprintf("%sloga_stateid", name), XDR_Stateid4(&v.Loga_stateid)) + x.Marshal(x.Sprintf("%sloga_maxcount", name), XDR_Count4(&v.Loga_maxcount)) +} +func XDR_LAYOUTGET4args(v *LAYOUTGET4args) *LAYOUTGET4args { return v } +type _XdrVec_unbounded_Layout4 []Layout4 +func (_XdrVec_unbounded_Layout4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Layout4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Layout4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Layout4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Layout4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Layout4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Layout4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Layout4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Layout4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Layout4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Layout4) XdrTypeName() string { return "Layout4<>" } +func (v *_XdrVec_unbounded_Layout4) XdrPointer() interface{} { return (*[]Layout4)(v) } +func (v _XdrVec_unbounded_Layout4) XdrValue() interface{} { return ([]Layout4)(v) } +func (v *_XdrVec_unbounded_Layout4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_LAYOUTGET4resok = *LAYOUTGET4resok +func (v *LAYOUTGET4resok) XdrPointer() interface{} { return v } +func (LAYOUTGET4resok) XdrTypeName() string { return "LAYOUTGET4resok" } +func (v LAYOUTGET4resok) XdrValue() interface{} { return v } +func (v *LAYOUTGET4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LAYOUTGET4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slogr_return_on_close", name), XDR_bool(&v.Logr_return_on_close)) + x.Marshal(x.Sprintf("%slogr_stateid", name), XDR_Stateid4(&v.Logr_stateid)) + x.Marshal(x.Sprintf("%slogr_layout", name), (*_XdrVec_unbounded_Layout4)(&v.Logr_layout)) +} +func XDR_LAYOUTGET4resok(v *LAYOUTGET4resok) *LAYOUTGET4resok { return v } +func (u *LAYOUTGET4res) Logr_resok4() *LAYOUTGET4resok { + switch u.Logr_status { + case NFS4_OK: + if v, ok := u.U.(*LAYOUTGET4resok); ok { + return v + } else { + var zero LAYOUTGET4resok + u.U = &zero + return &zero + } + default: + XdrPanic("LAYOUTGET4res.Logr_resok4 accessed when Logr_status == %v", u.Logr_status) + return nil + } +} +func (u *LAYOUTGET4res) Logr_will_signal_layout_avail() *bool { + switch u.Logr_status { + case NFS4ERR_LAYOUTTRYLATER: + if v, ok := u.U.(*bool); ok { + return v + } else { + var zero bool + u.U = &zero + return &zero + } + default: + XdrPanic("LAYOUTGET4res.Logr_will_signal_layout_avail accessed when Logr_status == %v", u.Logr_status) + return nil + } +} +func (u LAYOUTGET4res) XdrValid() bool { + return true +} +func (u *LAYOUTGET4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Logr_status) +} +func (u *LAYOUTGET4res) XdrUnionTagName() string { + return "Logr_status" +} +func (u *LAYOUTGET4res) XdrUnionBody() XdrType { + switch u.Logr_status { + case NFS4_OK: + return XDR_LAYOUTGET4resok(u.Logr_resok4()) + case NFS4ERR_LAYOUTTRYLATER: + return XDR_bool(u.Logr_will_signal_layout_avail()) + default: + return nil + } +} +func (u *LAYOUTGET4res) XdrUnionBodyName() string { + switch u.Logr_status { + case NFS4_OK: + return "Logr_resok4" + case NFS4ERR_LAYOUTTRYLATER: + return "Logr_will_signal_layout_avail" + default: + return "" + } +} +type XdrType_LAYOUTGET4res = *LAYOUTGET4res +func (v *LAYOUTGET4res) XdrPointer() interface{} { return v } +func (LAYOUTGET4res) XdrTypeName() string { return "LAYOUTGET4res" } +func (v LAYOUTGET4res) XdrValue() interface{} { return v } +func (v *LAYOUTGET4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LAYOUTGET4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Logr_status).XdrMarshal(x, x.Sprintf("%slogr_status", name)) + switch u.Logr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%slogr_resok4", name), XDR_LAYOUTGET4resok(u.Logr_resok4())) + return + case NFS4ERR_LAYOUTTRYLATER: + x.Marshal(x.Sprintf("%slogr_will_signal_layout_avail", name), XDR_bool(u.Logr_will_signal_layout_avail())) + return + default: + return + } +} +func XDR_LAYOUTGET4res(v *LAYOUTGET4res) *LAYOUTGET4res { return v} +var _XdrNames_Layoutreturn_type4 = map[int32]string{ + int32(LAYOUTRETURN4_FILE): "LAYOUTRETURN4_FILE", + int32(LAYOUTRETURN4_FSID): "LAYOUTRETURN4_FSID", + int32(LAYOUTRETURN4_ALL): "LAYOUTRETURN4_ALL", +} +var _XdrValues_Layoutreturn_type4 = map[string]int32{ + "LAYOUTRETURN4_FILE": int32(LAYOUTRETURN4_FILE), + "LAYOUTRETURN4_FSID": int32(LAYOUTRETURN4_FSID), + "LAYOUTRETURN4_ALL": int32(LAYOUTRETURN4_ALL), +} +func (Layoutreturn_type4) XdrEnumNames() map[int32]string { + return _XdrNames_Layoutreturn_type4 +} +func (v Layoutreturn_type4) String() string { + if s, ok := _XdrNames_Layoutreturn_type4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Layoutreturn_type4#%d", v) +} +func (v *Layoutreturn_type4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Layoutreturn_type4[stok]; ok { + *v = Layoutreturn_type4(val) + return nil + } else if stok == "Layoutreturn_type4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Layoutreturn_type4.", stok)) + } +} +func (v Layoutreturn_type4) GetU32() uint32 { return uint32(v) } +func (v *Layoutreturn_type4) SetU32(n uint32) { *v = Layoutreturn_type4(n) } +func (v *Layoutreturn_type4) XdrPointer() interface{} { return v } +func (Layoutreturn_type4) XdrTypeName() string { return "Layoutreturn_type4" } +func (v Layoutreturn_type4) XdrValue() interface{} { return v } +func (v *Layoutreturn_type4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Layoutreturn_type4 = *Layoutreturn_type4 +func XDR_Layoutreturn_type4(v *Layoutreturn_type4) *Layoutreturn_type4 { return v } +func (v *Layoutreturn_type4) XdrInitialize() { + switch Layoutreturn_type4(0) { + case LAYOUTRETURN4_FILE, LAYOUTRETURN4_FSID, LAYOUTRETURN4_ALL: + default: + if *v == Layoutreturn_type4(0) { *v = LAYOUTRETURN4_FILE } + } +} +type XdrType_Layoutreturn_file4 = *Layoutreturn_file4 +func (v *Layoutreturn_file4) XdrPointer() interface{} { return v } +func (Layoutreturn_file4) XdrTypeName() string { return "Layoutreturn_file4" } +func (v Layoutreturn_file4) XdrValue() interface{} { return v } +func (v *Layoutreturn_file4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Layoutreturn_file4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slrf_offset", name), XDR_Offset4(&v.Lrf_offset)) + x.Marshal(x.Sprintf("%slrf_length", name), XDR_Length4(&v.Lrf_length)) + x.Marshal(x.Sprintf("%slrf_stateid", name), XDR_Stateid4(&v.Lrf_stateid)) + x.Marshal(x.Sprintf("%slrf_body", name), XdrVecOpaque{&v.Lrf_body, 0xffffffff}) +} +func XDR_Layoutreturn_file4(v *Layoutreturn_file4) *Layoutreturn_file4 { return v } +func (u *Layoutreturn4) Lr_layout() *Layoutreturn_file4 { + switch u.Lr_returntype { + case LAYOUTRETURN4_FILE: + if v, ok := u.U.(*Layoutreturn_file4); ok { + return v + } else { + var zero Layoutreturn_file4 + u.U = &zero + return &zero + } + default: + XdrPanic("Layoutreturn4.Lr_layout accessed when Lr_returntype == %v", u.Lr_returntype) + return nil + } +} +func (u Layoutreturn4) XdrValid() bool { + return true +} +func (u *Layoutreturn4) XdrUnionTag() XdrNum32 { + return XDR_Layoutreturn_type4(&u.Lr_returntype) +} +func (u *Layoutreturn4) XdrUnionTagName() string { + return "Lr_returntype" +} +func (u *Layoutreturn4) XdrUnionBody() XdrType { + switch u.Lr_returntype { + case LAYOUTRETURN4_FILE: + return XDR_Layoutreturn_file4(u.Lr_layout()) + default: + return nil + } +} +func (u *Layoutreturn4) XdrUnionBodyName() string { + switch u.Lr_returntype { + case LAYOUTRETURN4_FILE: + return "Lr_layout" + default: + return "" + } +} +type XdrType_Layoutreturn4 = *Layoutreturn4 +func (v *Layoutreturn4) XdrPointer() interface{} { return v } +func (Layoutreturn4) XdrTypeName() string { return "Layoutreturn4" } +func (v Layoutreturn4) XdrValue() interface{} { return v } +func (v *Layoutreturn4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Layoutreturn4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Layoutreturn_type4(&u.Lr_returntype).XdrMarshal(x, x.Sprintf("%slr_returntype", name)) + switch u.Lr_returntype { + case LAYOUTRETURN4_FILE: + x.Marshal(x.Sprintf("%slr_layout", name), XDR_Layoutreturn_file4(u.Lr_layout())) + return + default: + return + } +} +func XDR_Layoutreturn4(v *Layoutreturn4) *Layoutreturn4 { return v} +type XdrType_LAYOUTRETURN4args = *LAYOUTRETURN4args +func (v *LAYOUTRETURN4args) XdrPointer() interface{} { return v } +func (LAYOUTRETURN4args) XdrTypeName() string { return "LAYOUTRETURN4args" } +func (v LAYOUTRETURN4args) XdrValue() interface{} { return v } +func (v *LAYOUTRETURN4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *LAYOUTRETURN4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slora_reclaim", name), XDR_bool(&v.Lora_reclaim)) + x.Marshal(x.Sprintf("%slora_layout_type", name), XDR_Layouttype4(&v.Lora_layout_type)) + x.Marshal(x.Sprintf("%slora_iomode", name), XDR_Layoutiomode4(&v.Lora_iomode)) + x.Marshal(x.Sprintf("%slora_layoutreturn", name), XDR_Layoutreturn4(&v.Lora_layoutreturn)) +} +func XDR_LAYOUTRETURN4args(v *LAYOUTRETURN4args) *LAYOUTRETURN4args { return v } +var _XdrTags_Layoutreturn_stateid = map[int32]bool{ + XdrToI32(true): true, + XdrToI32(false): true, +} +func (_ Layoutreturn_stateid) XdrValidTags() map[int32]bool { + return _XdrTags_Layoutreturn_stateid +} +func (u *Layoutreturn_stateid) Lrs_stateid() *Stateid4 { + switch u.Lrs_present { + case true: + if v, ok := u.U.(*Stateid4); ok { + return v + } else { + var zero Stateid4 + u.U = &zero + return &zero + } + default: + XdrPanic("Layoutreturn_stateid.Lrs_stateid accessed when Lrs_present == %v", u.Lrs_present) + return nil + } +} +func (u Layoutreturn_stateid) XdrValid() bool { + switch u.Lrs_present { + case true,false: + return true + } + return false +} +func (u *Layoutreturn_stateid) XdrUnionTag() XdrNum32 { + return XDR_bool(&u.Lrs_present) +} +func (u *Layoutreturn_stateid) XdrUnionTagName() string { + return "Lrs_present" +} +func (u *Layoutreturn_stateid) XdrUnionBody() XdrType { + switch u.Lrs_present { + case true: + return XDR_Stateid4(u.Lrs_stateid()) + case false: + return nil + } + return nil +} +func (u *Layoutreturn_stateid) XdrUnionBodyName() string { + switch u.Lrs_present { + case true: + return "Lrs_stateid" + case false: + return "" + } + return "" +} +type XdrType_Layoutreturn_stateid = *Layoutreturn_stateid +func (v *Layoutreturn_stateid) XdrPointer() interface{} { return v } +func (Layoutreturn_stateid) XdrTypeName() string { return "Layoutreturn_stateid" } +func (v Layoutreturn_stateid) XdrValue() interface{} { return v } +func (v *Layoutreturn_stateid) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Layoutreturn_stateid) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_bool(&u.Lrs_present).XdrMarshal(x, x.Sprintf("%slrs_present", name)) + switch u.Lrs_present { + case true: + x.Marshal(x.Sprintf("%slrs_stateid", name), XDR_Stateid4(u.Lrs_stateid())) + return + case false: + return + } + XdrPanic("invalid Lrs_present (%v) in Layoutreturn_stateid", u.Lrs_present) +} +func XDR_Layoutreturn_stateid(v *Layoutreturn_stateid) *Layoutreturn_stateid { return v} +func (u *LAYOUTRETURN4res) Lorr_stateid() *Layoutreturn_stateid { + switch u.Lorr_status { + case NFS4_OK: + if v, ok := u.U.(*Layoutreturn_stateid); ok { + return v + } else { + var zero Layoutreturn_stateid + u.U = &zero + return &zero + } + default: + XdrPanic("LAYOUTRETURN4res.Lorr_stateid accessed when Lorr_status == %v", u.Lorr_status) + return nil + } +} +func (u LAYOUTRETURN4res) XdrValid() bool { + return true +} +func (u *LAYOUTRETURN4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Lorr_status) +} +func (u *LAYOUTRETURN4res) XdrUnionTagName() string { + return "Lorr_status" +} +func (u *LAYOUTRETURN4res) XdrUnionBody() XdrType { + switch u.Lorr_status { + case NFS4_OK: + return XDR_Layoutreturn_stateid(u.Lorr_stateid()) + default: + return nil + } +} +func (u *LAYOUTRETURN4res) XdrUnionBodyName() string { + switch u.Lorr_status { + case NFS4_OK: + return "Lorr_stateid" + default: + return "" + } +} +type XdrType_LAYOUTRETURN4res = *LAYOUTRETURN4res +func (v *LAYOUTRETURN4res) XdrPointer() interface{} { return v } +func (LAYOUTRETURN4res) XdrTypeName() string { return "LAYOUTRETURN4res" } +func (v LAYOUTRETURN4res) XdrValue() interface{} { return v } +func (v *LAYOUTRETURN4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *LAYOUTRETURN4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Lorr_status).XdrMarshal(x, x.Sprintf("%slorr_status", name)) + switch u.Lorr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%slorr_stateid", name), XDR_Layoutreturn_stateid(u.Lorr_stateid())) + return + default: + return + } +} +func XDR_LAYOUTRETURN4res(v *LAYOUTRETURN4res) *LAYOUTRETURN4res { return v} +var _XdrNames_Secinfo_style4 = map[int32]string{ + int32(SECINFO_STYLE4_CURRENT_FH): "SECINFO_STYLE4_CURRENT_FH", + int32(SECINFO_STYLE4_PARENT): "SECINFO_STYLE4_PARENT", +} +var _XdrValues_Secinfo_style4 = map[string]int32{ + "SECINFO_STYLE4_CURRENT_FH": int32(SECINFO_STYLE4_CURRENT_FH), + "SECINFO_STYLE4_PARENT": int32(SECINFO_STYLE4_PARENT), +} +func (Secinfo_style4) XdrEnumNames() map[int32]string { + return _XdrNames_Secinfo_style4 +} +func (v Secinfo_style4) String() string { + if s, ok := _XdrNames_Secinfo_style4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Secinfo_style4#%d", v) +} +func (v *Secinfo_style4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Secinfo_style4[stok]; ok { + *v = Secinfo_style4(val) + return nil + } else if stok == "Secinfo_style4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Secinfo_style4.", stok)) + } +} +func (v Secinfo_style4) GetU32() uint32 { return uint32(v) } +func (v *Secinfo_style4) SetU32(n uint32) { *v = Secinfo_style4(n) } +func (v *Secinfo_style4) XdrPointer() interface{} { return v } +func (Secinfo_style4) XdrTypeName() string { return "Secinfo_style4" } +func (v Secinfo_style4) XdrValue() interface{} { return v } +func (v *Secinfo_style4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Secinfo_style4 = *Secinfo_style4 +func XDR_Secinfo_style4(v *Secinfo_style4) *Secinfo_style4 { return v } +type XdrType_SECINFO_NO_NAME4args struct { + XdrType_Secinfo_style4 +} +func XDR_SECINFO_NO_NAME4args(v *SECINFO_NO_NAME4args) *XdrType_SECINFO_NO_NAME4args { + return &XdrType_SECINFO_NO_NAME4args{XDR_Secinfo_style4(v)} +} +func (XdrType_SECINFO_NO_NAME4args) XdrTypeName() string { return "SECINFO_NO_NAME4args" } +func (v XdrType_SECINFO_NO_NAME4args) XdrUnwrap() XdrType { return v.XdrType_Secinfo_style4 } +type XdrType_SECINFO_NO_NAME4res struct { + XdrType_SECINFO4res +} +func XDR_SECINFO_NO_NAME4res(v *SECINFO_NO_NAME4res) *XdrType_SECINFO_NO_NAME4res { + return &XdrType_SECINFO_NO_NAME4res{XDR_SECINFO4res(v)} +} +func (XdrType_SECINFO_NO_NAME4res) XdrTypeName() string { return "SECINFO_NO_NAME4res" } +func (v XdrType_SECINFO_NO_NAME4res) XdrUnwrap() XdrType { return v.XdrType_SECINFO4res } +type XdrType_SEQUENCE4args = *SEQUENCE4args +func (v *SEQUENCE4args) XdrPointer() interface{} { return v } +func (SEQUENCE4args) XdrTypeName() string { return "SEQUENCE4args" } +func (v SEQUENCE4args) XdrValue() interface{} { return v } +func (v *SEQUENCE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SEQUENCE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%ssa_sessionid", name), XDR_Sessionid4(&v.Sa_sessionid)) + x.Marshal(x.Sprintf("%ssa_sequenceid", name), XDR_Sequenceid4(&v.Sa_sequenceid)) + x.Marshal(x.Sprintf("%ssa_slotid", name), XDR_Slotid4(&v.Sa_slotid)) + x.Marshal(x.Sprintf("%ssa_highest_slotid", name), XDR_Slotid4(&v.Sa_highest_slotid)) + x.Marshal(x.Sprintf("%ssa_cachethis", name), XDR_bool(&v.Sa_cachethis)) +} +func XDR_SEQUENCE4args(v *SEQUENCE4args) *SEQUENCE4args { return v } +type XdrType_SEQUENCE4resok = *SEQUENCE4resok +func (v *SEQUENCE4resok) XdrPointer() interface{} { return v } +func (SEQUENCE4resok) XdrTypeName() string { return "SEQUENCE4resok" } +func (v SEQUENCE4resok) XdrValue() interface{} { return v } +func (v *SEQUENCE4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SEQUENCE4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%ssr_sessionid", name), XDR_Sessionid4(&v.Sr_sessionid)) + x.Marshal(x.Sprintf("%ssr_sequenceid", name), XDR_Sequenceid4(&v.Sr_sequenceid)) + x.Marshal(x.Sprintf("%ssr_slotid", name), XDR_Slotid4(&v.Sr_slotid)) + x.Marshal(x.Sprintf("%ssr_highest_slotid", name), XDR_Slotid4(&v.Sr_highest_slotid)) + x.Marshal(x.Sprintf("%ssr_target_highest_slotid", name), XDR_Slotid4(&v.Sr_target_highest_slotid)) + x.Marshal(x.Sprintf("%ssr_status_flags", name), XDR_Uint32_t(&v.Sr_status_flags)) +} +func XDR_SEQUENCE4resok(v *SEQUENCE4resok) *SEQUENCE4resok { return v } +func (u *SEQUENCE4res) Sr_resok4() *SEQUENCE4resok { + switch u.Sr_status { + case NFS4_OK: + if v, ok := u.U.(*SEQUENCE4resok); ok { + return v + } else { + var zero SEQUENCE4resok + u.U = &zero + return &zero + } + default: + XdrPanic("SEQUENCE4res.Sr_resok4 accessed when Sr_status == %v", u.Sr_status) + return nil + } +} +func (u SEQUENCE4res) XdrValid() bool { + return true +} +func (u *SEQUENCE4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Sr_status) +} +func (u *SEQUENCE4res) XdrUnionTagName() string { + return "Sr_status" +} +func (u *SEQUENCE4res) XdrUnionBody() XdrType { + switch u.Sr_status { + case NFS4_OK: + return XDR_SEQUENCE4resok(u.Sr_resok4()) + default: + return nil + } +} +func (u *SEQUENCE4res) XdrUnionBodyName() string { + switch u.Sr_status { + case NFS4_OK: + return "Sr_resok4" + default: + return "" + } +} +type XdrType_SEQUENCE4res = *SEQUENCE4res +func (v *SEQUENCE4res) XdrPointer() interface{} { return v } +func (SEQUENCE4res) XdrTypeName() string { return "SEQUENCE4res" } +func (v SEQUENCE4res) XdrValue() interface{} { return v } +func (v *SEQUENCE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *SEQUENCE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Sr_status).XdrMarshal(x, x.Sprintf("%ssr_status", name)) + switch u.Sr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%ssr_resok4", name), XDR_SEQUENCE4resok(u.Sr_resok4())) + return + default: + return + } +} +func XDR_SEQUENCE4res(v *SEQUENCE4res) *SEQUENCE4res { return v} +type XdrType_Ssa_digest_input4 = *Ssa_digest_input4 +func (v *Ssa_digest_input4) XdrPointer() interface{} { return v } +func (Ssa_digest_input4) XdrTypeName() string { return "Ssa_digest_input4" } +func (v Ssa_digest_input4) XdrValue() interface{} { return v } +func (v *Ssa_digest_input4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Ssa_digest_input4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%ssdi_seqargs", name), XDR_SEQUENCE4args(&v.Sdi_seqargs)) +} +func XDR_Ssa_digest_input4(v *Ssa_digest_input4) *Ssa_digest_input4 { return v } +type XdrType_SET_SSV4args = *SET_SSV4args +func (v *SET_SSV4args) XdrPointer() interface{} { return v } +func (SET_SSV4args) XdrTypeName() string { return "SET_SSV4args" } +func (v SET_SSV4args) XdrValue() interface{} { return v } +func (v *SET_SSV4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SET_SSV4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sssa_ssv", name), XdrVecOpaque{&v.Ssa_ssv, 0xffffffff}) + x.Marshal(x.Sprintf("%sssa_digest", name), XdrVecOpaque{&v.Ssa_digest, 0xffffffff}) +} +func XDR_SET_SSV4args(v *SET_SSV4args) *SET_SSV4args { return v } +type XdrType_Ssr_digest_input4 = *Ssr_digest_input4 +func (v *Ssr_digest_input4) XdrPointer() interface{} { return v } +func (Ssr_digest_input4) XdrTypeName() string { return "Ssr_digest_input4" } +func (v Ssr_digest_input4) XdrValue() interface{} { return v } +func (v *Ssr_digest_input4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Ssr_digest_input4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%ssdi_seqres", name), XDR_SEQUENCE4res(&v.Sdi_seqres)) +} +func XDR_Ssr_digest_input4(v *Ssr_digest_input4) *Ssr_digest_input4 { return v } +type XdrType_SET_SSV4resok = *SET_SSV4resok +func (v *SET_SSV4resok) XdrPointer() interface{} { return v } +func (SET_SSV4resok) XdrTypeName() string { return "SET_SSV4resok" } +func (v SET_SSV4resok) XdrValue() interface{} { return v } +func (v *SET_SSV4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *SET_SSV4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sssr_digest", name), XdrVecOpaque{&v.Ssr_digest, 0xffffffff}) +} +func XDR_SET_SSV4resok(v *SET_SSV4resok) *SET_SSV4resok { return v } +func (u *SET_SSV4res) Ssr_resok4() *SET_SSV4resok { + switch u.Ssr_status { + case NFS4_OK: + if v, ok := u.U.(*SET_SSV4resok); ok { + return v + } else { + var zero SET_SSV4resok + u.U = &zero + return &zero + } + default: + XdrPanic("SET_SSV4res.Ssr_resok4 accessed when Ssr_status == %v", u.Ssr_status) + return nil + } +} +func (u SET_SSV4res) XdrValid() bool { + return true +} +func (u *SET_SSV4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Ssr_status) +} +func (u *SET_SSV4res) XdrUnionTagName() string { + return "Ssr_status" +} +func (u *SET_SSV4res) XdrUnionBody() XdrType { + switch u.Ssr_status { + case NFS4_OK: + return XDR_SET_SSV4resok(u.Ssr_resok4()) + default: + return nil + } +} +func (u *SET_SSV4res) XdrUnionBodyName() string { + switch u.Ssr_status { + case NFS4_OK: + return "Ssr_resok4" + default: + return "" + } +} +type XdrType_SET_SSV4res = *SET_SSV4res +func (v *SET_SSV4res) XdrPointer() interface{} { return v } +func (SET_SSV4res) XdrTypeName() string { return "SET_SSV4res" } +func (v SET_SSV4res) XdrValue() interface{} { return v } +func (v *SET_SSV4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *SET_SSV4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Ssr_status).XdrMarshal(x, x.Sprintf("%sssr_status", name)) + switch u.Ssr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sssr_resok4", name), XDR_SET_SSV4resok(u.Ssr_resok4())) + return + default: + return + } +} +func XDR_SET_SSV4res(v *SET_SSV4res) *SET_SSV4res { return v} +type _XdrVec_unbounded_Stateid4 []Stateid4 +func (_XdrVec_unbounded_Stateid4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Stateid4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Stateid4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Stateid4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Stateid4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Stateid4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Stateid4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Stateid4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Stateid4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Stateid4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Stateid4) XdrTypeName() string { return "Stateid4<>" } +func (v *_XdrVec_unbounded_Stateid4) XdrPointer() interface{} { return (*[]Stateid4)(v) } +func (v _XdrVec_unbounded_Stateid4) XdrValue() interface{} { return ([]Stateid4)(v) } +func (v *_XdrVec_unbounded_Stateid4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_TEST_STATEID4args = *TEST_STATEID4args +func (v *TEST_STATEID4args) XdrPointer() interface{} { return v } +func (TEST_STATEID4args) XdrTypeName() string { return "TEST_STATEID4args" } +func (v TEST_STATEID4args) XdrValue() interface{} { return v } +func (v *TEST_STATEID4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *TEST_STATEID4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sts_stateids", name), (*_XdrVec_unbounded_Stateid4)(&v.Ts_stateids)) +} +func XDR_TEST_STATEID4args(v *TEST_STATEID4args) *TEST_STATEID4args { return v } +type _XdrVec_unbounded_Nfsstat4 []Nfsstat4 +func (_XdrVec_unbounded_Nfsstat4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Nfsstat4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Nfsstat4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Nfsstat4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Nfsstat4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Nfsstat4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Nfsstat4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Nfsstat4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Nfsstat4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Nfsstat4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Nfsstat4) XdrTypeName() string { return "Nfsstat4<>" } +func (v *_XdrVec_unbounded_Nfsstat4) XdrPointer() interface{} { return (*[]Nfsstat4)(v) } +func (v _XdrVec_unbounded_Nfsstat4) XdrValue() interface{} { return ([]Nfsstat4)(v) } +func (v *_XdrVec_unbounded_Nfsstat4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_TEST_STATEID4resok = *TEST_STATEID4resok +func (v *TEST_STATEID4resok) XdrPointer() interface{} { return v } +func (TEST_STATEID4resok) XdrTypeName() string { return "TEST_STATEID4resok" } +func (v TEST_STATEID4resok) XdrValue() interface{} { return v } +func (v *TEST_STATEID4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *TEST_STATEID4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%stsr_status_codes", name), (*_XdrVec_unbounded_Nfsstat4)(&v.Tsr_status_codes)) +} +func XDR_TEST_STATEID4resok(v *TEST_STATEID4resok) *TEST_STATEID4resok { return v } +func (u *TEST_STATEID4res) Tsr_resok4() *TEST_STATEID4resok { + switch u.Tsr_status { + case NFS4_OK: + if v, ok := u.U.(*TEST_STATEID4resok); ok { + return v + } else { + var zero TEST_STATEID4resok + u.U = &zero + return &zero + } + default: + XdrPanic("TEST_STATEID4res.Tsr_resok4 accessed when Tsr_status == %v", u.Tsr_status) + return nil + } +} +func (u TEST_STATEID4res) XdrValid() bool { + return true +} +func (u *TEST_STATEID4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Tsr_status) +} +func (u *TEST_STATEID4res) XdrUnionTagName() string { + return "Tsr_status" +} +func (u *TEST_STATEID4res) XdrUnionBody() XdrType { + switch u.Tsr_status { + case NFS4_OK: + return XDR_TEST_STATEID4resok(u.Tsr_resok4()) + default: + return nil + } +} +func (u *TEST_STATEID4res) XdrUnionBodyName() string { + switch u.Tsr_status { + case NFS4_OK: + return "Tsr_resok4" + default: + return "" + } +} +type XdrType_TEST_STATEID4res = *TEST_STATEID4res +func (v *TEST_STATEID4res) XdrPointer() interface{} { return v } +func (TEST_STATEID4res) XdrTypeName() string { return "TEST_STATEID4res" } +func (v TEST_STATEID4res) XdrValue() interface{} { return v } +func (v *TEST_STATEID4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *TEST_STATEID4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Tsr_status).XdrMarshal(x, x.Sprintf("%stsr_status", name)) + switch u.Tsr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%stsr_resok4", name), XDR_TEST_STATEID4resok(u.Tsr_resok4())) + return + default: + return + } +} +func XDR_TEST_STATEID4res(v *TEST_STATEID4res) *TEST_STATEID4res { return v} +var _XdrTags_Deleg_claim4 = map[int32]bool{ + XdrToI32(CLAIM_FH): true, + XdrToI32(CLAIM_DELEG_PREV_FH): true, + XdrToI32(CLAIM_PREVIOUS): true, +} +func (_ Deleg_claim4) XdrValidTags() map[int32]bool { + return _XdrTags_Deleg_claim4 +} +func (u *Deleg_claim4) Dc_delegate_type() *Open_delegation_type4 { + switch u.Dc_claim { + case CLAIM_PREVIOUS: + if v, ok := u.U.(*Open_delegation_type4); ok { + return v + } else { + var zero Open_delegation_type4 + u.U = &zero + return &zero + } + default: + XdrPanic("Deleg_claim4.Dc_delegate_type accessed when Dc_claim == %v", u.Dc_claim) + return nil + } +} +func (u Deleg_claim4) XdrValid() bool { + switch u.Dc_claim { + case CLAIM_FH,CLAIM_DELEG_PREV_FH,CLAIM_PREVIOUS: + return true + } + return false +} +func (u *Deleg_claim4) XdrUnionTag() XdrNum32 { + return XDR_Open_claim_type4(&u.Dc_claim) +} +func (u *Deleg_claim4) XdrUnionTagName() string { + return "Dc_claim" +} +func (u *Deleg_claim4) XdrUnionBody() XdrType { + switch u.Dc_claim { + case CLAIM_FH: + return nil + case CLAIM_DELEG_PREV_FH: + return nil + case CLAIM_PREVIOUS: + return XDR_Open_delegation_type4(u.Dc_delegate_type()) + } + return nil +} +func (u *Deleg_claim4) XdrUnionBodyName() string { + switch u.Dc_claim { + case CLAIM_FH: + return "" + case CLAIM_DELEG_PREV_FH: + return "" + case CLAIM_PREVIOUS: + return "Dc_delegate_type" + } + return "" +} +type XdrType_Deleg_claim4 = *Deleg_claim4 +func (v *Deleg_claim4) XdrPointer() interface{} { return v } +func (Deleg_claim4) XdrTypeName() string { return "Deleg_claim4" } +func (v Deleg_claim4) XdrValue() interface{} { return v } +func (v *Deleg_claim4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Deleg_claim4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Open_claim_type4(&u.Dc_claim).XdrMarshal(x, x.Sprintf("%sdc_claim", name)) + switch u.Dc_claim { + case CLAIM_FH: + return + case CLAIM_DELEG_PREV_FH: + return + case CLAIM_PREVIOUS: + x.Marshal(x.Sprintf("%sdc_delegate_type", name), XDR_Open_delegation_type4(u.Dc_delegate_type())) + return + } + XdrPanic("invalid Dc_claim (%v) in Deleg_claim4", u.Dc_claim) +} +func (v *Deleg_claim4) XdrInitialize() { + var zero Open_claim_type4 + switch zero { + case CLAIM_FH, CLAIM_DELEG_PREV_FH, CLAIM_PREVIOUS: + default: + if v.Dc_claim == zero { v.Dc_claim = CLAIM_FH } + } +} +func XDR_Deleg_claim4(v *Deleg_claim4) *Deleg_claim4 { return v} +type XdrType_WANT_DELEGATION4args = *WANT_DELEGATION4args +func (v *WANT_DELEGATION4args) XdrPointer() interface{} { return v } +func (WANT_DELEGATION4args) XdrTypeName() string { return "WANT_DELEGATION4args" } +func (v WANT_DELEGATION4args) XdrValue() interface{} { return v } +func (v *WANT_DELEGATION4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *WANT_DELEGATION4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%swda_want", name), XDR_Uint32_t(&v.Wda_want)) + x.Marshal(x.Sprintf("%swda_claim", name), XDR_Deleg_claim4(&v.Wda_claim)) +} +func XDR_WANT_DELEGATION4args(v *WANT_DELEGATION4args) *WANT_DELEGATION4args { return v } +func (u *WANT_DELEGATION4res) Wdr_resok4() *Open_delegation4 { + switch u.Wdr_status { + case NFS4_OK: + if v, ok := u.U.(*Open_delegation4); ok { + return v + } else { + var zero Open_delegation4 + u.U = &zero + return &zero + } + default: + XdrPanic("WANT_DELEGATION4res.Wdr_resok4 accessed when Wdr_status == %v", u.Wdr_status) + return nil + } +} +func (u WANT_DELEGATION4res) XdrValid() bool { + return true +} +func (u *WANT_DELEGATION4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Wdr_status) +} +func (u *WANT_DELEGATION4res) XdrUnionTagName() string { + return "Wdr_status" +} +func (u *WANT_DELEGATION4res) XdrUnionBody() XdrType { + switch u.Wdr_status { + case NFS4_OK: + return XDR_Open_delegation4(u.Wdr_resok4()) + default: + return nil + } +} +func (u *WANT_DELEGATION4res) XdrUnionBodyName() string { + switch u.Wdr_status { + case NFS4_OK: + return "Wdr_resok4" + default: + return "" + } +} +type XdrType_WANT_DELEGATION4res = *WANT_DELEGATION4res +func (v *WANT_DELEGATION4res) XdrPointer() interface{} { return v } +func (WANT_DELEGATION4res) XdrTypeName() string { return "WANT_DELEGATION4res" } +func (v WANT_DELEGATION4res) XdrValue() interface{} { return v } +func (v *WANT_DELEGATION4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *WANT_DELEGATION4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Wdr_status).XdrMarshal(x, x.Sprintf("%swdr_status", name)) + switch u.Wdr_status { + case NFS4_OK: + x.Marshal(x.Sprintf("%swdr_resok4", name), XDR_Open_delegation4(u.Wdr_resok4())) + return + default: + return + } +} +func XDR_WANT_DELEGATION4res(v *WANT_DELEGATION4res) *WANT_DELEGATION4res { return v} +type XdrType_DESTROY_CLIENTID4args = *DESTROY_CLIENTID4args +func (v *DESTROY_CLIENTID4args) XdrPointer() interface{} { return v } +func (DESTROY_CLIENTID4args) XdrTypeName() string { return "DESTROY_CLIENTID4args" } +func (v DESTROY_CLIENTID4args) XdrValue() interface{} { return v } +func (v *DESTROY_CLIENTID4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DESTROY_CLIENTID4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sdca_clientid", name), XDR_Clientid4(&v.Dca_clientid)) +} +func XDR_DESTROY_CLIENTID4args(v *DESTROY_CLIENTID4args) *DESTROY_CLIENTID4args { return v } +type XdrType_DESTROY_CLIENTID4res = *DESTROY_CLIENTID4res +func (v *DESTROY_CLIENTID4res) XdrPointer() interface{} { return v } +func (DESTROY_CLIENTID4res) XdrTypeName() string { return "DESTROY_CLIENTID4res" } +func (v DESTROY_CLIENTID4res) XdrValue() interface{} { return v } +func (v *DESTROY_CLIENTID4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *DESTROY_CLIENTID4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sdcr_status", name), XDR_Nfsstat4(&v.Dcr_status)) +} +func XDR_DESTROY_CLIENTID4res(v *DESTROY_CLIENTID4res) *DESTROY_CLIENTID4res { return v } +type XdrType_RECLAIM_COMPLETE4args = *RECLAIM_COMPLETE4args +func (v *RECLAIM_COMPLETE4args) XdrPointer() interface{} { return v } +func (RECLAIM_COMPLETE4args) XdrTypeName() string { return "RECLAIM_COMPLETE4args" } +func (v RECLAIM_COMPLETE4args) XdrValue() interface{} { return v } +func (v *RECLAIM_COMPLETE4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RECLAIM_COMPLETE4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%srca_one_fs", name), XDR_bool(&v.Rca_one_fs)) +} +func XDR_RECLAIM_COMPLETE4args(v *RECLAIM_COMPLETE4args) *RECLAIM_COMPLETE4args { return v } +type XdrType_RECLAIM_COMPLETE4res = *RECLAIM_COMPLETE4res +func (v *RECLAIM_COMPLETE4res) XdrPointer() interface{} { return v } +func (RECLAIM_COMPLETE4res) XdrTypeName() string { return "RECLAIM_COMPLETE4res" } +func (v RECLAIM_COMPLETE4res) XdrValue() interface{} { return v } +func (v *RECLAIM_COMPLETE4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *RECLAIM_COMPLETE4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%srcr_status", name), XDR_Nfsstat4(&v.Rcr_status)) +} +func XDR_RECLAIM_COMPLETE4res(v *RECLAIM_COMPLETE4res) *RECLAIM_COMPLETE4res { return v } +type XdrType_ILLEGAL4res = *ILLEGAL4res +func (v *ILLEGAL4res) XdrPointer() interface{} { return v } +func (ILLEGAL4res) XdrTypeName() string { return "ILLEGAL4res" } +func (v ILLEGAL4res) XdrValue() interface{} { return v } +func (v *ILLEGAL4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *ILLEGAL4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_ILLEGAL4res(v *ILLEGAL4res) *ILLEGAL4res { return v } +var _XdrNames_Nfs_opnum4 = map[int32]string{ + int32(OP_ACCESS): "OP_ACCESS", + int32(OP_CLOSE): "OP_CLOSE", + int32(OP_COMMIT): "OP_COMMIT", + int32(OP_CREATE): "OP_CREATE", + int32(OP_DELEGPURGE): "OP_DELEGPURGE", + int32(OP_DELEGRETURN): "OP_DELEGRETURN", + int32(OP_GETATTR): "OP_GETATTR", + int32(OP_GETFH): "OP_GETFH", + int32(OP_LINK): "OP_LINK", + int32(OP_LOCK): "OP_LOCK", + int32(OP_LOCKT): "OP_LOCKT", + int32(OP_LOCKU): "OP_LOCKU", + int32(OP_LOOKUP): "OP_LOOKUP", + int32(OP_LOOKUPP): "OP_LOOKUPP", + int32(OP_NVERIFY): "OP_NVERIFY", + int32(OP_OPEN): "OP_OPEN", + int32(OP_OPENATTR): "OP_OPENATTR", + int32(OP_OPEN_CONFIRM): "OP_OPEN_CONFIRM", + int32(OP_OPEN_DOWNGRADE): "OP_OPEN_DOWNGRADE", + int32(OP_PUTFH): "OP_PUTFH", + int32(OP_PUTPUBFH): "OP_PUTPUBFH", + int32(OP_PUTROOTFH): "OP_PUTROOTFH", + int32(OP_READ): "OP_READ", + int32(OP_READDIR): "OP_READDIR", + int32(OP_READLINK): "OP_READLINK", + int32(OP_REMOVE): "OP_REMOVE", + int32(OP_RENAME): "OP_RENAME", + int32(OP_RENEW): "OP_RENEW", + int32(OP_RESTOREFH): "OP_RESTOREFH", + int32(OP_SAVEFH): "OP_SAVEFH", + int32(OP_SECINFO): "OP_SECINFO", + int32(OP_SETATTR): "OP_SETATTR", + int32(OP_SETCLIENTID): "OP_SETCLIENTID", + int32(OP_SETCLIENTID_CONFIRM): "OP_SETCLIENTID_CONFIRM", + int32(OP_VERIFY): "OP_VERIFY", + int32(OP_WRITE): "OP_WRITE", + int32(OP_RELEASE_LOCKOWNER): "OP_RELEASE_LOCKOWNER", + int32(OP_CREATE_SESSION): "OP_CREATE_SESSION", + int32(OP_DESTROY_SESSION): "OP_DESTROY_SESSION", + int32(OP_FREE_STATEID): "OP_FREE_STATEID", + int32(OP_GET_DIR_DELEGATION): "OP_GET_DIR_DELEGATION", + int32(OP_GETDEVICEINFO): "OP_GETDEVICEINFO", + int32(OP_GETDEVICELIST): "OP_GETDEVICELIST", + int32(OP_LAYOUTCOMMIT): "OP_LAYOUTCOMMIT", + int32(OP_LAYOUTGET): "OP_LAYOUTGET", + int32(OP_LAYOUTRETURN): "OP_LAYOUTRETURN", + int32(OP_SECINFO_NO_NAME): "OP_SECINFO_NO_NAME", + int32(OP_SEQUENCE): "OP_SEQUENCE", + int32(OP_SET_SSV): "OP_SET_SSV", + int32(OP_TEST_STATEID): "OP_TEST_STATEID", + int32(OP_WANT_DELEGATION): "OP_WANT_DELEGATION", + int32(OP_DESTROY_CLIENTID): "OP_DESTROY_CLIENTID", + int32(OP_RECLAIM_COMPLETE): "OP_RECLAIM_COMPLETE", + int32(OP_ILLEGAL): "OP_ILLEGAL", +} +var _XdrValues_Nfs_opnum4 = map[string]int32{ + "OP_ACCESS": int32(OP_ACCESS), + "OP_CLOSE": int32(OP_CLOSE), + "OP_COMMIT": int32(OP_COMMIT), + "OP_CREATE": int32(OP_CREATE), + "OP_DELEGPURGE": int32(OP_DELEGPURGE), + "OP_DELEGRETURN": int32(OP_DELEGRETURN), + "OP_GETATTR": int32(OP_GETATTR), + "OP_GETFH": int32(OP_GETFH), + "OP_LINK": int32(OP_LINK), + "OP_LOCK": int32(OP_LOCK), + "OP_LOCKT": int32(OP_LOCKT), + "OP_LOCKU": int32(OP_LOCKU), + "OP_LOOKUP": int32(OP_LOOKUP), + "OP_LOOKUPP": int32(OP_LOOKUPP), + "OP_NVERIFY": int32(OP_NVERIFY), + "OP_OPEN": int32(OP_OPEN), + "OP_OPENATTR": int32(OP_OPENATTR), + "OP_OPEN_CONFIRM": int32(OP_OPEN_CONFIRM), + "OP_OPEN_DOWNGRADE": int32(OP_OPEN_DOWNGRADE), + "OP_PUTFH": int32(OP_PUTFH), + "OP_PUTPUBFH": int32(OP_PUTPUBFH), + "OP_PUTROOTFH": int32(OP_PUTROOTFH), + "OP_READ": int32(OP_READ), + "OP_READDIR": int32(OP_READDIR), + "OP_READLINK": int32(OP_READLINK), + "OP_REMOVE": int32(OP_REMOVE), + "OP_RENAME": int32(OP_RENAME), + "OP_RENEW": int32(OP_RENEW), + "OP_RESTOREFH": int32(OP_RESTOREFH), + "OP_SAVEFH": int32(OP_SAVEFH), + "OP_SECINFO": int32(OP_SECINFO), + "OP_SETATTR": int32(OP_SETATTR), + "OP_SETCLIENTID": int32(OP_SETCLIENTID), + "OP_SETCLIENTID_CONFIRM": int32(OP_SETCLIENTID_CONFIRM), + "OP_VERIFY": int32(OP_VERIFY), + "OP_WRITE": int32(OP_WRITE), + "OP_RELEASE_LOCKOWNER": int32(OP_RELEASE_LOCKOWNER), + "OP_CREATE_SESSION": int32(OP_CREATE_SESSION), + "OP_DESTROY_SESSION": int32(OP_DESTROY_SESSION), + "OP_FREE_STATEID": int32(OP_FREE_STATEID), + "OP_GET_DIR_DELEGATION": int32(OP_GET_DIR_DELEGATION), + "OP_GETDEVICEINFO": int32(OP_GETDEVICEINFO), + "OP_GETDEVICELIST": int32(OP_GETDEVICELIST), + "OP_LAYOUTCOMMIT": int32(OP_LAYOUTCOMMIT), + "OP_LAYOUTGET": int32(OP_LAYOUTGET), + "OP_LAYOUTRETURN": int32(OP_LAYOUTRETURN), + "OP_SECINFO_NO_NAME": int32(OP_SECINFO_NO_NAME), + "OP_SEQUENCE": int32(OP_SEQUENCE), + "OP_SET_SSV": int32(OP_SET_SSV), + "OP_TEST_STATEID": int32(OP_TEST_STATEID), + "OP_WANT_DELEGATION": int32(OP_WANT_DELEGATION), + "OP_DESTROY_CLIENTID": int32(OP_DESTROY_CLIENTID), + "OP_RECLAIM_COMPLETE": int32(OP_RECLAIM_COMPLETE), + "OP_ILLEGAL": int32(OP_ILLEGAL), +} +func (Nfs_opnum4) XdrEnumNames() map[int32]string { + return _XdrNames_Nfs_opnum4 +} +func (v Nfs_opnum4) String() string { + if s, ok := _XdrNames_Nfs_opnum4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Nfs_opnum4#%d", v) +} +func (v *Nfs_opnum4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Nfs_opnum4[stok]; ok { + *v = Nfs_opnum4(val) + return nil + } else if stok == "Nfs_opnum4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Nfs_opnum4.", stok)) + } +} +func (v Nfs_opnum4) GetU32() uint32 { return uint32(v) } +func (v *Nfs_opnum4) SetU32(n uint32) { *v = Nfs_opnum4(n) } +func (v *Nfs_opnum4) XdrPointer() interface{} { return v } +func (Nfs_opnum4) XdrTypeName() string { return "Nfs_opnum4" } +func (v Nfs_opnum4) XdrValue() interface{} { return v } +func (v *Nfs_opnum4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Nfs_opnum4 = *Nfs_opnum4 +func XDR_Nfs_opnum4(v *Nfs_opnum4) *Nfs_opnum4 { return v } +func (v *Nfs_opnum4) XdrInitialize() { + switch Nfs_opnum4(0) { + case OP_ACCESS, OP_CLOSE, OP_COMMIT, OP_CREATE, OP_DELEGPURGE, OP_DELEGRETURN, OP_GETATTR, OP_GETFH, OP_LINK, OP_LOCK, OP_LOCKT, OP_LOCKU, OP_LOOKUP, OP_LOOKUPP, OP_NVERIFY, OP_OPEN, OP_OPENATTR, OP_OPEN_CONFIRM, OP_OPEN_DOWNGRADE, OP_PUTFH, OP_PUTPUBFH, OP_PUTROOTFH, OP_READ, OP_READDIR, OP_READLINK, OP_REMOVE, OP_RENAME, OP_RENEW, OP_RESTOREFH, OP_SAVEFH, OP_SECINFO, OP_SETATTR, OP_SETCLIENTID, OP_SETCLIENTID_CONFIRM, OP_VERIFY, OP_WRITE, OP_RELEASE_LOCKOWNER, OP_CREATE_SESSION, OP_DESTROY_SESSION, OP_FREE_STATEID, OP_GET_DIR_DELEGATION, OP_GETDEVICEINFO, OP_GETDEVICELIST, OP_LAYOUTCOMMIT, OP_LAYOUTGET, OP_LAYOUTRETURN, OP_SECINFO_NO_NAME, OP_SEQUENCE, OP_SET_SSV, OP_TEST_STATEID, OP_WANT_DELEGATION, OP_DESTROY_CLIENTID, OP_RECLAIM_COMPLETE, OP_ILLEGAL: + default: + if *v == Nfs_opnum4(0) { *v = OP_ACCESS } + } +} +var _XdrTags_Nfs_argop4 = map[int32]bool{ + XdrToI32(OP_ACCESS): true, + XdrToI32(OP_CLOSE): true, + XdrToI32(OP_COMMIT): true, + XdrToI32(OP_CREATE): true, + XdrToI32(OP_DELEGPURGE): true, + XdrToI32(OP_DELEGRETURN): true, + XdrToI32(OP_GETATTR): true, + XdrToI32(OP_GETFH): true, + XdrToI32(OP_LINK): true, + XdrToI32(OP_LOCK): true, + XdrToI32(OP_LOCKT): true, + XdrToI32(OP_LOCKU): true, + XdrToI32(OP_LOOKUP): true, + XdrToI32(OP_LOOKUPP): true, + XdrToI32(OP_NVERIFY): true, + XdrToI32(OP_OPEN): true, + XdrToI32(OP_OPENATTR): true, + XdrToI32(OP_OPEN_CONFIRM): true, + XdrToI32(OP_OPEN_DOWNGRADE): true, + XdrToI32(OP_PUTFH): true, + XdrToI32(OP_PUTPUBFH): true, + XdrToI32(OP_PUTROOTFH): true, + XdrToI32(OP_READ): true, + XdrToI32(OP_READDIR): true, + XdrToI32(OP_READLINK): true, + XdrToI32(OP_REMOVE): true, + XdrToI32(OP_RENAME): true, + XdrToI32(OP_RENEW): true, + XdrToI32(OP_RESTOREFH): true, + XdrToI32(OP_SAVEFH): true, + XdrToI32(OP_SECINFO): true, + XdrToI32(OP_SETATTR): true, + XdrToI32(OP_SETCLIENTID): true, + XdrToI32(OP_SETCLIENTID_CONFIRM): true, + XdrToI32(OP_VERIFY): true, + XdrToI32(OP_WRITE): true, + XdrToI32(OP_RELEASE_LOCKOWNER): true, + XdrToI32(OP_CREATE_SESSION): true, + XdrToI32(OP_DESTROY_SESSION): true, + XdrToI32(OP_FREE_STATEID): true, + XdrToI32(OP_GET_DIR_DELEGATION): true, + XdrToI32(OP_GETDEVICEINFO): true, + XdrToI32(OP_GETDEVICELIST): true, + XdrToI32(OP_LAYOUTCOMMIT): true, + XdrToI32(OP_LAYOUTGET): true, + XdrToI32(OP_LAYOUTRETURN): true, + XdrToI32(OP_SECINFO_NO_NAME): true, + XdrToI32(OP_SEQUENCE): true, + XdrToI32(OP_SET_SSV): true, + XdrToI32(OP_TEST_STATEID): true, + XdrToI32(OP_WANT_DELEGATION): true, + XdrToI32(OP_DESTROY_CLIENTID): true, + XdrToI32(OP_RECLAIM_COMPLETE): true, + XdrToI32(OP_ILLEGAL): true, +} +func (_ Nfs_argop4) XdrValidTags() map[int32]bool { + return _XdrTags_Nfs_argop4 +} +func (u *Nfs_argop4) Opaccess() *ACCESS4args { + switch u.Argop { + case OP_ACCESS: + if v, ok := u.U.(*ACCESS4args); ok { + return v + } else { + var zero ACCESS4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opaccess accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opclose() *CLOSE4args { + switch u.Argop { + case OP_CLOSE: + if v, ok := u.U.(*CLOSE4args); ok { + return v + } else { + var zero CLOSE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opclose accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opcommit() *COMMIT4args { + switch u.Argop { + case OP_COMMIT: + if v, ok := u.U.(*COMMIT4args); ok { + return v + } else { + var zero COMMIT4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opcommit accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opcreate() *CREATE4args { + switch u.Argop { + case OP_CREATE: + if v, ok := u.U.(*CREATE4args); ok { + return v + } else { + var zero CREATE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opcreate accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opdelegpurge() *DELEGPURGE4args { + switch u.Argop { + case OP_DELEGPURGE: + if v, ok := u.U.(*DELEGPURGE4args); ok { + return v + } else { + var zero DELEGPURGE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opdelegpurge accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opdelegreturn() *DELEGRETURN4args { + switch u.Argop { + case OP_DELEGRETURN: + if v, ok := u.U.(*DELEGRETURN4args); ok { + return v + } else { + var zero DELEGRETURN4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opdelegreturn accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opgetattr() *GETATTR4args { + switch u.Argop { + case OP_GETATTR: + if v, ok := u.U.(*GETATTR4args); ok { + return v + } else { + var zero GETATTR4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opgetattr accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplink() *LINK4args { + switch u.Argop { + case OP_LINK: + if v, ok := u.U.(*LINK4args); ok { + return v + } else { + var zero LINK4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplink accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplock() *LOCK4args { + switch u.Argop { + case OP_LOCK: + if v, ok := u.U.(*LOCK4args); ok { + return v + } else { + var zero LOCK4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplock accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplockt() *LOCKT4args { + switch u.Argop { + case OP_LOCKT: + if v, ok := u.U.(*LOCKT4args); ok { + return v + } else { + var zero LOCKT4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplockt accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplocku() *LOCKU4args { + switch u.Argop { + case OP_LOCKU: + if v, ok := u.U.(*LOCKU4args); ok { + return v + } else { + var zero LOCKU4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplocku accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplookup() *LOOKUP4args { + switch u.Argop { + case OP_LOOKUP: + if v, ok := u.U.(*LOOKUP4args); ok { + return v + } else { + var zero LOOKUP4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplookup accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opnverify() *NVERIFY4args { + switch u.Argop { + case OP_NVERIFY: + if v, ok := u.U.(*NVERIFY4args); ok { + return v + } else { + var zero NVERIFY4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opnverify accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opopen() *OPEN4args { + switch u.Argop { + case OP_OPEN: + if v, ok := u.U.(*OPEN4args); ok { + return v + } else { + var zero OPEN4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opopen accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opopenattr() *OPENATTR4args { + switch u.Argop { + case OP_OPENATTR: + if v, ok := u.U.(*OPENATTR4args); ok { + return v + } else { + var zero OPENATTR4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opopenattr accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opopen_confirm() *OPEN_CONFIRM4args { + switch u.Argop { + case OP_OPEN_CONFIRM: + if v, ok := u.U.(*OPEN_CONFIRM4args); ok { + return v + } else { + var zero OPEN_CONFIRM4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opopen_confirm accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opopen_downgrade() *OPEN_DOWNGRADE4args { + switch u.Argop { + case OP_OPEN_DOWNGRADE: + if v, ok := u.U.(*OPEN_DOWNGRADE4args); ok { + return v + } else { + var zero OPEN_DOWNGRADE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opopen_downgrade accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opputfh() *PUTFH4args { + switch u.Argop { + case OP_PUTFH: + if v, ok := u.U.(*PUTFH4args); ok { + return v + } else { + var zero PUTFH4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opputfh accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opread() *READ4args { + switch u.Argop { + case OP_READ: + if v, ok := u.U.(*READ4args); ok { + return v + } else { + var zero READ4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opread accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opreaddir() *READDIR4args { + switch u.Argop { + case OP_READDIR: + if v, ok := u.U.(*READDIR4args); ok { + return v + } else { + var zero READDIR4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opreaddir accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opremove() *REMOVE4args { + switch u.Argop { + case OP_REMOVE: + if v, ok := u.U.(*REMOVE4args); ok { + return v + } else { + var zero REMOVE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opremove accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oprename() *RENAME4args { + switch u.Argop { + case OP_RENAME: + if v, ok := u.U.(*RENAME4args); ok { + return v + } else { + var zero RENAME4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oprename accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oprenew() *RENEW4args { + switch u.Argop { + case OP_RENEW: + if v, ok := u.U.(*RENEW4args); ok { + return v + } else { + var zero RENEW4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oprenew accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsecinfo() *SECINFO4args { + switch u.Argop { + case OP_SECINFO: + if v, ok := u.U.(*SECINFO4args); ok { + return v + } else { + var zero SECINFO4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsecinfo accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsetattr() *SETATTR4args { + switch u.Argop { + case OP_SETATTR: + if v, ok := u.U.(*SETATTR4args); ok { + return v + } else { + var zero SETATTR4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsetattr accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsetclientid() *SETCLIENTID4args { + switch u.Argop { + case OP_SETCLIENTID: + if v, ok := u.U.(*SETCLIENTID4args); ok { + return v + } else { + var zero SETCLIENTID4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsetclientid accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsetclientid_confirm() *SETCLIENTID_CONFIRM4args { + switch u.Argop { + case OP_SETCLIENTID_CONFIRM: + if v, ok := u.U.(*SETCLIENTID_CONFIRM4args); ok { + return v + } else { + var zero SETCLIENTID_CONFIRM4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsetclientid_confirm accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opverify() *VERIFY4args { + switch u.Argop { + case OP_VERIFY: + if v, ok := u.U.(*VERIFY4args); ok { + return v + } else { + var zero VERIFY4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opverify accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opwrite() *WRITE4args { + switch u.Argop { + case OP_WRITE: + if v, ok := u.U.(*WRITE4args); ok { + return v + } else { + var zero WRITE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opwrite accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oprelease_lockowner() *RELEASE_LOCKOWNER4args { + switch u.Argop { + case OP_RELEASE_LOCKOWNER: + if v, ok := u.U.(*RELEASE_LOCKOWNER4args); ok { + return v + } else { + var zero RELEASE_LOCKOWNER4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oprelease_lockowner accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opcreatesession() *CREATE_SESSION4args { + switch u.Argop { + case OP_CREATE_SESSION: + if v, ok := u.U.(*CREATE_SESSION4args); ok { + return v + } else { + var zero CREATE_SESSION4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opcreatesession accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opdestroysession() *DESTROY_SESSION4args { + switch u.Argop { + case OP_DESTROY_SESSION: + if v, ok := u.U.(*DESTROY_SESSION4args); ok { + return v + } else { + var zero DESTROY_SESSION4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opdestroysession accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opfreestateid() *FREE_STATEID4args { + switch u.Argop { + case OP_FREE_STATEID: + if v, ok := u.U.(*FREE_STATEID4args); ok { + return v + } else { + var zero FREE_STATEID4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opfreestateid accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opgetdirdelegation() *GET_DIR_DELEGATION4args { + switch u.Argop { + case OP_GET_DIR_DELEGATION: + if v, ok := u.U.(*GET_DIR_DELEGATION4args); ok { + return v + } else { + var zero GET_DIR_DELEGATION4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opgetdirdelegation accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opgetdeviceinfo() *GETDEVICEINFO4args { + switch u.Argop { + case OP_GETDEVICEINFO: + if v, ok := u.U.(*GETDEVICEINFO4args); ok { + return v + } else { + var zero GETDEVICEINFO4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opgetdeviceinfo accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opgetdevicelist() *GETDEVICELIST4args { + switch u.Argop { + case OP_GETDEVICELIST: + if v, ok := u.U.(*GETDEVICELIST4args); ok { + return v + } else { + var zero GETDEVICELIST4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opgetdevicelist accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplayoutcommit() *LAYOUTCOMMIT4args { + switch u.Argop { + case OP_LAYOUTCOMMIT: + if v, ok := u.U.(*LAYOUTCOMMIT4args); ok { + return v + } else { + var zero LAYOUTCOMMIT4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplayoutcommit accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplayoutget() *LAYOUTGET4args { + switch u.Argop { + case OP_LAYOUTGET: + if v, ok := u.U.(*LAYOUTGET4args); ok { + return v + } else { + var zero LAYOUTGET4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplayoutget accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Oplayoutreturn() *LAYOUTRETURN4args { + switch u.Argop { + case OP_LAYOUTRETURN: + if v, ok := u.U.(*LAYOUTRETURN4args); ok { + return v + } else { + var zero LAYOUTRETURN4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Oplayoutreturn accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsecinfononame() *SECINFO_NO_NAME4args { + switch u.Argop { + case OP_SECINFO_NO_NAME: + if v, ok := u.U.(*SECINFO_NO_NAME4args); ok { + return v + } else { + var zero SECINFO_NO_NAME4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsecinfononame accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsequence() *SEQUENCE4args { + switch u.Argop { + case OP_SEQUENCE: + if v, ok := u.U.(*SEQUENCE4args); ok { + return v + } else { + var zero SEQUENCE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsequence accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opsetssv() *SET_SSV4args { + switch u.Argop { + case OP_SET_SSV: + if v, ok := u.U.(*SET_SSV4args); ok { + return v + } else { + var zero SET_SSV4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opsetssv accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opteststateid() *TEST_STATEID4args { + switch u.Argop { + case OP_TEST_STATEID: + if v, ok := u.U.(*TEST_STATEID4args); ok { + return v + } else { + var zero TEST_STATEID4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opteststateid accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opwantdelegation() *WANT_DELEGATION4args { + switch u.Argop { + case OP_WANT_DELEGATION: + if v, ok := u.U.(*WANT_DELEGATION4args); ok { + return v + } else { + var zero WANT_DELEGATION4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opwantdelegation accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opdestroyclientid() *DESTROY_CLIENTID4args { + switch u.Argop { + case OP_DESTROY_CLIENTID: + if v, ok := u.U.(*DESTROY_CLIENTID4args); ok { + return v + } else { + var zero DESTROY_CLIENTID4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opdestroyclientid accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_argop4) Opreclaimcomplete() *RECLAIM_COMPLETE4args { + switch u.Argop { + case OP_RECLAIM_COMPLETE: + if v, ok := u.U.(*RECLAIM_COMPLETE4args); ok { + return v + } else { + var zero RECLAIM_COMPLETE4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_argop4.Opreclaimcomplete accessed when Argop == %v", u.Argop) + return nil + } +} +func (u Nfs_argop4) XdrValid() bool { + switch u.Argop { + case OP_ACCESS,OP_CLOSE,OP_COMMIT,OP_CREATE,OP_DELEGPURGE,OP_DELEGRETURN,OP_GETATTR,OP_GETFH,OP_LINK,OP_LOCK,OP_LOCKT,OP_LOCKU,OP_LOOKUP,OP_LOOKUPP,OP_NVERIFY,OP_OPEN,OP_OPENATTR,OP_OPEN_CONFIRM,OP_OPEN_DOWNGRADE,OP_PUTFH,OP_PUTPUBFH,OP_PUTROOTFH,OP_READ,OP_READDIR,OP_READLINK,OP_REMOVE,OP_RENAME,OP_RENEW,OP_RESTOREFH,OP_SAVEFH,OP_SECINFO,OP_SETATTR,OP_SETCLIENTID,OP_SETCLIENTID_CONFIRM,OP_VERIFY,OP_WRITE,OP_RELEASE_LOCKOWNER,OP_CREATE_SESSION,OP_DESTROY_SESSION,OP_FREE_STATEID,OP_GET_DIR_DELEGATION,OP_GETDEVICEINFO,OP_GETDEVICELIST,OP_LAYOUTCOMMIT,OP_LAYOUTGET,OP_LAYOUTRETURN,OP_SECINFO_NO_NAME,OP_SEQUENCE,OP_SET_SSV,OP_TEST_STATEID,OP_WANT_DELEGATION,OP_DESTROY_CLIENTID,OP_RECLAIM_COMPLETE,OP_ILLEGAL: + return true + } + return false +} +func (u *Nfs_argop4) XdrUnionTag() XdrNum32 { + return XDR_Nfs_opnum4(&u.Argop) +} +func (u *Nfs_argop4) XdrUnionTagName() string { + return "Argop" +} +func (u *Nfs_argop4) XdrUnionBody() XdrType { + switch u.Argop { + case OP_ACCESS: + return XDR_ACCESS4args(u.Opaccess()) + case OP_CLOSE: + return XDR_CLOSE4args(u.Opclose()) + case OP_COMMIT: + return XDR_COMMIT4args(u.Opcommit()) + case OP_CREATE: + return XDR_CREATE4args(u.Opcreate()) + case OP_DELEGPURGE: + return XDR_DELEGPURGE4args(u.Opdelegpurge()) + case OP_DELEGRETURN: + return XDR_DELEGRETURN4args(u.Opdelegreturn()) + case OP_GETATTR: + return XDR_GETATTR4args(u.Opgetattr()) + case OP_GETFH: + return nil + case OP_LINK: + return XDR_LINK4args(u.Oplink()) + case OP_LOCK: + return XDR_LOCK4args(u.Oplock()) + case OP_LOCKT: + return XDR_LOCKT4args(u.Oplockt()) + case OP_LOCKU: + return XDR_LOCKU4args(u.Oplocku()) + case OP_LOOKUP: + return XDR_LOOKUP4args(u.Oplookup()) + case OP_LOOKUPP: + return nil + case OP_NVERIFY: + return XDR_NVERIFY4args(u.Opnverify()) + case OP_OPEN: + return XDR_OPEN4args(u.Opopen()) + case OP_OPENATTR: + return XDR_OPENATTR4args(u.Opopenattr()) + case OP_OPEN_CONFIRM: + return XDR_OPEN_CONFIRM4args(u.Opopen_confirm()) + case OP_OPEN_DOWNGRADE: + return XDR_OPEN_DOWNGRADE4args(u.Opopen_downgrade()) + case OP_PUTFH: + return XDR_PUTFH4args(u.Opputfh()) + case OP_PUTPUBFH: + return nil + case OP_PUTROOTFH: + return nil + case OP_READ: + return XDR_READ4args(u.Opread()) + case OP_READDIR: + return XDR_READDIR4args(u.Opreaddir()) + case OP_READLINK: + return nil + case OP_REMOVE: + return XDR_REMOVE4args(u.Opremove()) + case OP_RENAME: + return XDR_RENAME4args(u.Oprename()) + case OP_RENEW: + return XDR_RENEW4args(u.Oprenew()) + case OP_RESTOREFH: + return nil + case OP_SAVEFH: + return nil + case OP_SECINFO: + return XDR_SECINFO4args(u.Opsecinfo()) + case OP_SETATTR: + return XDR_SETATTR4args(u.Opsetattr()) + case OP_SETCLIENTID: + return XDR_SETCLIENTID4args(u.Opsetclientid()) + case OP_SETCLIENTID_CONFIRM: + return XDR_SETCLIENTID_CONFIRM4args(u.Opsetclientid_confirm()) + case OP_VERIFY: + return XDR_VERIFY4args(u.Opverify()) + case OP_WRITE: + return XDR_WRITE4args(u.Opwrite()) + case OP_RELEASE_LOCKOWNER: + return XDR_RELEASE_LOCKOWNER4args(u.Oprelease_lockowner()) + case OP_CREATE_SESSION: + return XDR_CREATE_SESSION4args(u.Opcreatesession()) + case OP_DESTROY_SESSION: + return XDR_DESTROY_SESSION4args(u.Opdestroysession()) + case OP_FREE_STATEID: + return XDR_FREE_STATEID4args(u.Opfreestateid()) + case OP_GET_DIR_DELEGATION: + return XDR_GET_DIR_DELEGATION4args(u.Opgetdirdelegation()) + case OP_GETDEVICEINFO: + return XDR_GETDEVICEINFO4args(u.Opgetdeviceinfo()) + case OP_GETDEVICELIST: + return XDR_GETDEVICELIST4args(u.Opgetdevicelist()) + case OP_LAYOUTCOMMIT: + return XDR_LAYOUTCOMMIT4args(u.Oplayoutcommit()) + case OP_LAYOUTGET: + return XDR_LAYOUTGET4args(u.Oplayoutget()) + case OP_LAYOUTRETURN: + return XDR_LAYOUTRETURN4args(u.Oplayoutreturn()) + case OP_SECINFO_NO_NAME: + return XDR_SECINFO_NO_NAME4args(u.Opsecinfononame()) + case OP_SEQUENCE: + return XDR_SEQUENCE4args(u.Opsequence()) + case OP_SET_SSV: + return XDR_SET_SSV4args(u.Opsetssv()) + case OP_TEST_STATEID: + return XDR_TEST_STATEID4args(u.Opteststateid()) + case OP_WANT_DELEGATION: + return XDR_WANT_DELEGATION4args(u.Opwantdelegation()) + case OP_DESTROY_CLIENTID: + return XDR_DESTROY_CLIENTID4args(u.Opdestroyclientid()) + case OP_RECLAIM_COMPLETE: + return XDR_RECLAIM_COMPLETE4args(u.Opreclaimcomplete()) + case OP_ILLEGAL: + return nil + } + return nil +} +func (u *Nfs_argop4) XdrUnionBodyName() string { + switch u.Argop { + case OP_ACCESS: + return "Opaccess" + case OP_CLOSE: + return "Opclose" + case OP_COMMIT: + return "Opcommit" + case OP_CREATE: + return "Opcreate" + case OP_DELEGPURGE: + return "Opdelegpurge" + case OP_DELEGRETURN: + return "Opdelegreturn" + case OP_GETATTR: + return "Opgetattr" + case OP_GETFH: + return "" + case OP_LINK: + return "Oplink" + case OP_LOCK: + return "Oplock" + case OP_LOCKT: + return "Oplockt" + case OP_LOCKU: + return "Oplocku" + case OP_LOOKUP: + return "Oplookup" + case OP_LOOKUPP: + return "" + case OP_NVERIFY: + return "Opnverify" + case OP_OPEN: + return "Opopen" + case OP_OPENATTR: + return "Opopenattr" + case OP_OPEN_CONFIRM: + return "Opopen_confirm" + case OP_OPEN_DOWNGRADE: + return "Opopen_downgrade" + case OP_PUTFH: + return "Opputfh" + case OP_PUTPUBFH: + return "" + case OP_PUTROOTFH: + return "" + case OP_READ: + return "Opread" + case OP_READDIR: + return "Opreaddir" + case OP_READLINK: + return "" + case OP_REMOVE: + return "Opremove" + case OP_RENAME: + return "Oprename" + case OP_RENEW: + return "Oprenew" + case OP_RESTOREFH: + return "" + case OP_SAVEFH: + return "" + case OP_SECINFO: + return "Opsecinfo" + case OP_SETATTR: + return "Opsetattr" + case OP_SETCLIENTID: + return "Opsetclientid" + case OP_SETCLIENTID_CONFIRM: + return "Opsetclientid_confirm" + case OP_VERIFY: + return "Opverify" + case OP_WRITE: + return "Opwrite" + case OP_RELEASE_LOCKOWNER: + return "Oprelease_lockowner" + case OP_CREATE_SESSION: + return "Opcreatesession" + case OP_DESTROY_SESSION: + return "Opdestroysession" + case OP_FREE_STATEID: + return "Opfreestateid" + case OP_GET_DIR_DELEGATION: + return "Opgetdirdelegation" + case OP_GETDEVICEINFO: + return "Opgetdeviceinfo" + case OP_GETDEVICELIST: + return "Opgetdevicelist" + case OP_LAYOUTCOMMIT: + return "Oplayoutcommit" + case OP_LAYOUTGET: + return "Oplayoutget" + case OP_LAYOUTRETURN: + return "Oplayoutreturn" + case OP_SECINFO_NO_NAME: + return "Opsecinfononame" + case OP_SEQUENCE: + return "Opsequence" + case OP_SET_SSV: + return "Opsetssv" + case OP_TEST_STATEID: + return "Opteststateid" + case OP_WANT_DELEGATION: + return "Opwantdelegation" + case OP_DESTROY_CLIENTID: + return "Opdestroyclientid" + case OP_RECLAIM_COMPLETE: + return "Opreclaimcomplete" + case OP_ILLEGAL: + return "" + } + return "" +} +type XdrType_Nfs_argop4 = *Nfs_argop4 +func (v *Nfs_argop4) XdrPointer() interface{} { return v } +func (Nfs_argop4) XdrTypeName() string { return "Nfs_argop4" } +func (v Nfs_argop4) XdrValue() interface{} { return v } +func (v *Nfs_argop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Nfs_argop4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfs_opnum4(&u.Argop).XdrMarshal(x, x.Sprintf("%sargop", name)) + switch u.Argop { + case OP_ACCESS: + x.Marshal(x.Sprintf("%sopaccess", name), XDR_ACCESS4args(u.Opaccess())) + return + case OP_CLOSE: + x.Marshal(x.Sprintf("%sopclose", name), XDR_CLOSE4args(u.Opclose())) + return + case OP_COMMIT: + x.Marshal(x.Sprintf("%sopcommit", name), XDR_COMMIT4args(u.Opcommit())) + return + case OP_CREATE: + x.Marshal(x.Sprintf("%sopcreate", name), XDR_CREATE4args(u.Opcreate())) + return + case OP_DELEGPURGE: + x.Marshal(x.Sprintf("%sopdelegpurge", name), XDR_DELEGPURGE4args(u.Opdelegpurge())) + return + case OP_DELEGRETURN: + x.Marshal(x.Sprintf("%sopdelegreturn", name), XDR_DELEGRETURN4args(u.Opdelegreturn())) + return + case OP_GETATTR: + x.Marshal(x.Sprintf("%sopgetattr", name), XDR_GETATTR4args(u.Opgetattr())) + return + case OP_GETFH: + return + case OP_LINK: + x.Marshal(x.Sprintf("%soplink", name), XDR_LINK4args(u.Oplink())) + return + case OP_LOCK: + x.Marshal(x.Sprintf("%soplock", name), XDR_LOCK4args(u.Oplock())) + return + case OP_LOCKT: + x.Marshal(x.Sprintf("%soplockt", name), XDR_LOCKT4args(u.Oplockt())) + return + case OP_LOCKU: + x.Marshal(x.Sprintf("%soplocku", name), XDR_LOCKU4args(u.Oplocku())) + return + case OP_LOOKUP: + x.Marshal(x.Sprintf("%soplookup", name), XDR_LOOKUP4args(u.Oplookup())) + return + case OP_LOOKUPP: + return + case OP_NVERIFY: + x.Marshal(x.Sprintf("%sopnverify", name), XDR_NVERIFY4args(u.Opnverify())) + return + case OP_OPEN: + x.Marshal(x.Sprintf("%sopopen", name), XDR_OPEN4args(u.Opopen())) + return + case OP_OPENATTR: + x.Marshal(x.Sprintf("%sopopenattr", name), XDR_OPENATTR4args(u.Opopenattr())) + return + case OP_OPEN_CONFIRM: + x.Marshal(x.Sprintf("%sopopen_confirm", name), XDR_OPEN_CONFIRM4args(u.Opopen_confirm())) + return + case OP_OPEN_DOWNGRADE: + x.Marshal(x.Sprintf("%sopopen_downgrade", name), XDR_OPEN_DOWNGRADE4args(u.Opopen_downgrade())) + return + case OP_PUTFH: + x.Marshal(x.Sprintf("%sopputfh", name), XDR_PUTFH4args(u.Opputfh())) + return + case OP_PUTPUBFH: + return + case OP_PUTROOTFH: + return + case OP_READ: + x.Marshal(x.Sprintf("%sopread", name), XDR_READ4args(u.Opread())) + return + case OP_READDIR: + x.Marshal(x.Sprintf("%sopreaddir", name), XDR_READDIR4args(u.Opreaddir())) + return + case OP_READLINK: + return + case OP_REMOVE: + x.Marshal(x.Sprintf("%sopremove", name), XDR_REMOVE4args(u.Opremove())) + return + case OP_RENAME: + x.Marshal(x.Sprintf("%soprename", name), XDR_RENAME4args(u.Oprename())) + return + case OP_RENEW: + x.Marshal(x.Sprintf("%soprenew", name), XDR_RENEW4args(u.Oprenew())) + return + case OP_RESTOREFH: + return + case OP_SAVEFH: + return + case OP_SECINFO: + x.Marshal(x.Sprintf("%sopsecinfo", name), XDR_SECINFO4args(u.Opsecinfo())) + return + case OP_SETATTR: + x.Marshal(x.Sprintf("%sopsetattr", name), XDR_SETATTR4args(u.Opsetattr())) + return + case OP_SETCLIENTID: + x.Marshal(x.Sprintf("%sopsetclientid", name), XDR_SETCLIENTID4args(u.Opsetclientid())) + return + case OP_SETCLIENTID_CONFIRM: + x.Marshal(x.Sprintf("%sopsetclientid_confirm", name), XDR_SETCLIENTID_CONFIRM4args(u.Opsetclientid_confirm())) + return + case OP_VERIFY: + x.Marshal(x.Sprintf("%sopverify", name), XDR_VERIFY4args(u.Opverify())) + return + case OP_WRITE: + x.Marshal(x.Sprintf("%sopwrite", name), XDR_WRITE4args(u.Opwrite())) + return + case OP_RELEASE_LOCKOWNER: + x.Marshal(x.Sprintf("%soprelease_lockowner", name), XDR_RELEASE_LOCKOWNER4args(u.Oprelease_lockowner())) + return + case OP_CREATE_SESSION: + x.Marshal(x.Sprintf("%sopcreatesession", name), XDR_CREATE_SESSION4args(u.Opcreatesession())) + return + case OP_DESTROY_SESSION: + x.Marshal(x.Sprintf("%sopdestroysession", name), XDR_DESTROY_SESSION4args(u.Opdestroysession())) + return + case OP_FREE_STATEID: + x.Marshal(x.Sprintf("%sopfreestateid", name), XDR_FREE_STATEID4args(u.Opfreestateid())) + return + case OP_GET_DIR_DELEGATION: + x.Marshal(x.Sprintf("%sopgetdirdelegation", name), XDR_GET_DIR_DELEGATION4args(u.Opgetdirdelegation())) + return + case OP_GETDEVICEINFO: + x.Marshal(x.Sprintf("%sopgetdeviceinfo", name), XDR_GETDEVICEINFO4args(u.Opgetdeviceinfo())) + return + case OP_GETDEVICELIST: + x.Marshal(x.Sprintf("%sopgetdevicelist", name), XDR_GETDEVICELIST4args(u.Opgetdevicelist())) + return + case OP_LAYOUTCOMMIT: + x.Marshal(x.Sprintf("%soplayoutcommit", name), XDR_LAYOUTCOMMIT4args(u.Oplayoutcommit())) + return + case OP_LAYOUTGET: + x.Marshal(x.Sprintf("%soplayoutget", name), XDR_LAYOUTGET4args(u.Oplayoutget())) + return + case OP_LAYOUTRETURN: + x.Marshal(x.Sprintf("%soplayoutreturn", name), XDR_LAYOUTRETURN4args(u.Oplayoutreturn())) + return + case OP_SECINFO_NO_NAME: + x.Marshal(x.Sprintf("%sopsecinfononame", name), XDR_SECINFO_NO_NAME4args(u.Opsecinfononame())) + return + case OP_SEQUENCE: + x.Marshal(x.Sprintf("%sopsequence", name), XDR_SEQUENCE4args(u.Opsequence())) + return + case OP_SET_SSV: + x.Marshal(x.Sprintf("%sopsetssv", name), XDR_SET_SSV4args(u.Opsetssv())) + return + case OP_TEST_STATEID: + x.Marshal(x.Sprintf("%sopteststateid", name), XDR_TEST_STATEID4args(u.Opteststateid())) + return + case OP_WANT_DELEGATION: + x.Marshal(x.Sprintf("%sopwantdelegation", name), XDR_WANT_DELEGATION4args(u.Opwantdelegation())) + return + case OP_DESTROY_CLIENTID: + x.Marshal(x.Sprintf("%sopdestroyclientid", name), XDR_DESTROY_CLIENTID4args(u.Opdestroyclientid())) + return + case OP_RECLAIM_COMPLETE: + x.Marshal(x.Sprintf("%sopreclaimcomplete", name), XDR_RECLAIM_COMPLETE4args(u.Opreclaimcomplete())) + return + case OP_ILLEGAL: + return + } + XdrPanic("invalid Argop (%v) in Nfs_argop4", u.Argop) +} +func (v *Nfs_argop4) XdrInitialize() { + var zero Nfs_opnum4 + switch zero { + case OP_ACCESS, OP_CLOSE, OP_COMMIT, OP_CREATE, OP_DELEGPURGE, OP_DELEGRETURN, OP_GETATTR, OP_GETFH, OP_LINK, OP_LOCK, OP_LOCKT, OP_LOCKU, OP_LOOKUP, OP_LOOKUPP, OP_NVERIFY, OP_OPEN, OP_OPENATTR, OP_OPEN_CONFIRM, OP_OPEN_DOWNGRADE, OP_PUTFH, OP_PUTPUBFH, OP_PUTROOTFH, OP_READ, OP_READDIR, OP_READLINK, OP_REMOVE, OP_RENAME, OP_RENEW, OP_RESTOREFH, OP_SAVEFH, OP_SECINFO, OP_SETATTR, OP_SETCLIENTID, OP_SETCLIENTID_CONFIRM, OP_VERIFY, OP_WRITE, OP_RELEASE_LOCKOWNER, OP_CREATE_SESSION, OP_DESTROY_SESSION, OP_FREE_STATEID, OP_GET_DIR_DELEGATION, OP_GETDEVICEINFO, OP_GETDEVICELIST, OP_LAYOUTCOMMIT, OP_LAYOUTGET, OP_LAYOUTRETURN, OP_SECINFO_NO_NAME, OP_SEQUENCE, OP_SET_SSV, OP_TEST_STATEID, OP_WANT_DELEGATION, OP_DESTROY_CLIENTID, OP_RECLAIM_COMPLETE, OP_ILLEGAL: + default: + if v.Argop == zero { v.Argop = OP_ACCESS } + } +} +func XDR_Nfs_argop4(v *Nfs_argop4) *Nfs_argop4 { return v} +var _XdrTags_Nfs_resop4 = map[int32]bool{ + XdrToI32(OP_ACCESS): true, + XdrToI32(OP_CLOSE): true, + XdrToI32(OP_COMMIT): true, + XdrToI32(OP_CREATE): true, + XdrToI32(OP_DELEGPURGE): true, + XdrToI32(OP_DELEGRETURN): true, + XdrToI32(OP_GETATTR): true, + XdrToI32(OP_GETFH): true, + XdrToI32(OP_LINK): true, + XdrToI32(OP_LOCK): true, + XdrToI32(OP_LOCKT): true, + XdrToI32(OP_LOCKU): true, + XdrToI32(OP_LOOKUP): true, + XdrToI32(OP_LOOKUPP): true, + XdrToI32(OP_NVERIFY): true, + XdrToI32(OP_OPEN): true, + XdrToI32(OP_OPENATTR): true, + XdrToI32(OP_OPEN_CONFIRM): true, + XdrToI32(OP_OPEN_DOWNGRADE): true, + XdrToI32(OP_PUTFH): true, + XdrToI32(OP_PUTPUBFH): true, + XdrToI32(OP_PUTROOTFH): true, + XdrToI32(OP_READ): true, + XdrToI32(OP_READDIR): true, + XdrToI32(OP_READLINK): true, + XdrToI32(OP_REMOVE): true, + XdrToI32(OP_RENAME): true, + XdrToI32(OP_RENEW): true, + XdrToI32(OP_RESTOREFH): true, + XdrToI32(OP_SAVEFH): true, + XdrToI32(OP_SECINFO): true, + XdrToI32(OP_SETATTR): true, + XdrToI32(OP_SETCLIENTID): true, + XdrToI32(OP_SETCLIENTID_CONFIRM): true, + XdrToI32(OP_VERIFY): true, + XdrToI32(OP_WRITE): true, + XdrToI32(OP_RELEASE_LOCKOWNER): true, + XdrToI32(OP_CREATE_SESSION): true, + XdrToI32(OP_DESTROY_SESSION): true, + XdrToI32(OP_FREE_STATEID): true, + XdrToI32(OP_GET_DIR_DELEGATION): true, + XdrToI32(OP_GETDEVICEINFO): true, + XdrToI32(OP_GETDEVICELIST): true, + XdrToI32(OP_LAYOUTCOMMIT): true, + XdrToI32(OP_LAYOUTGET): true, + XdrToI32(OP_LAYOUTRETURN): true, + XdrToI32(OP_SECINFO_NO_NAME): true, + XdrToI32(OP_SEQUENCE): true, + XdrToI32(OP_SET_SSV): true, + XdrToI32(OP_TEST_STATEID): true, + XdrToI32(OP_WANT_DELEGATION): true, + XdrToI32(OP_DESTROY_CLIENTID): true, + XdrToI32(OP_RECLAIM_COMPLETE): true, + XdrToI32(OP_ILLEGAL): true, +} +func (_ Nfs_resop4) XdrValidTags() map[int32]bool { + return _XdrTags_Nfs_resop4 +} +func (u *Nfs_resop4) Opaccess() *ACCESS4res { + switch u.Resop { + case OP_ACCESS: + if v, ok := u.U.(*ACCESS4res); ok { + return v + } else { + var zero ACCESS4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opaccess accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opclose() *CLOSE4res { + switch u.Resop { + case OP_CLOSE: + if v, ok := u.U.(*CLOSE4res); ok { + return v + } else { + var zero CLOSE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opclose accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opcommit() *COMMIT4res { + switch u.Resop { + case OP_COMMIT: + if v, ok := u.U.(*COMMIT4res); ok { + return v + } else { + var zero COMMIT4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opcommit accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opcreate() *CREATE4res { + switch u.Resop { + case OP_CREATE: + if v, ok := u.U.(*CREATE4res); ok { + return v + } else { + var zero CREATE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opcreate accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opdelegpurge() *DELEGPURGE4res { + switch u.Resop { + case OP_DELEGPURGE: + if v, ok := u.U.(*DELEGPURGE4res); ok { + return v + } else { + var zero DELEGPURGE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opdelegpurge accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opdelegreturn() *DELEGRETURN4res { + switch u.Resop { + case OP_DELEGRETURN: + if v, ok := u.U.(*DELEGRETURN4res); ok { + return v + } else { + var zero DELEGRETURN4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opdelegreturn accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opgetattr() *GETATTR4res { + switch u.Resop { + case OP_GETATTR: + if v, ok := u.U.(*GETATTR4res); ok { + return v + } else { + var zero GETATTR4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opgetattr accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opgetfh() *GETFH4res { + switch u.Resop { + case OP_GETFH: + if v, ok := u.U.(*GETFH4res); ok { + return v + } else { + var zero GETFH4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opgetfh accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplink() *LINK4res { + switch u.Resop { + case OP_LINK: + if v, ok := u.U.(*LINK4res); ok { + return v + } else { + var zero LINK4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplink accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplock() *LOCK4res { + switch u.Resop { + case OP_LOCK: + if v, ok := u.U.(*LOCK4res); ok { + return v + } else { + var zero LOCK4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplock accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplockt() *LOCKT4res { + switch u.Resop { + case OP_LOCKT: + if v, ok := u.U.(*LOCKT4res); ok { + return v + } else { + var zero LOCKT4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplockt accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplocku() *LOCKU4res { + switch u.Resop { + case OP_LOCKU: + if v, ok := u.U.(*LOCKU4res); ok { + return v + } else { + var zero LOCKU4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplocku accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplookup() *LOOKUP4res { + switch u.Resop { + case OP_LOOKUP: + if v, ok := u.U.(*LOOKUP4res); ok { + return v + } else { + var zero LOOKUP4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplookup accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplookupp() *LOOKUPP4res { + switch u.Resop { + case OP_LOOKUPP: + if v, ok := u.U.(*LOOKUPP4res); ok { + return v + } else { + var zero LOOKUPP4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplookupp accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opnverify() *NVERIFY4res { + switch u.Resop { + case OP_NVERIFY: + if v, ok := u.U.(*NVERIFY4res); ok { + return v + } else { + var zero NVERIFY4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opnverify accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opopen() *OPEN4res { + switch u.Resop { + case OP_OPEN: + if v, ok := u.U.(*OPEN4res); ok { + return v + } else { + var zero OPEN4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opopen accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opopenattr() *OPENATTR4res { + switch u.Resop { + case OP_OPENATTR: + if v, ok := u.U.(*OPENATTR4res); ok { + return v + } else { + var zero OPENATTR4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opopenattr accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opopen_confirm() *OPEN_CONFIRM4res { + switch u.Resop { + case OP_OPEN_CONFIRM: + if v, ok := u.U.(*OPEN_CONFIRM4res); ok { + return v + } else { + var zero OPEN_CONFIRM4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opopen_confirm accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opopen_downgrade() *OPEN_DOWNGRADE4res { + switch u.Resop { + case OP_OPEN_DOWNGRADE: + if v, ok := u.U.(*OPEN_DOWNGRADE4res); ok { + return v + } else { + var zero OPEN_DOWNGRADE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opopen_downgrade accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opputfh() *PUTFH4res { + switch u.Resop { + case OP_PUTFH: + if v, ok := u.U.(*PUTFH4res); ok { + return v + } else { + var zero PUTFH4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opputfh accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opputpubfh() *PUTPUBFH4res { + switch u.Resop { + case OP_PUTPUBFH: + if v, ok := u.U.(*PUTPUBFH4res); ok { + return v + } else { + var zero PUTPUBFH4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opputpubfh accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opputrootfh() *PUTROOTFH4res { + switch u.Resop { + case OP_PUTROOTFH: + if v, ok := u.U.(*PUTROOTFH4res); ok { + return v + } else { + var zero PUTROOTFH4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opputrootfh accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opread() *READ4res { + switch u.Resop { + case OP_READ: + if v, ok := u.U.(*READ4res); ok { + return v + } else { + var zero READ4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opread accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opreaddir() *READDIR4res { + switch u.Resop { + case OP_READDIR: + if v, ok := u.U.(*READDIR4res); ok { + return v + } else { + var zero READDIR4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opreaddir accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opreadlink() *READLINK4res { + switch u.Resop { + case OP_READLINK: + if v, ok := u.U.(*READLINK4res); ok { + return v + } else { + var zero READLINK4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opreadlink accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opremove() *REMOVE4res { + switch u.Resop { + case OP_REMOVE: + if v, ok := u.U.(*REMOVE4res); ok { + return v + } else { + var zero REMOVE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opremove accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oprename() *RENAME4res { + switch u.Resop { + case OP_RENAME: + if v, ok := u.U.(*RENAME4res); ok { + return v + } else { + var zero RENAME4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oprename accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oprenew() *RENEW4res { + switch u.Resop { + case OP_RENEW: + if v, ok := u.U.(*RENEW4res); ok { + return v + } else { + var zero RENEW4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oprenew accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oprestorefh() *RESTOREFH4res { + switch u.Resop { + case OP_RESTOREFH: + if v, ok := u.U.(*RESTOREFH4res); ok { + return v + } else { + var zero RESTOREFH4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oprestorefh accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsavefh() *SAVEFH4res { + switch u.Resop { + case OP_SAVEFH: + if v, ok := u.U.(*SAVEFH4res); ok { + return v + } else { + var zero SAVEFH4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsavefh accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsecinfo() *SECINFO4res { + switch u.Resop { + case OP_SECINFO: + if v, ok := u.U.(*SECINFO4res); ok { + return v + } else { + var zero SECINFO4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsecinfo accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsetattr() *SETATTR4res { + switch u.Resop { + case OP_SETATTR: + if v, ok := u.U.(*SETATTR4res); ok { + return v + } else { + var zero SETATTR4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsetattr accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsetclientid() *SETCLIENTID4res { + switch u.Resop { + case OP_SETCLIENTID: + if v, ok := u.U.(*SETCLIENTID4res); ok { + return v + } else { + var zero SETCLIENTID4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsetclientid accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsetclientid_confirm() *SETCLIENTID_CONFIRM4res { + switch u.Resop { + case OP_SETCLIENTID_CONFIRM: + if v, ok := u.U.(*SETCLIENTID_CONFIRM4res); ok { + return v + } else { + var zero SETCLIENTID_CONFIRM4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsetclientid_confirm accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opverify() *VERIFY4res { + switch u.Resop { + case OP_VERIFY: + if v, ok := u.U.(*VERIFY4res); ok { + return v + } else { + var zero VERIFY4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opverify accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opwrite() *WRITE4res { + switch u.Resop { + case OP_WRITE: + if v, ok := u.U.(*WRITE4res); ok { + return v + } else { + var zero WRITE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opwrite accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oprelease_lockowner() *RELEASE_LOCKOWNER4res { + switch u.Resop { + case OP_RELEASE_LOCKOWNER: + if v, ok := u.U.(*RELEASE_LOCKOWNER4res); ok { + return v + } else { + var zero RELEASE_LOCKOWNER4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oprelease_lockowner accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opcreatesession() *CREATE_SESSION4res { + switch u.Resop { + case OP_CREATE_SESSION: + if v, ok := u.U.(*CREATE_SESSION4res); ok { + return v + } else { + var zero CREATE_SESSION4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opcreatesession accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opdestroysession() *DESTROY_SESSION4res { + switch u.Resop { + case OP_DESTROY_SESSION: + if v, ok := u.U.(*DESTROY_SESSION4res); ok { + return v + } else { + var zero DESTROY_SESSION4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opdestroysession accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opfreestateid() *FREE_STATEID4res { + switch u.Resop { + case OP_FREE_STATEID: + if v, ok := u.U.(*FREE_STATEID4res); ok { + return v + } else { + var zero FREE_STATEID4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opfreestateid accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opgetdirdelegation() *GET_DIR_DELEGATION4res { + switch u.Resop { + case OP_GET_DIR_DELEGATION: + if v, ok := u.U.(*GET_DIR_DELEGATION4res); ok { + return v + } else { + var zero GET_DIR_DELEGATION4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opgetdirdelegation accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opgetdeviceinfo() *GETDEVICEINFO4res { + switch u.Resop { + case OP_GETDEVICEINFO: + if v, ok := u.U.(*GETDEVICEINFO4res); ok { + return v + } else { + var zero GETDEVICEINFO4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opgetdeviceinfo accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opgetdevicelist() *GETDEVICELIST4res { + switch u.Resop { + case OP_GETDEVICELIST: + if v, ok := u.U.(*GETDEVICELIST4res); ok { + return v + } else { + var zero GETDEVICELIST4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opgetdevicelist accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplayoutcommit() *LAYOUTCOMMIT4res { + switch u.Resop { + case OP_LAYOUTCOMMIT: + if v, ok := u.U.(*LAYOUTCOMMIT4res); ok { + return v + } else { + var zero LAYOUTCOMMIT4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplayoutcommit accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplayoutget() *LAYOUTGET4res { + switch u.Resop { + case OP_LAYOUTGET: + if v, ok := u.U.(*LAYOUTGET4res); ok { + return v + } else { + var zero LAYOUTGET4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplayoutget accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Oplayoutreturn() *LAYOUTRETURN4res { + switch u.Resop { + case OP_LAYOUTRETURN: + if v, ok := u.U.(*LAYOUTRETURN4res); ok { + return v + } else { + var zero LAYOUTRETURN4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Oplayoutreturn accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsecinfononame() *SECINFO_NO_NAME4res { + switch u.Resop { + case OP_SECINFO_NO_NAME: + if v, ok := u.U.(*SECINFO_NO_NAME4res); ok { + return v + } else { + var zero SECINFO_NO_NAME4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsecinfononame accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsequence() *SEQUENCE4res { + switch u.Resop { + case OP_SEQUENCE: + if v, ok := u.U.(*SEQUENCE4res); ok { + return v + } else { + var zero SEQUENCE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsequence accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opsetssv() *SET_SSV4res { + switch u.Resop { + case OP_SET_SSV: + if v, ok := u.U.(*SET_SSV4res); ok { + return v + } else { + var zero SET_SSV4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opsetssv accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opteststateid() *TEST_STATEID4res { + switch u.Resop { + case OP_TEST_STATEID: + if v, ok := u.U.(*TEST_STATEID4res); ok { + return v + } else { + var zero TEST_STATEID4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opteststateid accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opwantdelegation() *WANT_DELEGATION4res { + switch u.Resop { + case OP_WANT_DELEGATION: + if v, ok := u.U.(*WANT_DELEGATION4res); ok { + return v + } else { + var zero WANT_DELEGATION4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opwantdelegation accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opdestroyclientid() *DESTROY_CLIENTID4res { + switch u.Resop { + case OP_DESTROY_CLIENTID: + if v, ok := u.U.(*DESTROY_CLIENTID4res); ok { + return v + } else { + var zero DESTROY_CLIENTID4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opdestroyclientid accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opreclaimcomplete() *RECLAIM_COMPLETE4res { + switch u.Resop { + case OP_RECLAIM_COMPLETE: + if v, ok := u.U.(*RECLAIM_COMPLETE4res); ok { + return v + } else { + var zero RECLAIM_COMPLETE4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opreclaimcomplete accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_resop4) Opillegal() *ILLEGAL4res { + switch u.Resop { + case OP_ILLEGAL: + if v, ok := u.U.(*ILLEGAL4res); ok { + return v + } else { + var zero ILLEGAL4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_resop4.Opillegal accessed when Resop == %v", u.Resop) + return nil + } +} +func (u Nfs_resop4) XdrValid() bool { + switch u.Resop { + case OP_ACCESS,OP_CLOSE,OP_COMMIT,OP_CREATE,OP_DELEGPURGE,OP_DELEGRETURN,OP_GETATTR,OP_GETFH,OP_LINK,OP_LOCK,OP_LOCKT,OP_LOCKU,OP_LOOKUP,OP_LOOKUPP,OP_NVERIFY,OP_OPEN,OP_OPENATTR,OP_OPEN_CONFIRM,OP_OPEN_DOWNGRADE,OP_PUTFH,OP_PUTPUBFH,OP_PUTROOTFH,OP_READ,OP_READDIR,OP_READLINK,OP_REMOVE,OP_RENAME,OP_RENEW,OP_RESTOREFH,OP_SAVEFH,OP_SECINFO,OP_SETATTR,OP_SETCLIENTID,OP_SETCLIENTID_CONFIRM,OP_VERIFY,OP_WRITE,OP_RELEASE_LOCKOWNER,OP_CREATE_SESSION,OP_DESTROY_SESSION,OP_FREE_STATEID,OP_GET_DIR_DELEGATION,OP_GETDEVICEINFO,OP_GETDEVICELIST,OP_LAYOUTCOMMIT,OP_LAYOUTGET,OP_LAYOUTRETURN,OP_SECINFO_NO_NAME,OP_SEQUENCE,OP_SET_SSV,OP_TEST_STATEID,OP_WANT_DELEGATION,OP_DESTROY_CLIENTID,OP_RECLAIM_COMPLETE,OP_ILLEGAL: + return true + } + return false +} +func (u *Nfs_resop4) XdrUnionTag() XdrNum32 { + return XDR_Nfs_opnum4(&u.Resop) +} +func (u *Nfs_resop4) XdrUnionTagName() string { + return "Resop" +} +func (u *Nfs_resop4) XdrUnionBody() XdrType { + switch u.Resop { + case OP_ACCESS: + return XDR_ACCESS4res(u.Opaccess()) + case OP_CLOSE: + return XDR_CLOSE4res(u.Opclose()) + case OP_COMMIT: + return XDR_COMMIT4res(u.Opcommit()) + case OP_CREATE: + return XDR_CREATE4res(u.Opcreate()) + case OP_DELEGPURGE: + return XDR_DELEGPURGE4res(u.Opdelegpurge()) + case OP_DELEGRETURN: + return XDR_DELEGRETURN4res(u.Opdelegreturn()) + case OP_GETATTR: + return XDR_GETATTR4res(u.Opgetattr()) + case OP_GETFH: + return XDR_GETFH4res(u.Opgetfh()) + case OP_LINK: + return XDR_LINK4res(u.Oplink()) + case OP_LOCK: + return XDR_LOCK4res(u.Oplock()) + case OP_LOCKT: + return XDR_LOCKT4res(u.Oplockt()) + case OP_LOCKU: + return XDR_LOCKU4res(u.Oplocku()) + case OP_LOOKUP: + return XDR_LOOKUP4res(u.Oplookup()) + case OP_LOOKUPP: + return XDR_LOOKUPP4res(u.Oplookupp()) + case OP_NVERIFY: + return XDR_NVERIFY4res(u.Opnverify()) + case OP_OPEN: + return XDR_OPEN4res(u.Opopen()) + case OP_OPENATTR: + return XDR_OPENATTR4res(u.Opopenattr()) + case OP_OPEN_CONFIRM: + return XDR_OPEN_CONFIRM4res(u.Opopen_confirm()) + case OP_OPEN_DOWNGRADE: + return XDR_OPEN_DOWNGRADE4res(u.Opopen_downgrade()) + case OP_PUTFH: + return XDR_PUTFH4res(u.Opputfh()) + case OP_PUTPUBFH: + return XDR_PUTPUBFH4res(u.Opputpubfh()) + case OP_PUTROOTFH: + return XDR_PUTROOTFH4res(u.Opputrootfh()) + case OP_READ: + return XDR_READ4res(u.Opread()) + case OP_READDIR: + return XDR_READDIR4res(u.Opreaddir()) + case OP_READLINK: + return XDR_READLINK4res(u.Opreadlink()) + case OP_REMOVE: + return XDR_REMOVE4res(u.Opremove()) + case OP_RENAME: + return XDR_RENAME4res(u.Oprename()) + case OP_RENEW: + return XDR_RENEW4res(u.Oprenew()) + case OP_RESTOREFH: + return XDR_RESTOREFH4res(u.Oprestorefh()) + case OP_SAVEFH: + return XDR_SAVEFH4res(u.Opsavefh()) + case OP_SECINFO: + return XDR_SECINFO4res(u.Opsecinfo()) + case OP_SETATTR: + return XDR_SETATTR4res(u.Opsetattr()) + case OP_SETCLIENTID: + return XDR_SETCLIENTID4res(u.Opsetclientid()) + case OP_SETCLIENTID_CONFIRM: + return XDR_SETCLIENTID_CONFIRM4res(u.Opsetclientid_confirm()) + case OP_VERIFY: + return XDR_VERIFY4res(u.Opverify()) + case OP_WRITE: + return XDR_WRITE4res(u.Opwrite()) + case OP_RELEASE_LOCKOWNER: + return XDR_RELEASE_LOCKOWNER4res(u.Oprelease_lockowner()) + case OP_CREATE_SESSION: + return XDR_CREATE_SESSION4res(u.Opcreatesession()) + case OP_DESTROY_SESSION: + return XDR_DESTROY_SESSION4res(u.Opdestroysession()) + case OP_FREE_STATEID: + return XDR_FREE_STATEID4res(u.Opfreestateid()) + case OP_GET_DIR_DELEGATION: + return XDR_GET_DIR_DELEGATION4res(u.Opgetdirdelegation()) + case OP_GETDEVICEINFO: + return XDR_GETDEVICEINFO4res(u.Opgetdeviceinfo()) + case OP_GETDEVICELIST: + return XDR_GETDEVICELIST4res(u.Opgetdevicelist()) + case OP_LAYOUTCOMMIT: + return XDR_LAYOUTCOMMIT4res(u.Oplayoutcommit()) + case OP_LAYOUTGET: + return XDR_LAYOUTGET4res(u.Oplayoutget()) + case OP_LAYOUTRETURN: + return XDR_LAYOUTRETURN4res(u.Oplayoutreturn()) + case OP_SECINFO_NO_NAME: + return XDR_SECINFO_NO_NAME4res(u.Opsecinfononame()) + case OP_SEQUENCE: + return XDR_SEQUENCE4res(u.Opsequence()) + case OP_SET_SSV: + return XDR_SET_SSV4res(u.Opsetssv()) + case OP_TEST_STATEID: + return XDR_TEST_STATEID4res(u.Opteststateid()) + case OP_WANT_DELEGATION: + return XDR_WANT_DELEGATION4res(u.Opwantdelegation()) + case OP_DESTROY_CLIENTID: + return XDR_DESTROY_CLIENTID4res(u.Opdestroyclientid()) + case OP_RECLAIM_COMPLETE: + return XDR_RECLAIM_COMPLETE4res(u.Opreclaimcomplete()) + case OP_ILLEGAL: + return XDR_ILLEGAL4res(u.Opillegal()) + } + return nil +} +func (u *Nfs_resop4) XdrUnionBodyName() string { + switch u.Resop { + case OP_ACCESS: + return "Opaccess" + case OP_CLOSE: + return "Opclose" + case OP_COMMIT: + return "Opcommit" + case OP_CREATE: + return "Opcreate" + case OP_DELEGPURGE: + return "Opdelegpurge" + case OP_DELEGRETURN: + return "Opdelegreturn" + case OP_GETATTR: + return "Opgetattr" + case OP_GETFH: + return "Opgetfh" + case OP_LINK: + return "Oplink" + case OP_LOCK: + return "Oplock" + case OP_LOCKT: + return "Oplockt" + case OP_LOCKU: + return "Oplocku" + case OP_LOOKUP: + return "Oplookup" + case OP_LOOKUPP: + return "Oplookupp" + case OP_NVERIFY: + return "Opnverify" + case OP_OPEN: + return "Opopen" + case OP_OPENATTR: + return "Opopenattr" + case OP_OPEN_CONFIRM: + return "Opopen_confirm" + case OP_OPEN_DOWNGRADE: + return "Opopen_downgrade" + case OP_PUTFH: + return "Opputfh" + case OP_PUTPUBFH: + return "Opputpubfh" + case OP_PUTROOTFH: + return "Opputrootfh" + case OP_READ: + return "Opread" + case OP_READDIR: + return "Opreaddir" + case OP_READLINK: + return "Opreadlink" + case OP_REMOVE: + return "Opremove" + case OP_RENAME: + return "Oprename" + case OP_RENEW: + return "Oprenew" + case OP_RESTOREFH: + return "Oprestorefh" + case OP_SAVEFH: + return "Opsavefh" + case OP_SECINFO: + return "Opsecinfo" + case OP_SETATTR: + return "Opsetattr" + case OP_SETCLIENTID: + return "Opsetclientid" + case OP_SETCLIENTID_CONFIRM: + return "Opsetclientid_confirm" + case OP_VERIFY: + return "Opverify" + case OP_WRITE: + return "Opwrite" + case OP_RELEASE_LOCKOWNER: + return "Oprelease_lockowner" + case OP_CREATE_SESSION: + return "Opcreatesession" + case OP_DESTROY_SESSION: + return "Opdestroysession" + case OP_FREE_STATEID: + return "Opfreestateid" + case OP_GET_DIR_DELEGATION: + return "Opgetdirdelegation" + case OP_GETDEVICEINFO: + return "Opgetdeviceinfo" + case OP_GETDEVICELIST: + return "Opgetdevicelist" + case OP_LAYOUTCOMMIT: + return "Oplayoutcommit" + case OP_LAYOUTGET: + return "Oplayoutget" + case OP_LAYOUTRETURN: + return "Oplayoutreturn" + case OP_SECINFO_NO_NAME: + return "Opsecinfononame" + case OP_SEQUENCE: + return "Opsequence" + case OP_SET_SSV: + return "Opsetssv" + case OP_TEST_STATEID: + return "Opteststateid" + case OP_WANT_DELEGATION: + return "Opwantdelegation" + case OP_DESTROY_CLIENTID: + return "Opdestroyclientid" + case OP_RECLAIM_COMPLETE: + return "Opreclaimcomplete" + case OP_ILLEGAL: + return "Opillegal" + } + return "" +} +type XdrType_Nfs_resop4 = *Nfs_resop4 +func (v *Nfs_resop4) XdrPointer() interface{} { return v } +func (Nfs_resop4) XdrTypeName() string { return "Nfs_resop4" } +func (v Nfs_resop4) XdrValue() interface{} { return v } +func (v *Nfs_resop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Nfs_resop4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfs_opnum4(&u.Resop).XdrMarshal(x, x.Sprintf("%sresop", name)) + switch u.Resop { + case OP_ACCESS: + x.Marshal(x.Sprintf("%sopaccess", name), XDR_ACCESS4res(u.Opaccess())) + return + case OP_CLOSE: + x.Marshal(x.Sprintf("%sopclose", name), XDR_CLOSE4res(u.Opclose())) + return + case OP_COMMIT: + x.Marshal(x.Sprintf("%sopcommit", name), XDR_COMMIT4res(u.Opcommit())) + return + case OP_CREATE: + x.Marshal(x.Sprintf("%sopcreate", name), XDR_CREATE4res(u.Opcreate())) + return + case OP_DELEGPURGE: + x.Marshal(x.Sprintf("%sopdelegpurge", name), XDR_DELEGPURGE4res(u.Opdelegpurge())) + return + case OP_DELEGRETURN: + x.Marshal(x.Sprintf("%sopdelegreturn", name), XDR_DELEGRETURN4res(u.Opdelegreturn())) + return + case OP_GETATTR: + x.Marshal(x.Sprintf("%sopgetattr", name), XDR_GETATTR4res(u.Opgetattr())) + return + case OP_GETFH: + x.Marshal(x.Sprintf("%sopgetfh", name), XDR_GETFH4res(u.Opgetfh())) + return + case OP_LINK: + x.Marshal(x.Sprintf("%soplink", name), XDR_LINK4res(u.Oplink())) + return + case OP_LOCK: + x.Marshal(x.Sprintf("%soplock", name), XDR_LOCK4res(u.Oplock())) + return + case OP_LOCKT: + x.Marshal(x.Sprintf("%soplockt", name), XDR_LOCKT4res(u.Oplockt())) + return + case OP_LOCKU: + x.Marshal(x.Sprintf("%soplocku", name), XDR_LOCKU4res(u.Oplocku())) + return + case OP_LOOKUP: + x.Marshal(x.Sprintf("%soplookup", name), XDR_LOOKUP4res(u.Oplookup())) + return + case OP_LOOKUPP: + x.Marshal(x.Sprintf("%soplookupp", name), XDR_LOOKUPP4res(u.Oplookupp())) + return + case OP_NVERIFY: + x.Marshal(x.Sprintf("%sopnverify", name), XDR_NVERIFY4res(u.Opnverify())) + return + case OP_OPEN: + x.Marshal(x.Sprintf("%sopopen", name), XDR_OPEN4res(u.Opopen())) + return + case OP_OPENATTR: + x.Marshal(x.Sprintf("%sopopenattr", name), XDR_OPENATTR4res(u.Opopenattr())) + return + case OP_OPEN_CONFIRM: + x.Marshal(x.Sprintf("%sopopen_confirm", name), XDR_OPEN_CONFIRM4res(u.Opopen_confirm())) + return + case OP_OPEN_DOWNGRADE: + x.Marshal(x.Sprintf("%sopopen_downgrade", name), XDR_OPEN_DOWNGRADE4res(u.Opopen_downgrade())) + return + case OP_PUTFH: + x.Marshal(x.Sprintf("%sopputfh", name), XDR_PUTFH4res(u.Opputfh())) + return + case OP_PUTPUBFH: + x.Marshal(x.Sprintf("%sopputpubfh", name), XDR_PUTPUBFH4res(u.Opputpubfh())) + return + case OP_PUTROOTFH: + x.Marshal(x.Sprintf("%sopputrootfh", name), XDR_PUTROOTFH4res(u.Opputrootfh())) + return + case OP_READ: + x.Marshal(x.Sprintf("%sopread", name), XDR_READ4res(u.Opread())) + return + case OP_READDIR: + x.Marshal(x.Sprintf("%sopreaddir", name), XDR_READDIR4res(u.Opreaddir())) + return + case OP_READLINK: + x.Marshal(x.Sprintf("%sopreadlink", name), XDR_READLINK4res(u.Opreadlink())) + return + case OP_REMOVE: + x.Marshal(x.Sprintf("%sopremove", name), XDR_REMOVE4res(u.Opremove())) + return + case OP_RENAME: + x.Marshal(x.Sprintf("%soprename", name), XDR_RENAME4res(u.Oprename())) + return + case OP_RENEW: + x.Marshal(x.Sprintf("%soprenew", name), XDR_RENEW4res(u.Oprenew())) + return + case OP_RESTOREFH: + x.Marshal(x.Sprintf("%soprestorefh", name), XDR_RESTOREFH4res(u.Oprestorefh())) + return + case OP_SAVEFH: + x.Marshal(x.Sprintf("%sopsavefh", name), XDR_SAVEFH4res(u.Opsavefh())) + return + case OP_SECINFO: + x.Marshal(x.Sprintf("%sopsecinfo", name), XDR_SECINFO4res(u.Opsecinfo())) + return + case OP_SETATTR: + x.Marshal(x.Sprintf("%sopsetattr", name), XDR_SETATTR4res(u.Opsetattr())) + return + case OP_SETCLIENTID: + x.Marshal(x.Sprintf("%sopsetclientid", name), XDR_SETCLIENTID4res(u.Opsetclientid())) + return + case OP_SETCLIENTID_CONFIRM: + x.Marshal(x.Sprintf("%sopsetclientid_confirm", name), XDR_SETCLIENTID_CONFIRM4res(u.Opsetclientid_confirm())) + return + case OP_VERIFY: + x.Marshal(x.Sprintf("%sopverify", name), XDR_VERIFY4res(u.Opverify())) + return + case OP_WRITE: + x.Marshal(x.Sprintf("%sopwrite", name), XDR_WRITE4res(u.Opwrite())) + return + case OP_RELEASE_LOCKOWNER: + x.Marshal(x.Sprintf("%soprelease_lockowner", name), XDR_RELEASE_LOCKOWNER4res(u.Oprelease_lockowner())) + return + case OP_CREATE_SESSION: + x.Marshal(x.Sprintf("%sopcreatesession", name), XDR_CREATE_SESSION4res(u.Opcreatesession())) + return + case OP_DESTROY_SESSION: + x.Marshal(x.Sprintf("%sopdestroysession", name), XDR_DESTROY_SESSION4res(u.Opdestroysession())) + return + case OP_FREE_STATEID: + x.Marshal(x.Sprintf("%sopfreestateid", name), XDR_FREE_STATEID4res(u.Opfreestateid())) + return + case OP_GET_DIR_DELEGATION: + x.Marshal(x.Sprintf("%sopgetdirdelegation", name), XDR_GET_DIR_DELEGATION4res(u.Opgetdirdelegation())) + return + case OP_GETDEVICEINFO: + x.Marshal(x.Sprintf("%sopgetdeviceinfo", name), XDR_GETDEVICEINFO4res(u.Opgetdeviceinfo())) + return + case OP_GETDEVICELIST: + x.Marshal(x.Sprintf("%sopgetdevicelist", name), XDR_GETDEVICELIST4res(u.Opgetdevicelist())) + return + case OP_LAYOUTCOMMIT: + x.Marshal(x.Sprintf("%soplayoutcommit", name), XDR_LAYOUTCOMMIT4res(u.Oplayoutcommit())) + return + case OP_LAYOUTGET: + x.Marshal(x.Sprintf("%soplayoutget", name), XDR_LAYOUTGET4res(u.Oplayoutget())) + return + case OP_LAYOUTRETURN: + x.Marshal(x.Sprintf("%soplayoutreturn", name), XDR_LAYOUTRETURN4res(u.Oplayoutreturn())) + return + case OP_SECINFO_NO_NAME: + x.Marshal(x.Sprintf("%sopsecinfononame", name), XDR_SECINFO_NO_NAME4res(u.Opsecinfononame())) + return + case OP_SEQUENCE: + x.Marshal(x.Sprintf("%sopsequence", name), XDR_SEQUENCE4res(u.Opsequence())) + return + case OP_SET_SSV: + x.Marshal(x.Sprintf("%sopsetssv", name), XDR_SET_SSV4res(u.Opsetssv())) + return + case OP_TEST_STATEID: + x.Marshal(x.Sprintf("%sopteststateid", name), XDR_TEST_STATEID4res(u.Opteststateid())) + return + case OP_WANT_DELEGATION: + x.Marshal(x.Sprintf("%sopwantdelegation", name), XDR_WANT_DELEGATION4res(u.Opwantdelegation())) + return + case OP_DESTROY_CLIENTID: + x.Marshal(x.Sprintf("%sopdestroyclientid", name), XDR_DESTROY_CLIENTID4res(u.Opdestroyclientid())) + return + case OP_RECLAIM_COMPLETE: + x.Marshal(x.Sprintf("%sopreclaimcomplete", name), XDR_RECLAIM_COMPLETE4res(u.Opreclaimcomplete())) + return + case OP_ILLEGAL: + x.Marshal(x.Sprintf("%sopillegal", name), XDR_ILLEGAL4res(u.Opillegal())) + return + } + XdrPanic("invalid Resop (%v) in Nfs_resop4", u.Resop) +} +func (v *Nfs_resop4) XdrInitialize() { + var zero Nfs_opnum4 + switch zero { + case OP_ACCESS, OP_CLOSE, OP_COMMIT, OP_CREATE, OP_DELEGPURGE, OP_DELEGRETURN, OP_GETATTR, OP_GETFH, OP_LINK, OP_LOCK, OP_LOCKT, OP_LOCKU, OP_LOOKUP, OP_LOOKUPP, OP_NVERIFY, OP_OPEN, OP_OPENATTR, OP_OPEN_CONFIRM, OP_OPEN_DOWNGRADE, OP_PUTFH, OP_PUTPUBFH, OP_PUTROOTFH, OP_READ, OP_READDIR, OP_READLINK, OP_REMOVE, OP_RENAME, OP_RENEW, OP_RESTOREFH, OP_SAVEFH, OP_SECINFO, OP_SETATTR, OP_SETCLIENTID, OP_SETCLIENTID_CONFIRM, OP_VERIFY, OP_WRITE, OP_RELEASE_LOCKOWNER, OP_CREATE_SESSION, OP_DESTROY_SESSION, OP_FREE_STATEID, OP_GET_DIR_DELEGATION, OP_GETDEVICEINFO, OP_GETDEVICELIST, OP_LAYOUTCOMMIT, OP_LAYOUTGET, OP_LAYOUTRETURN, OP_SECINFO_NO_NAME, OP_SEQUENCE, OP_SET_SSV, OP_TEST_STATEID, OP_WANT_DELEGATION, OP_DESTROY_CLIENTID, OP_RECLAIM_COMPLETE, OP_ILLEGAL: + default: + if v.Resop == zero { v.Resop = OP_ACCESS } + } +} +func XDR_Nfs_resop4(v *Nfs_resop4) *Nfs_resop4 { return v} +type _XdrVec_unbounded_Nfs_argop4 []Nfs_argop4 +func (_XdrVec_unbounded_Nfs_argop4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Nfs_argop4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Nfs_argop4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Nfs_argop4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Nfs_argop4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Nfs_argop4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Nfs_argop4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Nfs_argop4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Nfs_argop4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Nfs_argop4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Nfs_argop4) XdrTypeName() string { return "Nfs_argop4<>" } +func (v *_XdrVec_unbounded_Nfs_argop4) XdrPointer() interface{} { return (*[]Nfs_argop4)(v) } +func (v _XdrVec_unbounded_Nfs_argop4) XdrValue() interface{} { return ([]Nfs_argop4)(v) } +func (v *_XdrVec_unbounded_Nfs_argop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_COMPOUND4args = *COMPOUND4args +func (v *COMPOUND4args) XdrPointer() interface{} { return v } +func (COMPOUND4args) XdrTypeName() string { return "COMPOUND4args" } +func (v COMPOUND4args) XdrValue() interface{} { return v } +func (v *COMPOUND4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *COMPOUND4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%stag", name), XDR_Utf8str_cs(&v.Tag)) + x.Marshal(x.Sprintf("%sminorversion", name), XDR_Uint32_t(&v.Minorversion)) + x.Marshal(x.Sprintf("%sargarray", name), (*_XdrVec_unbounded_Nfs_argop4)(&v.Argarray)) +} +func XDR_COMPOUND4args(v *COMPOUND4args) *COMPOUND4args { return v } +type _XdrVec_unbounded_Nfs_resop4 []Nfs_resop4 +func (_XdrVec_unbounded_Nfs_resop4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Nfs_resop4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Nfs_resop4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Nfs_resop4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Nfs_resop4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Nfs_resop4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Nfs_resop4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Nfs_resop4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Nfs_resop4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Nfs_resop4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Nfs_resop4) XdrTypeName() string { return "Nfs_resop4<>" } +func (v *_XdrVec_unbounded_Nfs_resop4) XdrPointer() interface{} { return (*[]Nfs_resop4)(v) } +func (v _XdrVec_unbounded_Nfs_resop4) XdrValue() interface{} { return ([]Nfs_resop4)(v) } +func (v *_XdrVec_unbounded_Nfs_resop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_COMPOUND4res = *COMPOUND4res +func (v *COMPOUND4res) XdrPointer() interface{} { return v } +func (COMPOUND4res) XdrTypeName() string { return "COMPOUND4res" } +func (v COMPOUND4res) XdrValue() interface{} { return v } +func (v *COMPOUND4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *COMPOUND4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) + x.Marshal(x.Sprintf("%stag", name), XDR_Utf8str_cs(&v.Tag)) + x.Marshal(x.Sprintf("%sresarray", name), (*_XdrVec_unbounded_Nfs_resop4)(&v.Resarray)) +} +func XDR_COMPOUND4res(v *COMPOUND4res) *COMPOUND4res { return v } + +type XdrProc_NFSPROC4_NULL struct { + Arg *XdrVoid + Res *XdrVoid +} +func (XdrProc_NFSPROC4_NULL) Prog() uint32 { return 100003 } +func (XdrProc_NFSPROC4_NULL) Vers() uint32 { return 4 } +func (XdrProc_NFSPROC4_NULL) Proc() uint32 { return 0 } +func (XdrProc_NFSPROC4_NULL) ProgName() string { return "NFS4_PROGRAM" } +func (XdrProc_NFSPROC4_NULL) VersName() string { return "NFS_V4" } +func (XdrProc_NFSPROC4_NULL) ProcName() string { return "NFSPROC4_NULL" } +func (p *XdrProc_NFSPROC4_NULL) GetArg() XdrType { + if p.Arg == nil { + p.Arg = new(XdrVoid) + } + return XDR_XdrVoid(p.Arg) +} +func (p *XdrProc_NFSPROC4_NULL) GetRes() XdrType { + if p.Res == nil { + p.Res = new(XdrVoid) + } + return XDR_XdrVoid(p.Res) +} +var _ XdrProc = &XdrProc_NFSPROC4_NULL{} // XXX + +type xdrSrvProc_NFSPROC4_NULL struct { + XdrProc_NFSPROC4_NULL + Srv NFS_V4 +} +func (p *xdrSrvProc_NFSPROC4_NULL) SetContext(ctx context.Context) { + if wc, ok := p.Srv.(interface { + WithContext(context.Context) NFS_V4 + }); ok { + p.Srv = wc.WithContext(ctx) + } +} +func (p *xdrSrvProc_NFSPROC4_NULL) Do() { + p.Srv.NFSPROC4_NULL() +} +var _ XdrSrvProc = &xdrSrvProc_NFSPROC4_NULL{} // XXX + +type XdrProc_NFSPROC4_COMPOUND struct { + Arg *COMPOUND4args + Res *COMPOUND4res +} +func (XdrProc_NFSPROC4_COMPOUND) Prog() uint32 { return 100003 } +func (XdrProc_NFSPROC4_COMPOUND) Vers() uint32 { return 4 } +func (XdrProc_NFSPROC4_COMPOUND) Proc() uint32 { return 1 } +func (XdrProc_NFSPROC4_COMPOUND) ProgName() string { return "NFS4_PROGRAM" } +func (XdrProc_NFSPROC4_COMPOUND) VersName() string { return "NFS_V4" } +func (XdrProc_NFSPROC4_COMPOUND) ProcName() string { return "NFSPROC4_COMPOUND" } +func (p *XdrProc_NFSPROC4_COMPOUND) GetArg() XdrType { + if p.Arg == nil { + p.Arg = new(COMPOUND4args) + } + return XDR_COMPOUND4args(p.Arg) +} +func (p *XdrProc_NFSPROC4_COMPOUND) GetRes() XdrType { + if p.Res == nil { + p.Res = new(COMPOUND4res) + } + return XDR_COMPOUND4res(p.Res) +} +var _ XdrProc = &XdrProc_NFSPROC4_COMPOUND{} // XXX + +type xdrSrvProc_NFSPROC4_COMPOUND struct { + XdrProc_NFSPROC4_COMPOUND + Srv NFS_V4 +} +func (p *xdrSrvProc_NFSPROC4_COMPOUND) SetContext(ctx context.Context) { + if wc, ok := p.Srv.(interface { + WithContext(context.Context) NFS_V4 + }); ok { + p.Srv = wc.WithContext(ctx) + } +} +func (p *xdrSrvProc_NFSPROC4_COMPOUND) Do() { + r := p.Srv.NFSPROC4_COMPOUND(*p.Arg) + p.Res = &r + +} +var _ XdrSrvProc = &xdrSrvProc_NFSPROC4_COMPOUND{} // XXX + +func init() { + XdrCatalog[100003<<32|4] = func(p uint32) XdrProc { + switch(p) { + case 0: + return &XdrProc_NFSPROC4_NULL{} + case 1: + return &XdrProc_NFSPROC4_COMPOUND{} + } + return nil + } +} + +type NFS_V4_Server struct { + Srv NFS_V4 +} +func (NFS_V4_Server) Prog() uint32 { return 100003 } +func (NFS_V4_Server) Vers() uint32 { return 4 } +func (NFS_V4_Server) ProgName() string { return "NFS4_PROGRAM" } +func (NFS_V4_Server) VersName() string { return "NFS_V4" } +func (s NFS_V4_Server) GetProc(p uint32) XdrSrvProc { + switch p { + case 0: // NFSPROC4_NULL + return &xdrSrvProc_NFSPROC4_NULL{ Srv: s.Srv } + case 1: // NFSPROC4_COMPOUND + return &xdrSrvProc_NFSPROC4_COMPOUND{ Srv: s.Srv } + default: + return nil + } +} +var _ XdrSrv = NFS_V4_Server{} // XXX + +type NFS_V4_Client struct { + Send XdrSendCall + Ctx context.Context +} +var _ NFS_V4 = NFS_V4_Client{} // XXX +func (c NFS_V4_Client) WithContext(ctx context.Context) NFS_V4 { + c.Ctx = ctx + return c +} +func (c NFS_V4_Client) NFSPROC4_NULL() { + var proc XdrProc_NFSPROC4_NULL + if err := c.Send.SendCall(c.Ctx, &proc); err != nil { + panic(err) + } +} +func (c NFS_V4_Client) NFSPROC4_COMPOUND(a1 COMPOUND4args) COMPOUND4res { + var proc XdrProc_NFSPROC4_COMPOUND + proc.Arg = &a1 + if err := c.Send.SendCall(c.Ctx, &proc); err != nil { + panic(err) + } + return *proc.Res +} +type XdrType_CB_GETATTR4args = *CB_GETATTR4args +func (v *CB_GETATTR4args) XdrPointer() interface{} { return v } +func (CB_GETATTR4args) XdrTypeName() string { return "CB_GETATTR4args" } +func (v CB_GETATTR4args) XdrValue() interface{} { return v } +func (v *CB_GETATTR4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_GETATTR4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sfh", name), XDR_Nfs_fh4(&v.Fh)) + x.Marshal(x.Sprintf("%sattr_request", name), XDR_Bitmap4(&v.Attr_request)) +} +func XDR_CB_GETATTR4args(v *CB_GETATTR4args) *CB_GETATTR4args { return v } +type XdrType_CB_GETATTR4resok = *CB_GETATTR4resok +func (v *CB_GETATTR4resok) XdrPointer() interface{} { return v } +func (CB_GETATTR4resok) XdrTypeName() string { return "CB_GETATTR4resok" } +func (v CB_GETATTR4resok) XdrValue() interface{} { return v } +func (v *CB_GETATTR4resok) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_GETATTR4resok) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sobj_attributes", name), XDR_Fattr4(&v.Obj_attributes)) +} +func XDR_CB_GETATTR4resok(v *CB_GETATTR4resok) *CB_GETATTR4resok { return v } +func (u *CB_GETATTR4res) Resok4() *CB_GETATTR4resok { + switch u.Status { + case NFS4_OK: + if v, ok := u.U.(*CB_GETATTR4resok); ok { + return v + } else { + var zero CB_GETATTR4resok + u.U = &zero + return &zero + } + default: + XdrPanic("CB_GETATTR4res.Resok4 accessed when Status == %v", u.Status) + return nil + } +} +func (u CB_GETATTR4res) XdrValid() bool { + return true +} +func (u *CB_GETATTR4res) XdrUnionTag() XdrNum32 { + return XDR_Nfsstat4(&u.Status) +} +func (u *CB_GETATTR4res) XdrUnionTagName() string { + return "Status" +} +func (u *CB_GETATTR4res) XdrUnionBody() XdrType { + switch u.Status { + case NFS4_OK: + return XDR_CB_GETATTR4resok(u.Resok4()) + default: + return nil + } +} +func (u *CB_GETATTR4res) XdrUnionBodyName() string { + switch u.Status { + case NFS4_OK: + return "Resok4" + default: + return "" + } +} +type XdrType_CB_GETATTR4res = *CB_GETATTR4res +func (v *CB_GETATTR4res) XdrPointer() interface{} { return v } +func (CB_GETATTR4res) XdrTypeName() string { return "CB_GETATTR4res" } +func (v CB_GETATTR4res) XdrValue() interface{} { return v } +func (v *CB_GETATTR4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *CB_GETATTR4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Nfsstat4(&u.Status).XdrMarshal(x, x.Sprintf("%sstatus", name)) + switch u.Status { + case NFS4_OK: + x.Marshal(x.Sprintf("%sresok4", name), XDR_CB_GETATTR4resok(u.Resok4())) + return + default: + return + } +} +func XDR_CB_GETATTR4res(v *CB_GETATTR4res) *CB_GETATTR4res { return v} +type XdrType_CB_RECALL4args = *CB_RECALL4args +func (v *CB_RECALL4args) XdrPointer() interface{} { return v } +func (CB_RECALL4args) XdrTypeName() string { return "CB_RECALL4args" } +func (v CB_RECALL4args) XdrValue() interface{} { return v } +func (v *CB_RECALL4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_RECALL4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstateid", name), XDR_Stateid4(&v.Stateid)) + x.Marshal(x.Sprintf("%struncate", name), XDR_bool(&v.Truncate)) + x.Marshal(x.Sprintf("%sfh", name), XDR_Nfs_fh4(&v.Fh)) +} +func XDR_CB_RECALL4args(v *CB_RECALL4args) *CB_RECALL4args { return v } +type XdrType_CB_RECALL4res = *CB_RECALL4res +func (v *CB_RECALL4res) XdrPointer() interface{} { return v } +func (CB_RECALL4res) XdrTypeName() string { return "CB_RECALL4res" } +func (v CB_RECALL4res) XdrValue() interface{} { return v } +func (v *CB_RECALL4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_RECALL4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_CB_RECALL4res(v *CB_RECALL4res) *CB_RECALL4res { return v } +type XdrType_CB_ILLEGAL4res = *CB_ILLEGAL4res +func (v *CB_ILLEGAL4res) XdrPointer() interface{} { return v } +func (CB_ILLEGAL4res) XdrTypeName() string { return "CB_ILLEGAL4res" } +func (v CB_ILLEGAL4res) XdrValue() interface{} { return v } +func (v *CB_ILLEGAL4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_ILLEGAL4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) +} +func XDR_CB_ILLEGAL4res(v *CB_ILLEGAL4res) *CB_ILLEGAL4res { return v } +var _XdrNames_Nfs_cb_opnum4 = map[int32]string{ + int32(OP_CB_GETATTR): "OP_CB_GETATTR", + int32(OP_CB_RECALL): "OP_CB_RECALL", + int32(OP_CB_ILLEGAL): "OP_CB_ILLEGAL", +} +var _XdrValues_Nfs_cb_opnum4 = map[string]int32{ + "OP_CB_GETATTR": int32(OP_CB_GETATTR), + "OP_CB_RECALL": int32(OP_CB_RECALL), + "OP_CB_ILLEGAL": int32(OP_CB_ILLEGAL), +} +func (Nfs_cb_opnum4) XdrEnumNames() map[int32]string { + return _XdrNames_Nfs_cb_opnum4 +} +func (v Nfs_cb_opnum4) String() string { + if s, ok := _XdrNames_Nfs_cb_opnum4[int32(v)]; ok { + return s + } + return fmt.Sprintf("Nfs_cb_opnum4#%d", v) +} +func (v *Nfs_cb_opnum4) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Nfs_cb_opnum4[stok]; ok { + *v = Nfs_cb_opnum4(val) + return nil + } else if stok == "Nfs_cb_opnum4" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Nfs_cb_opnum4.", stok)) + } +} +func (v Nfs_cb_opnum4) GetU32() uint32 { return uint32(v) } +func (v *Nfs_cb_opnum4) SetU32(n uint32) { *v = Nfs_cb_opnum4(n) } +func (v *Nfs_cb_opnum4) XdrPointer() interface{} { return v } +func (Nfs_cb_opnum4) XdrTypeName() string { return "Nfs_cb_opnum4" } +func (v Nfs_cb_opnum4) XdrValue() interface{} { return v } +func (v *Nfs_cb_opnum4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Nfs_cb_opnum4 = *Nfs_cb_opnum4 +func XDR_Nfs_cb_opnum4(v *Nfs_cb_opnum4) *Nfs_cb_opnum4 { return v } +func (v *Nfs_cb_opnum4) XdrInitialize() { + switch Nfs_cb_opnum4(0) { + case OP_CB_GETATTR, OP_CB_RECALL, OP_CB_ILLEGAL: + default: + if *v == Nfs_cb_opnum4(0) { *v = OP_CB_GETATTR } + } +} +var _XdrTags_Nfs_cb_argop4 = map[int32]bool{ + XdrToI32(OP_CB_GETATTR): true, + XdrToI32(OP_CB_RECALL): true, + XdrToI32(OP_CB_ILLEGAL): true, +} +func (_ Nfs_cb_argop4) XdrValidTags() map[int32]bool { + return _XdrTags_Nfs_cb_argop4 +} +func (u *Nfs_cb_argop4) Opcbgetattr() *CB_GETATTR4args { + switch Nfs_cb_opnum4(u.Argop) { + case OP_CB_GETATTR: + if v, ok := u.U.(*CB_GETATTR4args); ok { + return v + } else { + var zero CB_GETATTR4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_cb_argop4.Opcbgetattr accessed when Argop == %v", u.Argop) + return nil + } +} +func (u *Nfs_cb_argop4) Opcbrecall() *CB_RECALL4args { + switch Nfs_cb_opnum4(u.Argop) { + case OP_CB_RECALL: + if v, ok := u.U.(*CB_RECALL4args); ok { + return v + } else { + var zero CB_RECALL4args + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_cb_argop4.Opcbrecall accessed when Argop == %v", u.Argop) + return nil + } +} +func (u Nfs_cb_argop4) XdrValid() bool { + switch Nfs_cb_opnum4(u.Argop) { + case OP_CB_GETATTR,OP_CB_RECALL,OP_CB_ILLEGAL: + return true + } + return false +} +func (u *Nfs_cb_argop4) XdrUnionTag() XdrNum32 { + return XDR_uint32(&u.Argop) +} +func (u *Nfs_cb_argop4) XdrUnionTagName() string { + return "Argop" +} +func (u *Nfs_cb_argop4) XdrUnionBody() XdrType { + switch Nfs_cb_opnum4(u.Argop) { + case OP_CB_GETATTR: + return XDR_CB_GETATTR4args(u.Opcbgetattr()) + case OP_CB_RECALL: + return XDR_CB_RECALL4args(u.Opcbrecall()) + case OP_CB_ILLEGAL: + return nil + } + return nil +} +func (u *Nfs_cb_argop4) XdrUnionBodyName() string { + switch Nfs_cb_opnum4(u.Argop) { + case OP_CB_GETATTR: + return "Opcbgetattr" + case OP_CB_RECALL: + return "Opcbrecall" + case OP_CB_ILLEGAL: + return "" + } + return "" +} +type XdrType_Nfs_cb_argop4 = *Nfs_cb_argop4 +func (v *Nfs_cb_argop4) XdrPointer() interface{} { return v } +func (Nfs_cb_argop4) XdrTypeName() string { return "Nfs_cb_argop4" } +func (v Nfs_cb_argop4) XdrValue() interface{} { return v } +func (v *Nfs_cb_argop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Nfs_cb_argop4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_uint32(&u.Argop).XdrMarshal(x, x.Sprintf("%sargop", name)) + switch Nfs_cb_opnum4(u.Argop) { + case OP_CB_GETATTR: + x.Marshal(x.Sprintf("%sopcbgetattr", name), XDR_CB_GETATTR4args(u.Opcbgetattr())) + return + case OP_CB_RECALL: + x.Marshal(x.Sprintf("%sopcbrecall", name), XDR_CB_RECALL4args(u.Opcbrecall())) + return + case OP_CB_ILLEGAL: + return + } + XdrPanic("invalid Argop (%v) in Nfs_cb_argop4", u.Argop) +} +func (v *Nfs_cb_argop4) XdrInitialize() { + var zero uint32 + switch Nfs_cb_opnum4(zero) { + case OP_CB_GETATTR, OP_CB_RECALL, OP_CB_ILLEGAL: + default: + if v.Argop == zero { v.Argop = uint32(OP_CB_GETATTR) } + } +} +func XDR_Nfs_cb_argop4(v *Nfs_cb_argop4) *Nfs_cb_argop4 { return v} +var _XdrTags_Nfs_cb_resop4 = map[int32]bool{ + XdrToI32(OP_CB_GETATTR): true, + XdrToI32(OP_CB_RECALL): true, + XdrToI32(OP_CB_ILLEGAL): true, +} +func (_ Nfs_cb_resop4) XdrValidTags() map[int32]bool { + return _XdrTags_Nfs_cb_resop4 +} +func (u *Nfs_cb_resop4) Opcbgetattr() *CB_GETATTR4res { + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_GETATTR: + if v, ok := u.U.(*CB_GETATTR4res); ok { + return v + } else { + var zero CB_GETATTR4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_cb_resop4.Opcbgetattr accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_cb_resop4) Opcbrecall() *CB_RECALL4res { + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_RECALL: + if v, ok := u.U.(*CB_RECALL4res); ok { + return v + } else { + var zero CB_RECALL4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_cb_resop4.Opcbrecall accessed when Resop == %v", u.Resop) + return nil + } +} +func (u *Nfs_cb_resop4) Opcbillegal() *CB_ILLEGAL4res { + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_ILLEGAL: + if v, ok := u.U.(*CB_ILLEGAL4res); ok { + return v + } else { + var zero CB_ILLEGAL4res + u.U = &zero + return &zero + } + default: + XdrPanic("Nfs_cb_resop4.Opcbillegal accessed when Resop == %v", u.Resop) + return nil + } +} +func (u Nfs_cb_resop4) XdrValid() bool { + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_GETATTR,OP_CB_RECALL,OP_CB_ILLEGAL: + return true + } + return false +} +func (u *Nfs_cb_resop4) XdrUnionTag() XdrNum32 { + return XDR_uint32(&u.Resop) +} +func (u *Nfs_cb_resop4) XdrUnionTagName() string { + return "Resop" +} +func (u *Nfs_cb_resop4) XdrUnionBody() XdrType { + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_GETATTR: + return XDR_CB_GETATTR4res(u.Opcbgetattr()) + case OP_CB_RECALL: + return XDR_CB_RECALL4res(u.Opcbrecall()) + case OP_CB_ILLEGAL: + return XDR_CB_ILLEGAL4res(u.Opcbillegal()) + } + return nil +} +func (u *Nfs_cb_resop4) XdrUnionBodyName() string { + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_GETATTR: + return "Opcbgetattr" + case OP_CB_RECALL: + return "Opcbrecall" + case OP_CB_ILLEGAL: + return "Opcbillegal" + } + return "" +} +type XdrType_Nfs_cb_resop4 = *Nfs_cb_resop4 +func (v *Nfs_cb_resop4) XdrPointer() interface{} { return v } +func (Nfs_cb_resop4) XdrTypeName() string { return "Nfs_cb_resop4" } +func (v Nfs_cb_resop4) XdrValue() interface{} { return v } +func (v *Nfs_cb_resop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Nfs_cb_resop4) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_uint32(&u.Resop).XdrMarshal(x, x.Sprintf("%sresop", name)) + switch Nfs_cb_opnum4(u.Resop) { + case OP_CB_GETATTR: + x.Marshal(x.Sprintf("%sopcbgetattr", name), XDR_CB_GETATTR4res(u.Opcbgetattr())) + return + case OP_CB_RECALL: + x.Marshal(x.Sprintf("%sopcbrecall", name), XDR_CB_RECALL4res(u.Opcbrecall())) + return + case OP_CB_ILLEGAL: + x.Marshal(x.Sprintf("%sopcbillegal", name), XDR_CB_ILLEGAL4res(u.Opcbillegal())) + return + } + XdrPanic("invalid Resop (%v) in Nfs_cb_resop4", u.Resop) +} +func (v *Nfs_cb_resop4) XdrInitialize() { + var zero uint32 + switch Nfs_cb_opnum4(zero) { + case OP_CB_GETATTR, OP_CB_RECALL, OP_CB_ILLEGAL: + default: + if v.Resop == zero { v.Resop = uint32(OP_CB_GETATTR) } + } +} +func XDR_Nfs_cb_resop4(v *Nfs_cb_resop4) *Nfs_cb_resop4 { return v} +type _XdrVec_unbounded_Nfs_cb_argop4 []Nfs_cb_argop4 +func (_XdrVec_unbounded_Nfs_cb_argop4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Nfs_cb_argop4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Nfs_cb_argop4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Nfs_cb_argop4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Nfs_cb_argop4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Nfs_cb_argop4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Nfs_cb_argop4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Nfs_cb_argop4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Nfs_cb_argop4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Nfs_cb_argop4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Nfs_cb_argop4) XdrTypeName() string { return "Nfs_cb_argop4<>" } +func (v *_XdrVec_unbounded_Nfs_cb_argop4) XdrPointer() interface{} { return (*[]Nfs_cb_argop4)(v) } +func (v _XdrVec_unbounded_Nfs_cb_argop4) XdrValue() interface{} { return ([]Nfs_cb_argop4)(v) } +func (v *_XdrVec_unbounded_Nfs_cb_argop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_CB_COMPOUND4args = *CB_COMPOUND4args +func (v *CB_COMPOUND4args) XdrPointer() interface{} { return v } +func (CB_COMPOUND4args) XdrTypeName() string { return "CB_COMPOUND4args" } +func (v CB_COMPOUND4args) XdrValue() interface{} { return v } +func (v *CB_COMPOUND4args) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_COMPOUND4args) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%stag", name), XDR_Utf8str_cs(&v.Tag)) + x.Marshal(x.Sprintf("%sminorversion", name), XDR_Uint32_t(&v.Minorversion)) + x.Marshal(x.Sprintf("%scallback_ident", name), XDR_Uint32_t(&v.Callback_ident)) + x.Marshal(x.Sprintf("%sargarray", name), (*_XdrVec_unbounded_Nfs_cb_argop4)(&v.Argarray)) +} +func XDR_CB_COMPOUND4args(v *CB_COMPOUND4args) *CB_COMPOUND4args { return v } +type _XdrVec_unbounded_Nfs_cb_resop4 []Nfs_cb_resop4 +func (_XdrVec_unbounded_Nfs_cb_resop4) XdrBound() uint32 { + const bound uint32 = 4294967295 // Force error if not const or doesn't fit + return bound +} +func (_XdrVec_unbounded_Nfs_cb_resop4) XdrCheckLen(length uint32) { + if length > uint32(4294967295) { + XdrPanic("_XdrVec_unbounded_Nfs_cb_resop4 length %d exceeds bound 4294967295", length) + } else if int(length) < 0 { + XdrPanic("_XdrVec_unbounded_Nfs_cb_resop4 length %d exceeds max int", length) + } +} +func (v _XdrVec_unbounded_Nfs_cb_resop4) GetVecLen() uint32 { return uint32(len(v)) } +func (v *_XdrVec_unbounded_Nfs_cb_resop4) SetVecLen(length uint32) { + v.XdrCheckLen(length) + if int(length) <= cap(*v) { + if int(length) != len(*v) { + *v = (*v)[:int(length)] + } + return + } + newcap := 2*cap(*v) + if newcap < int(length) { // also catches overflow where 2*cap < 0 + newcap = int(length) + } else if bound := uint(4294967295); uint(newcap) > bound { + if int(bound) < 0 { + bound = ^uint(0) >> 1 + } + newcap = int(bound) + } + nv := make([]Nfs_cb_resop4, int(length), newcap) + copy(nv, *v) + *v = nv +} +func (v *_XdrVec_unbounded_Nfs_cb_resop4) XdrMarshalN(x XDR, name string, n uint32) { + v.XdrCheckLen(n) + for i := 0; i < int(n); i++ { + if (i >= len(*v)) { + v.SetVecLen(uint32(i+1)) + } + XDR_Nfs_cb_resop4(&(*v)[i]).XdrMarshal(x, x.Sprintf("%s[%d]", name, i)) + } + if int(n) < len(*v) { + *v = (*v)[:int(n)] + } +} +func (v *_XdrVec_unbounded_Nfs_cb_resop4) XdrRecurse(x XDR, name string) { + size := XdrSize{ Size: uint32(len(*v)), Bound: 4294967295 } + x.Marshal(name, &size) + v.XdrMarshalN(x, name, size.Size) +} +func (_XdrVec_unbounded_Nfs_cb_resop4) XdrTypeName() string { return "Nfs_cb_resop4<>" } +func (v *_XdrVec_unbounded_Nfs_cb_resop4) XdrPointer() interface{} { return (*[]Nfs_cb_resop4)(v) } +func (v _XdrVec_unbounded_Nfs_cb_resop4) XdrValue() interface{} { return ([]Nfs_cb_resop4)(v) } +func (v *_XdrVec_unbounded_Nfs_cb_resop4) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_CB_COMPOUND4res = *CB_COMPOUND4res +func (v *CB_COMPOUND4res) XdrPointer() interface{} { return v } +func (CB_COMPOUND4res) XdrTypeName() string { return "CB_COMPOUND4res" } +func (v CB_COMPOUND4res) XdrValue() interface{} { return v } +func (v *CB_COMPOUND4res) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *CB_COMPOUND4res) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sstatus", name), XDR_Nfsstat4(&v.Status)) + x.Marshal(x.Sprintf("%stag", name), XDR_Utf8str_cs(&v.Tag)) + x.Marshal(x.Sprintf("%sresarray", name), (*_XdrVec_unbounded_Nfs_cb_resop4)(&v.Resarray)) +} +func XDR_CB_COMPOUND4res(v *CB_COMPOUND4res) *CB_COMPOUND4res { return v } + +type xdrProc_CB_NULL struct { + Arg *XdrVoid + Res *XdrVoid +} +func (xdrProc_CB_NULL) Prog() uint32 { return 1073741824 } +func (xdrProc_CB_NULL) Vers() uint32 { return 1 } +func (xdrProc_CB_NULL) Proc() uint32 { return 0 } +func (xdrProc_CB_NULL) ProgName() string { return "NFS4_CALLBACK" } +func (xdrProc_CB_NULL) VersName() string { return "NFS_CB" } +func (xdrProc_CB_NULL) ProcName() string { return "CB_NULL" } +func (p *xdrProc_CB_NULL) GetArg() XdrType { + if p.Arg == nil { + p.Arg = new(XdrVoid) + } + return XDR_XdrVoid(p.Arg) +} +func (p *xdrProc_CB_NULL) GetRes() XdrType { + if p.Res == nil { + p.Res = new(XdrVoid) + } + return XDR_XdrVoid(p.Res) +} +var _ XdrProc = &xdrProc_CB_NULL{} // XXX + +type xdrSrvProc_CB_NULL struct { + xdrProc_CB_NULL + Srv NFS_CB +} +func (p *xdrSrvProc_CB_NULL) SetContext(ctx context.Context) { + if wc, ok := p.Srv.(interface { + WithContext(context.Context) NFS_CB + }); ok { + p.Srv = wc.WithContext(ctx) + } +} +func (p *xdrSrvProc_CB_NULL) Do() { + p.Srv.CB_NULL() +} +var _ XdrSrvProc = &xdrSrvProc_CB_NULL{} // XXX + +type xdrProc_CB_COMPOUND struct { + Arg *CB_COMPOUND4args + Res *CB_COMPOUND4res +} +func (xdrProc_CB_COMPOUND) Prog() uint32 { return 1073741824 } +func (xdrProc_CB_COMPOUND) Vers() uint32 { return 1 } +func (xdrProc_CB_COMPOUND) Proc() uint32 { return 1 } +func (xdrProc_CB_COMPOUND) ProgName() string { return "NFS4_CALLBACK" } +func (xdrProc_CB_COMPOUND) VersName() string { return "NFS_CB" } +func (xdrProc_CB_COMPOUND) ProcName() string { return "CB_COMPOUND" } +func (p *xdrProc_CB_COMPOUND) GetArg() XdrType { + if p.Arg == nil { + p.Arg = new(CB_COMPOUND4args) + } + return XDR_CB_COMPOUND4args(p.Arg) +} +func (p *xdrProc_CB_COMPOUND) GetRes() XdrType { + if p.Res == nil { + p.Res = new(CB_COMPOUND4res) + } + return XDR_CB_COMPOUND4res(p.Res) +} +var _ XdrProc = &xdrProc_CB_COMPOUND{} // XXX + +type xdrSrvProc_CB_COMPOUND struct { + xdrProc_CB_COMPOUND + Srv NFS_CB +} +func (p *xdrSrvProc_CB_COMPOUND) SetContext(ctx context.Context) { + if wc, ok := p.Srv.(interface { + WithContext(context.Context) NFS_CB + }); ok { + p.Srv = wc.WithContext(ctx) + } +} +func (p *xdrSrvProc_CB_COMPOUND) Do() { + r := p.Srv.CB_COMPOUND(*p.Arg) + p.Res = &r + +} +var _ XdrSrvProc = &xdrSrvProc_CB_COMPOUND{} // XXX + +func init() { + XdrCatalog[1073741824<<32|1] = func(p uint32) XdrProc { + switch(p) { + case 0: + return &xdrProc_CB_NULL{} + case 1: + return &xdrProc_CB_COMPOUND{} + } + return nil + } +} + +type NFS_CB_Server struct { + Srv NFS_CB +} +func (NFS_CB_Server) Prog() uint32 { return 1073741824 } +func (NFS_CB_Server) Vers() uint32 { return 1 } +func (NFS_CB_Server) ProgName() string { return "NFS4_CALLBACK" } +func (NFS_CB_Server) VersName() string { return "NFS_CB" } +func (s NFS_CB_Server) GetProc(p uint32) XdrSrvProc { + switch p { + case 0: // CB_NULL + return &xdrSrvProc_CB_NULL{ Srv: s.Srv } + case 1: // CB_COMPOUND + return &xdrSrvProc_CB_COMPOUND{ Srv: s.Srv } + default: + return nil + } +} +var _ XdrSrv = NFS_CB_Server{} // XXX + +type NFS_CB_Client struct { + Send XdrSendCall + Ctx context.Context +} +var _ NFS_CB = NFS_CB_Client{} // XXX +func (c NFS_CB_Client) WithContext(ctx context.Context) NFS_CB { + c.Ctx = ctx + return c +} +func (c NFS_CB_Client) CB_NULL() { + var proc xdrProc_CB_NULL + if err := c.Send.SendCall(c.Ctx, &proc); err != nil { + panic(err) + } +} +func (c NFS_CB_Client) CB_COMPOUND(a1 CB_COMPOUND4args) CB_COMPOUND4res { + var proc xdrProc_CB_COMPOUND + proc.Arg = &a1 + if err := c.Send.SendCall(c.Ctx, &proc); err != nil { + panic(err) + } + return *proc.Res +} + +// +// begin boilerplate +// + +// Types passed to the XDR Marshal method implementing the XdrType +// interface. Pointers to some generated types T already implement +// the interface. However, since built-in types such as string and +// int32 cannot implement interfaces, each type T has a function +// XDR_T(*T) that returns some type implementing XdrType. These +// XdrType interfaces also encode limits on string and vector sizes +// and simplify code by collapsing similar cases (e.g., all 32-bit +// numbers are cast to a pointer implementing XdrNum32). +// +// For most XdrType instances, XdrPointer() and XdrValue() provide +// access to the underlying type (which might not implement XdrType), +// with the following exceptions: +// +// * opaque[] (fixed-length arrays of bytes) are returned as +// XdrArrayOpaque (by XdrValue()) or nil (by XdrPointer()). This is +// because XdrArrayOpaque wraps a byte slice rather than an actual +// array. One generally doesn't want to pass arrays around; moreover, +// getting a pointer to the actual array provides less information, +// because one can't test for arrays in a type switch without knowing +// the exact length of the array, while one can always dynamically +// test the length of a slice. +// +// * Pointer types, in their XdrRecurse methods, marshal a special +// XdrNum32 type of 0 or 1 to record whether the pointer is nil or the +// value is present. Since this bool does not exist, XdrPointer() +// returns nil (while XdrValue returns a bool). +// +// * For arrays, XdrValue() passes a slice, rather than the full +// array, so as to avoid copying the array. +type XdrType interface { + // Return a string describing the name of the type (which will + // reflect the name of a typedef). + XdrTypeName() string + + // Return the underlying native representation of an XdrType + // (e.g., int32 for an XdrInt32). + XdrValue() interface{} + + // Return a pointer to the underlying native representation of an + // XdrType (often just the same type as the XdrType, but sometimes + // not, e.g., for primitive types that can't have methods + // defined). + XdrPointer() interface{} + + // Calls x.Marshal(name, v). + XdrMarshal(XDR, string) +} + +// The interface through which values are serialized, printed, etc. +type XDR interface { + // A function that gets called for each value to be marshalled. + // The val XdrType argument will be one of the following: + // + // * A pointer type implementing XdrNum32 for bool, int, unsigned + // int, float, the size of variable-length arrays except string + // and opaque, and enums. In the case of enums, that instance + // will just be a pointer to the enum. In the case of the other + // types, it will be a pointer to a defined type that implements + // the XdrNum32 interface (since plain go types cannot implement + // methods)--e.g., *XdrUint32 for unsigned int. Variable array + // sizes are passed as *XdrSize, which enforces the bound. + // + // * A pointer type implementing XdrNum64 for hyper, unsigned + // hyper, and double. These are user-defined versions of int64, + // uint64, and float64, called XdrInt64, XdrUint64, and + // XdrFloat64, respectively. + // + // * An instance of XdrBytes for strings and opaque. + // Specifically, strings are passed as XdrString, and + // variable-length opaque<> vectors are passed as XdrVecOpaque, + // both of which implement XdrVarBytes. + // + // * An XdrArrayOpaque containing a slice referencing a byte array + // for fixed-length opaque[]. XdrArrayOpaque implements + // XdrBytes, but not XdrVarBytes. + // + // * An instance of XdrAggregate for structs, unions, and + // pointers. Note that structs and unions are just passed as + // pointers to the underlying structures (which all implement + // XdrAggregate). Pointers are passed as an XdrPtr interface + // implemented by a defined pointer type (since plain pointers + // cannot have methods). + // + // Note that the Marshal method is responsible for recursing into + // XdrAggregate instance by calling the XdrRecurse method. + // Requiring the Marshal method to recurse manually allows it to + // refrain from recursing in cases where it needs to special-case + // the handling of specific types. + Marshal(name string, val XdrType) + + // This method should just be fmt.Sprintf for XDRs that use name. + // Those that don't use name can use a trivial method returning "" + Sprintf(string, ...interface{}) string +} + +// The error thrown by marshaling functions when data has a bad value. +type XdrError string +func (v XdrError) Error() string { return string(v) } + +// Throws an XdrError. +func XdrPanic(s string, args ...interface{}) { + panic(XdrError(fmt.Sprintf(s, args...))) +} + +// RFC4506 defines bool as equivalent to an enum with values all-caps +// TRUE and FALSE. For convenience, we represent an XDR bool as a Go +// bool instead, and so define these constants for use in union cases. +// (XDR source files should not use lower-case true and false, as +// these will not work in other languages or with other XDR +// compilers.) +const ( + TRUE = true + FALSE = false +) + +// Unfortunately, you can't cast a bool to an int. Hence, in +// situations like a union discriminant where we don't know if a type +// is equivalent to bool or not, then, short of using reflection, this +// is how we have to convert to an integer. Note that this expects +// types int, [u]int32, enum, and bool, rather than pointers to these +// types. +func XdrToI32(i interface{}) int32 { + switch v := i.(type) { + case interface{ GetU32() uint32 }: + return int32(v.GetU32()) + case int32: + return v + case uint32: + return int32(v) + case int: + return int32(v) + case bool: + if v { + return 1 + } + return 0 + } + panic(XdrError(fmt.Sprintf("XdrToI32: bad type %T", i))) +} + +// +// User-defined types used to place methods on basic types +// + +// All quantities that should be serialized as 32-bit numbers +// (including bools, enums, union discriminants, the bit saying +// whether or not a pointer is NULL, floats, and vector lenghts) are +// passed to the XDR.Marshal function as a pointer to a defined type +// implementing the XdrNum32 interface. The one exception is string<> +// and opaque<>, for which it is the job of XDR.Marshal to serialize +// the 32-bit length. +type XdrNum32 interface { + XdrType + fmt.Stringer + fmt.Scanner + GetU32() uint32 + SetU32(uint32) +} + +// Enums additionally provide access to a map of values to names. You +// generally don't need to invoke the XdrEnumNames() method (since the +// String and Scan methods already access the underlying maps), but +// the presence of this method can be useful to differentiate enums +// from other XdrNum32 types. +type XdrEnum interface { + XdrNum32 + XdrEnumNames() map[int32]string +} + +// All 64-bit numbers (hyper, unsigned hyper, and double) are passed +// to XDR.Marshal as a pointer to a defined type implementing +// XdrNum64. +type XdrNum64 interface { + XdrType + fmt.Stringer + fmt.Scanner + GetU64() uint64 + SetU64(uint64) +} + +// A common interface implemented by XdrString, XdrVecOpaque, and +// XdrArrayOpaque (and hence used to operate on the XdrTypes +// corresponding to value os ftype string<>, opaque<>, and opaque[]). +type XdrBytes interface { + XdrType + GetByteSlice() []byte +} + +// A common interface implemented by XdrString and XdrVecOpaque, the +// XdrTypes for opaque<> and string<>. Since XdrVarBytes is a subtype +// of XdrBytes, Marshal functions that want to distinguish between +// opaque<> and opaque[] should first try a type assertion for +// XdrVarBytes (to check for opaque<>) and then if that fails try +// XdrBytes (to check for opaque[]). +type XdrVarBytes interface { + XdrBytes + XdrBound() uint32 + SetByteSlice([]byte) +} + +// Any struct, union, pointer, or variable-length array type (except +// opaque<> and string<>) is passed to XDR.Marshal as a pointer +// implementing the XdrAggregate interface. It is the responsibility +// of the XDR.Marshal function to call the XdrRecurse method so as to +// recurse into the data structure. Placing reponsibility on +// XDR.Marshal for recursing allows a custom XDR to prune the +// serialization at particular types (e.g., for pretty-printing a +// partucular struct in a non-standard way). +type XdrAggregate interface { + XdrType + XdrRecurse(XDR, string) +} + +// A union type is an XdrAggregate with extra methods for individually +// accessing the tag and active branch. +type XdrUnion interface { + XdrAggregate + XdrValid() bool + XdrValidTags() map[int32]bool + XdrUnionTag() XdrNum32 + XdrUnionTagName() string + XdrUnionBody() XdrType + XdrUnionBodyName() string +} + +// Any pointer type is converted to an XdrType implementing the XdrPtr +// interface for marshaling. Note XdrPtr is a subtype of +// XdrAggregate. When a Marshal function does nothing special for +// XdrPtr and treats the XdrPtr like any other XdrAggregate (calling +// XdrRecurse), the Marshal function will then get called one or two +// more times, first with an XdrSize (implementing XdrNum32) to +// marshal the non-NULL bit, and then again with the underlying value +// if the pointer is non-NULL. An XDR.Marshal function that wants to +// special case pointers can access the present bit from the +// GetPresent and SetPresent methods, then bypass marshaling of the +// bit by calling XdrMarshalValue instead of XdrRecurse. +type XdrPtr interface { + // Marshals first the present/not-present bool, then if true, the + // underlying value. + XdrAggregate + + GetPresent() bool + SetPresent(bool) + + // If the present/not-present bool is false, this function does + // nothing. Otherwise, it marshals just the value, not the bit. + XdrMarshalValue(XDR, string) +} + +// Any vector type is passed as a pointer to a user-defined slice type +// that implements the XdrVec interface. XdrVec is a superset of +// XdrAggregate, so calling XdrRecurse will recurse to call +// XDR.Marshal first on the size (of type XdrSize), then on each +// element of the slice. An XDR.Marshal function can manually marshal +// the size and then call XdrMarshalN to marshal n vector elements. +// (When deserializing, it is advisable *not* to call SetVecLen before +// calling XdrMarshalN in case the length is huge and would exhaust +// memory; XdrMarshalN gradually grows the slice size as needed so as +// to throw a premature EOF error if N is larger than the actual input +// data.) +type XdrVec interface { + XdrAggregate + XdrBound() uint32 + GetVecLen() uint32 + SetVecLen(uint32) + XdrMarshalN(XDR, string, uint32) +} + +// Any array type is passed as a pointer to a user-defined array +// supporting the XdrArray interface. This is a subtype of +// XdrAggregate, and so supports recursing to marshal each individual +// array member. +type XdrArray interface { + XdrAggregate + XdrArraySize() uint32 +} + +type XdrTypedef interface { + XdrType + XdrUnwrap() XdrType +} + +// Unwrap typedefs to obtain the underlying XdrType. +func XdrBaseType(v XdrType) XdrType { + for { + t, ok := v.(XdrTypedef) + if !ok { + return v + } + v = t.XdrUnwrap() + } +} + +// Returns true for A-Z, a-z, 0-9, and _. (Used by the generated code +// that implements Scanner for enums.) +func XdrSymChar(r rune) bool { + return (r|0x20 >= 'a' && r|0x20 <= 'z') || + (r >= '0' && r <= '9') || r == '_' +} + +// An XdrType that marshals as zero bytes, and hence is used to +// represent void argument and return types of functions. +type XdrVoid struct{} +type XdrType_void = *XdrVoid +func (XdrVoid) XdrTypeName() string { return "void" } +func (XdrVoid) XdrValue() interface{} { return nil } +func (XdrVoid) XdrPointer() interface{} { return nil } +func (XdrVoid) XdrMarshal(XDR, string) {} +func XDR_XdrVoid(v *XdrVoid) XdrType_void { return v } + +// The XdrType that bool gets turned into for marshaling. +type XdrBool bool +type XdrType_bool = *XdrBool +func (XdrBool) XdrTypeName() string { return "bool" } +func (v XdrBool) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrBool) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrBool) GetU32() uint32 { if v { return 1 }; return 0 } +func (v *XdrBool) SetU32(nv uint32) { + switch nv { + case 0: + *v = false + case 1: + *v = true + default: + XdrPanic("bool must be 0 or 1") + } +} +func (v *XdrBool) XdrPointer() interface{} { return (*bool)(v) } +func (v XdrBool) XdrValue() interface{} { return bool(v) } +func (v *XdrBool) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_bool(v *bool) *XdrBool { return (*XdrBool)(v) } + +// The XdrType that int gets converted to for marshaling. +type XdrInt32 int32 +type XdrType_int32 = *XdrInt32 +func (XdrInt32) XdrTypeName() string { return "int32" } +func (v XdrInt32) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrInt32) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrInt32) GetU32() uint32 { return uint32(v) } +func (v *XdrInt32) SetU32(nv uint32) { *v = XdrInt32(nv) } +func (v *XdrInt32) XdrPointer() interface{} { return (*int32)(v) } +func (v XdrInt32) XdrValue() interface{} { return int32(v) } +func (v *XdrInt32) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_int32(v *int32) *XdrInt32 { return (*XdrInt32)(v) } + +// The XdrType that unsigned int gets converted to for marshaling. +type XdrUint32 uint32 +type XdrType_uint32 = *XdrUint32 +func (XdrUint32) XdrTypeName() string { return "uint32" } +func (v XdrUint32) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrUint32) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrUint32) GetU32() uint32 { return uint32(v) } +func (v *XdrUint32) SetU32(nv uint32) { *v = XdrUint32(nv) } +func (v *XdrUint32) XdrPointer() interface{} { return (*uint32)(v) } +func (v XdrUint32) XdrValue() interface{} { return uint32(v) } +func (v *XdrUint32) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_uint32(v *uint32) *XdrUint32 { return (*XdrUint32)(v) } + +// The XdrType that float gets converted to for marshaling. +type XdrFloat32 float32 +type XdrType_float32 = *XdrFloat32 +func (XdrFloat32) XdrTypeName() string { return "float32" } +func (v XdrFloat32) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrFloat32) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrFloat32) GetU32() uint32 { return math.Float32bits(float32(v)) } +func (v *XdrFloat32) SetU32(nv uint32) { + *v = XdrFloat32(math.Float32frombits(nv)) +} +func (v *XdrFloat32) XdrPointer() interface{} { return (*float32)(v) } +func (v XdrFloat32) XdrValue() interface{} { return float32(v) } +func (v *XdrFloat32) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_float32(v *float32) *XdrFloat32 { return (*XdrFloat32)(v) } + +// This XdrType is used to marshal the length of vectors and the +// present/not-present value of pointers. +type XdrSize struct { + Size uint32 + Bound uint32 +} +func (v XdrSize) String() string { return fmt.Sprintf("%v", v.Size) } +func (v *XdrSize) Scan(ss fmt.ScanState, r rune) (err error) { + defer func() { + if err == nil { + err = recover().(error) + } + }() + var nv uint32 + if _, err := fmt.Fscanf(ss, string([]rune{'%', r}), &nv); err != nil { + return err + } + v.SetU32(nv) + return +} +func (v XdrSize) GetU32() uint32 { return v.Size } +func (v *XdrSize) SetU32(nv uint32) { + if nv > v.Bound { + XdrPanic("size %d greater than bound %d", nv, v.Bound) + } else if int(nv) < 0 { + XdrPanic("size %d greater than max slice len", nv) + } + v.Size = nv +} +func (XdrSize) XdrTypeName() string { return "len" } +func (v *XdrSize) XdrPointer() interface{} { return &v.Size } +func (v XdrSize) XdrValue() interface{} { return v.Size } +func (v *XdrSize) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v XdrSize) XdrBound() uint32 { return v.Bound } + +// The XdrType that hyper gets converted to for marshaling. +type XdrInt64 int64 +type XdrType_int64 = *XdrInt64 +func (XdrInt64) XdrTypeName() string { return "int64" } +func (v XdrInt64) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrInt64) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrInt64) GetU64() uint64 { return uint64(v) } +func (v *XdrInt64) SetU64(nv uint64) { *v = XdrInt64(nv) } +func (v *XdrInt64) XdrPointer() interface{} { return (*int64)(v) } +func (v XdrInt64) XdrValue() interface{} { return int64(v) } +func (v *XdrInt64) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_int64(v *int64) *XdrInt64 { return (*XdrInt64)(v) } + +// The XdrType that unsigned hyper gets converted to for marshaling. +type XdrUint64 uint64 +type XdrType_uint64 = *XdrUint64 +func (XdrUint64) XdrTypeName() string { return "uint64" } +func (v XdrUint64) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrUint64) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrUint64) GetU64() uint64 { return uint64(v) } +func (v *XdrUint64) SetU64(nv uint64) { *v = XdrUint64(nv) } +func (v *XdrUint64) XdrPointer() interface{} { return (*uint64)(v) } +func (v XdrUint64) XdrValue() interface{} { return uint64(v) } +func (v *XdrUint64) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_uint64(v *uint64) *XdrUint64 { return (*XdrUint64)(v) } + +// The XdrType that double gets converted to for marshaling. +type XdrFloat64 float64 +type XdrType_float64 = *XdrFloat64 +func (XdrFloat64) XdrTypeName() string { return "float64" } +func (v XdrFloat64) String() string { return fmt.Sprintf("%v", v.XdrValue()) } +func (v *XdrFloat64) Scan(ss fmt.ScanState, r rune) error { + _, err := fmt.Fscanf(ss, string([]rune{'%', r}), v.XdrPointer()) + return err +} +func (v XdrFloat64) GetU64() uint64 { return math.Float64bits(float64(v)) } +func (v *XdrFloat64) SetU64(nv uint64) { + *v = XdrFloat64(math.Float64frombits(nv)) +} +func (v *XdrFloat64) XdrPointer() interface{} { return (*float64)(v) } +func (v XdrFloat64) XdrValue() interface{} { return float64(v) } +func (v *XdrFloat64) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func XDR_float64(v *float64) *XdrFloat64 { return (*XdrFloat64)(v) } + +// The XdrType that strings get converted to for marshaling. +type XdrString struct { + Str *string + Bound uint32 +} +func (v XdrString) String() string { return fmt.Sprintf("%q", *v.Str) } +func (v XdrString) Scan(ss fmt.ScanState, _ rune) error { + var s string + if _, err := fmt.Fscanf(ss, "%q", &s); err != nil { + return err + } else if int64(len(s)) > int64(v.Bound) { + return XdrError(fmt.Sprintf("Cannot store %d bytes in string<%d>", + len(s), v.Bound)) + } + *v.Str = s + return nil +} +func (v XdrString) XdrBound() uint32 { return v.Bound } +func (v XdrString) GetString() string { return *v.Str } +func (v XdrString) SetString(s string) { + if uint(len(s)) > uint(v.Bound) { + XdrPanic("Cannot store %d bytes in string<%d>", len(s), v.Bound) + } + *v.Str = s +} +func (v XdrString) GetByteSlice() []byte { return ([]byte)(*v.Str) } +func (v XdrString) SetByteSlice(bs []byte) { + if uint(len(bs)) > uint(v.Bound) { + XdrPanic("Cannot store %d bytes in string<%d>", len(bs), v.Bound) + } + *v.Str = string(bs) +} +func (XdrString) XdrTypeName() string { return "string" } +func (v XdrString) XdrPointer() interface{} { return v.Str } +func (v XdrString) XdrValue() interface{} { return *v.Str } +func (v XdrString) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } + +// The XdrType that opaque<> gets converted to for marshaling. +type XdrVecOpaque struct { + Bytes *[]byte + Bound uint32 +} +func (v XdrVecOpaque) String() string { + return fmt.Sprintf("%x", []byte(*v.Bytes)) +} +func (v XdrVecOpaque) Scan(ss fmt.ScanState, _ rune) error { + var bs []byte + _, err := fmt.Fscanf(ss, "%x", &bs) + if err == nil { + v.SetByteSlice(bs) + } + return err +} +func (v XdrVecOpaque) GetByteSlice() []byte { return *v.Bytes } +func (v XdrVecOpaque) XdrBound() uint32 { return v.Bound } +func (v XdrVecOpaque) SetByteSlice(bs []byte) { + if uint(len(bs)) > uint(v.Bound) { + XdrPanic("Cannot store %d bytes in string<%d>", len(bs), v.Bound) + } + *v.Bytes = bs +} +func (XdrVecOpaque) XdrTypeName() string { return "opaque<>" } +func (v XdrVecOpaque) XdrPointer() interface{} { return v.Bytes } +func (v XdrVecOpaque) XdrValue() interface{} { return *v.Bytes } +func (v XdrVecOpaque) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } + +// Helper function for scanning fix-size opaque arrays. +func XdrArrayOpaqueScan(dest []byte, ss fmt.ScanState, _ rune) error { + var bs []byte + _, err := fmt.Fscanf(ss, "%x", &bs) + if err != nil { + return err + } else if len(bs) != len (dest) { + return XdrError("Wrong number of bytes when scanning opaque[]") + } + copy(dest, bs) + return nil +} + +// The interface of XdrTypes of opaque[n] for all n +type XdrArrayOpaque interface { + XdrBytes + XdrArraySize() uint32 +} + + +// +// Basic implementations of XDR interface +// + +// Back end that renders an XDR data structure as simple text. +// Example: +// +// XDR_MyType(&myVal).XdrMarshal(&XdrPrint{os.Stdout}, "") +// +type XdrPrint struct { + Out io.Writer +} + +// Generic function that converts any compiled XDR type to a +// multi-line string. Useful for debugging. +func XdrToString(t XdrType) string { + out := &strings.Builder{} + t.XdrMarshal(&XdrPrint{out}, "") + return out.String() +} + +func (xp XdrPrint) Sprintf(f string, args ...interface{}) string { + return fmt.Sprintf(f, args...) +} + +func (xp XdrPrint) Marshal(name string, i XdrType) { + switch v := i.(type) { + case fmt.Stringer: + fmt.Fprintf(xp.Out, "%s: %s\n", name, v.String()) + case XdrPtr: + fmt.Fprintf(xp.Out, "%s.present: %v\n", name, v.GetPresent()) + v.XdrMarshalValue(xp, fmt.Sprintf("(*%s)", name)) + case XdrVec: + fmt.Fprintf(xp.Out, "%s.len: %d\n", name, v.GetVecLen()) + v.XdrMarshalN(xp, name, v.GetVecLen()) + case XdrAggregate: + v.XdrRecurse(xp, name) + default: + fmt.Fprintf(xp.Out, "%s: %v\n", name, i) + } +} + +var xdrZerofill [4][]byte = [...][]byte{ + {}, {0,0,0}, {0,0}, {0}, +} + +func xdrPutBytes(out io.Writer, val []byte) { + out.Write(val) + out.Write(xdrZerofill[len(val)&3]) +} + +func xdrPut32(out io.Writer, val uint32) { + b := make([]byte, 4) + binary.BigEndian.PutUint32(b, val) + out.Write(b) +} + +func xdrPut64(out io.Writer, val uint64) { + b := make([]byte, 8) + binary.BigEndian.PutUint64(b, val) + out.Write(b) +} + + +// XDR that marshals to canonical binary format +type XdrOut struct { + Out io.Writer +} + +func (xp XdrOut) Sprintf(f string, args ...interface{}) string { + return "" +} + +func (xo XdrOut) Marshal(name string, i XdrType) { + switch v := i.(type) { + case XdrNum32: + xdrPut32(xo.Out, v.GetU32()) + case XdrNum64: + xdrPut64(xo.Out, v.GetU64()) + case XdrString: + s := v.GetString() + xdrPut32(xo.Out, uint32(len(s))) + io.WriteString(xo.Out, s) + xo.Out.Write(xdrZerofill[len(s)&3]) + case XdrVarBytes: + xdrPut32(xo.Out, uint32(len(v.GetByteSlice()))) + xdrPutBytes(xo.Out, v.GetByteSlice()) + case XdrBytes: + xdrPutBytes(xo.Out, v.GetByteSlice()) + case XdrAggregate: + v.XdrRecurse(xo, name) + default: + panic(fmt.Sprintf("XdrOut: unhandled type %T", i)) + } +} + +func xdrReadN(in io.Reader, n uint32) []byte { + var b bytes.Buffer + if _, err := io.CopyN(&b, in, int64(n)); err != nil { + XdrPanic(err.Error()) + } + return b.Bytes() +} + +func xdrReadPad(in io.Reader, n uint32) { + if n & 3 != 0 { + got := xdrReadN(in, 4-(n&3)) + for _, b := range got { + if b != 0 { + XdrPanic("padding contained non-zero bytes") + } + } + } +} + +func xdrGet32(in io.Reader) uint32 { + b := xdrReadN(in, 4) + return binary.BigEndian.Uint32(b) +} + +func xdrGet64(in io.Reader) uint64 { + b := xdrReadN(in, 8) + return binary.BigEndian.Uint64(b) +} + + +// XDR that unmarshals from canonical binary format +type XdrIn struct { + In io.Reader +} + +func (xp XdrIn) Sprintf(f string, args ...interface{}) string { + return "" +} + +func (xi XdrIn) Marshal(name string, i XdrType) { + switch v := i.(type) { + case XdrNum32: + v.SetU32(xdrGet32(xi.In)) + case XdrNum64: + v.SetU64(xdrGet64(xi.In)) + case XdrVarBytes: + n := xdrGet32(xi.In) + v.SetByteSlice(xdrReadN(xi.In, n)) + xdrReadPad(xi.In, n) + case XdrBytes: + if _, err := io.ReadFull(xi.In, v.GetByteSlice()); err != nil { + panic(err) + } + xdrReadPad(xi.In, uint32(len(v.GetByteSlice()))) + case XdrAggregate: + v.XdrRecurse(xi, name) + } +} + + +// +// RFC5531 RPC support +// + +// Interface for a data structure containing the argument and result +// types of a call. +type XdrProc interface { + Prog() uint32 + Vers() uint32 + Proc() uint32 + ProgName() string + VersName() string + ProcName() string + GetArg() XdrType + GetRes() XdrType +} + +// Interface for a data structure containing argument and results of a +// procedure plus a way to invoke the procedure on an instance of the +// RPC version. In other words, Do() actually performs the work of an +// RPC on the server side. +type XdrSrvProc interface { + XdrProc + Do() + SetContext(context.Context) +} + +// Interface for an RPC version interface bound to a server +// implementation. The result of GetProc() can be used to marshal the +// arguments and results as well as actually invoke the function +// (though Do()). +type XdrSrv interface { + Prog() uint32 + Vers() uint32 + ProgName() string + VersName() string + GetProc(uint32) XdrSrvProc +} + +// An interface for types that can send remote procedure calls and +// await their reply. +type XdrSendCall interface { + SendCall(context.Context, XdrProc) error +} + +// A catalog of procedures of different RPC programs and versions, +// mostly useful for debugging (e.g., pretty-printing a log of RPC +// messages). The key to the map is prog<<32|vers. The function +// returns a new instance of an appropriate XdrProc. +var XdrCatalog = make(map[uint64]func(uint32)XdrProc) + +// +// end boilerplate +// diff --git a/server/plugin/plg_backend_nfs4/repo/internal/nfs4.x b/server/plugin/plg_backend_nfs4/repo/internal/nfs4.x new file mode 100644 index 00000000..5f7ba38f --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/nfs4.x @@ -0,0 +1,2191 @@ +/* This is based on RFC3530 */ + +/* + * NFS v4 Definitions + */ + + +/* + * Copyright (C) The Internet Society (1998,1999,2000,2001,2002). + * All Rights Reserved. + */ + +/* + * nfs4_prot.x + * + */ + +/* + * Sizes + */ +const NFS4_FHSIZE = 128; +const NFS4_VERIFIER_SIZE = 8; +const NFS4_OPAQUE_LIMIT = 1024; +const NFS4_SESSIONID_SIZE = 16; +/* + * File types + */ +enum nfs_ftype4 { + NF4REG = 1, /* Regular File */ + NF4DIR = 2, /* Directory */ + NF4BLK = 3, /* Special File - block device */ + NF4CHR = 4, /* Special File - character device */ + NF4LNK = 5, /* Symbolic Link */ + NF4SOCK = 6, /* Special File - socket */ + NF4FIFO = 7, /* Special File - fifo */ + NF4ATTRDIR = 8, /* Attribute Directory */ + NF4NAMEDATTR = 9 /* Named Attribute */ +}; + +/* + * Error status + */ +enum nfsstat4 { + NFS4_OK = 0, /* everything is okay */ + NFS4ERR_PERM = 1, /* caller not privileged */ + NFS4ERR_NOENT = 2, /* no such file/directory */ + NFS4ERR_IO = 5, /* hard I/O error */ + NFS4ERR_NXIO = 6, /* no such device */ + NFS4ERR_ACCESS = 13, /* access denied */ + NFS4ERR_EXIST = 17, /* file already exists */ + NFS4ERR_XDEV = 18, /* different filesystems */ + /* Unused/reserved 19 */ + NFS4ERR_NOTDIR = 20, /* should be a directory */ + NFS4ERR_ISDIR = 21, /* should not be directory */ + NFS4ERR_INVAL = 22, /* invalid argument */ + NFS4ERR_FBIG = 27, /* file exceeds server max */ + NFS4ERR_NOSPC = 28, /* no space on filesystem */ + NFS4ERR_ROFS = 30, /* read-only filesystem */ + NFS4ERR_MLINK = 31, /* too many hard links */ + NFS4ERR_NAMETOOLONG = 63, /* name exceeds server max */ + NFS4ERR_NOTEMPTY = 66, /* directory not empty */ + NFS4ERR_DQUOT = 69, /* hard quota limit reached*/ + NFS4ERR_STALE = 70, /* file no longer exists */ + NFS4ERR_BADHANDLE = 10001,/* Illegal filehandle */ + NFS4ERR_BAD_COOKIE = 10003,/* READDIR cookie is stale */ + NFS4ERR_NOTSUPP = 10004,/* operation not supported */ + NFS4ERR_TOOSMALL = 10005,/* response limit exceeded */ + NFS4ERR_SERVERFAULT = 10006,/* undefined server error */ + NFS4ERR_BADTYPE = 10007,/* type invalid for CREATE */ + NFS4ERR_DELAY = 10008,/* file "busy" - retry */ + NFS4ERR_SAME = 10009,/* nverify says attrs same */ + NFS4ERR_DENIED = 10010,/* lock unavailable */ + NFS4ERR_EXPIRED = 10011,/* lock lease expired */ + NFS4ERR_LOCKED = 10012,/* I/O failed due to lock */ + NFS4ERR_GRACE = 10013,/* in grace period */ + NFS4ERR_FHEXPIRED = 10014,/* filehandle expired */ + NFS4ERR_SHARE_DENIED = 10015,/* share reserve denied */ + NFS4ERR_WRONGSEC = 10016,/* wrong security flavor */ + NFS4ERR_CLID_INUSE = 10017,/* clientid in use */ + NFS4ERR_RESOURCE = 10018,/* resource exhaustion */ + NFS4ERR_MOVED = 10019,/* filesystem relocated */ + NFS4ERR_NOFILEHANDLE = 10020,/* current FH is not set */ + NFS4ERR_MINOR_VERS_MISMATCH = 10021,/* minor vers not supp */ + NFS4ERR_STALE_CLIENTID = 10022,/* server has rebooted */ + NFS4ERR_STALE_STATEID = 10023,/* server has rebooted */ + NFS4ERR_OLD_STATEID = 10024,/* state is out of sync */ + NFS4ERR_BAD_STATEID = 10025,/* incorrect stateid */ + NFS4ERR_BAD_SEQID = 10026,/* request is out of seq. */ + NFS4ERR_NOT_SAME = 10027,/* verify - attrs not same */ + NFS4ERR_LOCK_RANGE = 10028,/* lock range not supported*/ + NFS4ERR_SYMLINK = 10029,/* should be file/directory*/ + NFS4ERR_RESTOREFH = 10030,/* no saved filehandle */ + NFS4ERR_LEASE_MOVED = 10031,/* some filesystem moved */ + NFS4ERR_ATTRNOTSUPP = 10032,/* recommended attr not sup*/ + NFS4ERR_NO_GRACE = 10033,/* reclaim outside of grace*/ + NFS4ERR_RECLAIM_BAD = 10034,/* reclaim error at server */ + NFS4ERR_RECLAIM_CONFLICT = 10035,/* conflict on reclaim */ + NFS4ERR_BADXDR = 10036,/* XDR decode failed */ + NFS4ERR_LOCKS_HELD = 10037,/* file locks held at CLOSE*/ + NFS4ERR_OPENMODE = 10038,/* conflict in OPEN and I/O*/ + NFS4ERR_BADOWNER = 10039,/* owner translation bad */ + NFS4ERR_BADCHAR = 10040,/* utf-8 char not supported*/ + NFS4ERR_BADNAME = 10041,/* name not supported */ + NFS4ERR_BAD_RANGE = 10042,/* lock range not supported*/ + NFS4ERR_LOCK_NOTSUPP = 10043,/* no atomic up/downgrade */ + NFS4ERR_OP_ILLEGAL = 10044,/* undefined operation */ + NFS4ERR_DEADLOCK = 10045,/* file locking deadlock */ + NFS4ERR_FILE_OPEN = 10046,/* open file blocks op. */ + NFS4ERR_ADMIN_REVOKED = 10047,/* lockowner state revoked */ + NFS4ERR_CB_PATH_DOWN = 10048,/* callback path down */ + NFS4ERR_BADIOMODE = 10049, + NFS4ERR_BADLAYOUT = 10050, + NFS4ERR_BAD_SESSION_DIGEST = 10051, + NFS4ERR_BADSESSION = 10052, + NFS4ERR_BADSLOT = 10053, + NFS4ERR_COMPLETE_ALREADY = 10054, + NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055, + NFS4ERR_DELEG_ALREADY_WANTED = 10056, + NFS4ERR_BACK_CHAN_BUSY = 10057, + NFS4ERR_LAYOUTTRYLATER = 10058, + NFS4ERR_LAYOUTUNAVAILABLE = 10059, + NFS4ERR_NOMATCHING_LAYOUT = 10060, + NFS4ERR_RECALLCONFLICT = 10061 +}; + +/* + * Basic data types + */ +typedef uint32_t bitmap4<>; +typedef uint64_t offset4; +typedef uint32_t count4; +typedef uint64_t length4; +typedef uint64_t clientid4; +typedef uint32_t sequenceid4; +typedef uint32_t seqid4; +typedef uint32_t slotid4; +typedef opaque utf8string<>; +typedef utf8string utf8str_cis; +typedef utf8string utf8str_cs; +typedef utf8string utf8str_mixed; +typedef utf8str_cs component4; +typedef component4 pathname4<>; +typedef uint64_t nfs_lockid4; +typedef uint64_t nfs_cookie4; +typedef utf8str_cs linktext4; +typedef opaque sec_oid4<>; +typedef uint32_t qop4; +typedef uint32_t mode4; +typedef uint64_t changeid4; +typedef opaque verifier4[NFS4_VERIFIER_SIZE]; +typedef opaque sessionid4[NFS4_SESSIONID_SIZE]; +/* + * Authsys_parms + */ +struct authsys_parms { + unsigned int stamp; + string machinename<255>; + unsigned int uid; + unsigned int gid; + unsigned int gids<16>; +}; + +const NFS4_DEVICEID4_SIZE = 16; + +typedef opaque deviceid4[NFS4_DEVICEID4_SIZE]; + +enum layouttype4 { + LAYOUT4_NFSV4_1_FILES = 0x1, + LAYOUT4_OSD2_OBJECTS = 0x2, + LAYOUT4_BLOCK_VOLUME = 0x3 +}; + +struct layoutupdate4 { + layouttype4 lou_type; + opaque lou_body<>; +}; + + +struct device_addr4 { + layouttype4 da_layout_type; + opaque da_addr_body<>; +}; + +/* + * Timeval + */ +struct nfstime4 { + int64_t seconds; + uint32_t nseconds; +}; + +enum time_how4 { + SET_TO_SERVER_TIME4 = 0, + SET_TO_CLIENT_TIME4 = 1 +}; + +enum layoutiomode4 { + LAYOUTIOMODE4_READ = 1, + LAYOUTIOMODE4_RW = 2, + LAYOUTIOMODE4_ANY = 3 +}; + +struct layout_content4 { + layouttype4 loc_type; + opaque loc_body<>; +}; + +struct layout4 { + offset4 lo_offset; + length4 lo_length; + layoutiomode4 lo_iomode; + layout_content4 lo_content; +}; + +union settime4 switch (time_how4 set_it) { + case SET_TO_CLIENT_TIME4: + nfstime4 time; + default: + void; +}; + +/* + * File access handle + */ +typedef opaque nfs_fh4; + +/* + * File attribute definitions + */ + +/* + * FSID structure for major/minor + */ +struct fsid4 { + uint64_t major; + uint64_t minor; +}; + +/* + * Filesystem locations attribute for relocation/migration + */ +struct fs_location4 { + utf8str_cis server<>; + pathname4 rootpath; +}; + +struct fs_locations4 { + pathname4 fs_root; + fs_location4 locations<>; +}; + +/* + * Various Access Control Entry definitions + */ + +/* + * Mask that indicates which Access Control Entries are supported. + * Values for the fattr4_aclsupport attribute. + */ +const ACL4_SUPPORT_ALLOW_ACL = 0x00000001; +const ACL4_SUPPORT_DENY_ACL = 0x00000002; +const ACL4_SUPPORT_AUDIT_ACL = 0x00000004; +const ACL4_SUPPORT_ALARM_ACL = 0x00000008; + + +typedef uint32_t acetype4; +/* + * acetype4 values, others can be added as needed. + */ +const ACE4_ACCESS_ALLOWED_ACE_TYPE = 0x00000000; +const ACE4_ACCESS_DENIED_ACE_TYPE = 0x00000001; +const ACE4_SYSTEM_AUDIT_ACE_TYPE = 0x00000002; +const ACE4_SYSTEM_ALARM_ACE_TYPE = 0x00000003; + + +/* + * ACE flag + */ +typedef uint32_t aceflag4; + +/* + * ACE flag values + */ +const ACE4_FILE_INHERIT_ACE = 0x00000001; +const ACE4_DIRECTORY_INHERIT_ACE = 0x00000002; +const ACE4_NO_PROPAGATE_INHERIT_ACE = 0x00000004; +const ACE4_INHERIT_ONLY_ACE = 0x00000008; +const ACE4_SUCCESSFUL_ACCESS_ACE_FLAG = 0x00000010; +const ACE4_FAILED_ACCESS_ACE_FLAG = 0x00000020; +const ACE4_IDENTIFIER_GROUP = 0x00000040; + + +/* + * ACE mask + */ +typedef uint32_t acemask4; + +/* + * ACE mask values + */ +const ACE4_READ_DATA = 0x00000001; +const ACE4_LIST_DIRECTORY = 0x00000001; +const ACE4_WRITE_DATA = 0x00000002; +const ACE4_ADD_FILE = 0x00000002; +const ACE4_APPEND_DATA = 0x00000004; +const ACE4_ADD_SUBDIRECTORY = 0x00000004; +const ACE4_READ_NAMED_ATTRS = 0x00000008; +const ACE4_WRITE_NAMED_ATTRS = 0x00000010; +const ACE4_EXECUTE = 0x00000020; +const ACE4_DELETE_CHILD = 0x00000040; +const ACE4_READ_ATTRIBUTES = 0x00000080; +const ACE4_WRITE_ATTRIBUTES = 0x00000100; +const ACE4_DELETE = 0x00010000; +const ACE4_READ_ACL = 0x00020000; +const ACE4_WRITE_ACL = 0x00040000; +const ACE4_WRITE_OWNER = 0x00080000; +const ACE4_SYNCHRONIZE = 0x00100000; + +/* + * ACE4_GENERIC_READ -- defined as combination of + * ACE4_READ_ACL | + * ACE4_READ_DATA | + * ACE4_READ_ATTRIBUTES | + * ACE4_SYNCHRONIZE + */ +const ACE4_GENERIC_READ = 0x00120081; + +/* + * ACE4_GENERIC_WRITE -- defined as combination of + * ACE4_READ_ACL | + * ACE4_WRITE_DATA | + * ACE4_WRITE_ATTRIBUTES | + * ACE4_WRITE_ACL | + * ACE4_APPEND_DATA | + * ACE4_SYNCHRONIZE + */ +const ACE4_GENERIC_WRITE = 0x00160106; + +/* + * ACE4_GENERIC_EXECUTE -- defined as combination of + * ACE4_READ_ACL + * ACE4_READ_ATTRIBUTES + * ACE4_EXECUTE + * ACE4_SYNCHRONIZE + */ +const ACE4_GENERIC_EXECUTE = 0x001200A0; + + +/* + * Access Control Entry definition + */ +struct nfsace4 { + acetype4 type; + aceflag4 flag; + acemask4 access_mask; + utf8str_mixed who; +}; + +/* + * Field definitions for the fattr4_mode attribute + */ +const MODE4_SUID = 0x800; /* set user id on execution */ +const MODE4_SGID = 0x400; /* set group id on execution */ +const MODE4_SVTX = 0x200; /* save text even after use */ +const MODE4_RUSR = 0x100; /* read permission: owner */ +const MODE4_WUSR = 0x080; /* write permission: owner */ +const MODE4_XUSR = 0x040; /* execute permission: owner */ +const MODE4_RGRP = 0x020; /* read permission: group */ +const MODE4_WGRP = 0x010; /* write permission: group */ +const MODE4_XGRP = 0x008; /* execute permission: group */ +const MODE4_ROTH = 0x004; /* read permission: other */ +const MODE4_WOTH = 0x002; /* write permission: other */ +const MODE4_XOTH = 0x001; /* execute permission: other */ + +/* + * Special data/attribute associated with + * file types NF4BLK and NF4CHR. + */ +struct specdata4 { + uint32_t specdata1; /* major device number */ + uint32_t specdata2; /* minor device number */ +}; + +/* + * Values for fattr4_fh_expire_type + */ +const FH4_PERSISTENT = 0x00000000; +const FH4_NOEXPIRE_WITH_OPEN = 0x00000001; +const FH4_VOLATILE_ANY = 0x00000002; +const FH4_VOL_MIGRATION = 0x00000004; +const FH4_VOL_RENAME = 0x00000008; + + +typedef bitmap4 fattr4_supported_attrs; +typedef nfs_ftype4 fattr4_type; +typedef uint32_t fattr4_fh_expire_type; +typedef changeid4 fattr4_change; +typedef uint64_t fattr4_size; +typedef bool fattr4_link_support; +typedef bool fattr4_symlink_support; +typedef bool fattr4_named_attr; +typedef fsid4 fattr4_fsid; +typedef bool fattr4_unique_handles; +typedef uint32_t fattr4_lease_time; +typedef nfsstat4 fattr4_rdattr_error; +typedef nfsace4 fattr4_acl<>; +typedef uint32_t fattr4_aclsupport; +typedef bool fattr4_archive; +typedef bool fattr4_cansettime; +typedef bool fattr4_case_insensitive; +typedef bool fattr4_case_preserving; +typedef bool fattr4_chown_restricted; +typedef uint64_t fattr4_fileid; +typedef uint64_t fattr4_files_avail; +typedef nfs_fh4 fattr4_filehandle; +typedef uint64_t fattr4_files_free; +typedef uint64_t fattr4_files_total; +typedef fs_locations4 fattr4_fs_locations; +typedef bool fattr4_hidden; +typedef bool fattr4_homogeneous; +typedef uint64_t fattr4_maxfilesize; +typedef uint32_t fattr4_maxlink; +typedef uint32_t fattr4_maxname; +typedef uint64_t fattr4_maxread; +typedef uint64_t fattr4_maxwrite; +typedef utf8str_cs fattr4_mimetype; +typedef mode4 fattr4_mode; +typedef uint64_t fattr4_mounted_on_fileid; +typedef bool fattr4_no_trunc; +typedef uint32_t fattr4_numlinks; +typedef utf8str_mixed fattr4_owner; +typedef utf8str_mixed fattr4_owner_group; +typedef uint64_t fattr4_quota_avail_hard; +typedef uint64_t fattr4_quota_avail_soft; +typedef uint64_t fattr4_quota_used; +typedef specdata4 fattr4_rawdev; +typedef uint64_t fattr4_space_avail; +typedef uint64_t fattr4_space_free; +typedef uint64_t fattr4_space_total; +typedef uint64_t fattr4_space_used; +typedef bool fattr4_system; +typedef nfstime4 fattr4_time_access; +typedef settime4 fattr4_time_access_set; +typedef nfstime4 fattr4_time_backup; +typedef nfstime4 fattr4_time_create; +typedef nfstime4 fattr4_time_delta; +typedef nfstime4 fattr4_time_metadata; +typedef nfstime4 fattr4_time_modify; +typedef settime4 fattr4_time_modify_set; + + +/* + * Mandatory Attributes + */ +const FATTR4_SUPPORTED_ATTRS = 0; +const FATTR4_TYPE = 1; +const FATTR4_FH_EXPIRE_TYPE = 2; +const FATTR4_CHANGE = 3; +const FATTR4_SIZE = 4; +const FATTR4_LINK_SUPPORT = 5; +const FATTR4_SYMLINK_SUPPORT = 6; +const FATTR4_NAMED_ATTR = 7; +const FATTR4_FSID = 8; +const FATTR4_UNIQUE_HANDLES = 9; +const FATTR4_LEASE_TIME = 10; +const FATTR4_RDATTR_ERROR = 11; +const FATTR4_FILEHANDLE = 19; + +/* + * Recommended Attributes + */ +const FATTR4_ACL = 12; +const FATTR4_ACLSUPPORT = 13; +const FATTR4_ARCHIVE = 14; +const FATTR4_CANSETTIME = 15; +const FATTR4_CASE_INSENSITIVE = 16; +const FATTR4_CASE_PRESERVING = 17; +const FATTR4_CHOWN_RESTRICTED = 18; +const FATTR4_FILEID = 20; +const FATTR4_FILES_AVAIL = 21; +const FATTR4_FILES_FREE = 22; +const FATTR4_FILES_TOTAL = 23; +const FATTR4_FS_LOCATIONS = 24; +const FATTR4_HIDDEN = 25; +const FATTR4_HOMOGENEOUS = 26; +const FATTR4_MAXFILESIZE = 27; +const FATTR4_MAXLINK = 28; +const FATTR4_MAXNAME = 29; +const FATTR4_MAXREAD = 30; +const FATTR4_MAXWRITE = 31; +const FATTR4_MIMETYPE = 32; +const FATTR4_MODE = 33; +const FATTR4_NO_TRUNC = 34; +const FATTR4_NUMLINKS = 35; +const FATTR4_OWNER = 36; +const FATTR4_OWNER_GROUP = 37; +const FATTR4_QUOTA_AVAIL_HARD = 38; +const FATTR4_QUOTA_AVAIL_SOFT = 39; +const FATTR4_QUOTA_USED = 40; +const FATTR4_RAWDEV = 41; +const FATTR4_SPACE_AVAIL = 42; +const FATTR4_SPACE_FREE = 43; +const FATTR4_SPACE_TOTAL = 44; +const FATTR4_SPACE_USED = 45; +const FATTR4_SYSTEM = 46; +const FATTR4_TIME_ACCESS = 47; +const FATTR4_TIME_ACCESS_SET = 48; +const FATTR4_TIME_BACKUP = 49; +const FATTR4_TIME_CREATE = 50; +const FATTR4_TIME_DELTA = 51; +const FATTR4_TIME_METADATA = 52; +const FATTR4_TIME_MODIFY = 53; +const FATTR4_TIME_MODIFY_SET = 54; +const FATTR4_MOUNTED_ON_FILEID = 55; + +typedef opaque attrlist4<>; + +/* + * File attribute container + */ +struct fattr4 { + bitmap4 attrmask; + attrlist4 attr_vals; +}; + +/* + * Change info for the client + */ +struct change_info4 { + bool atomic; + changeid4 before; + changeid4 after; +}; + +struct clientaddr4 { + /* see struct rpcb in RFC 1833 */ + string r_netid<>; /* network id */ + string r_addr<>; /* universal address */ +}; + +/* + * Callback program info as provided by the client + */ +struct cb_client4 { + uint32_t cb_program; + clientaddr4 cb_location; +}; + +/* + * Stateid + */ +struct stateid4 { + uint32_t seqid; + opaque other[12]; +}; + +/* + * Client ID + */ +struct nfs_client_id4 { + verifier4 verifier; + opaque id; +}; + +struct open_owner4 { + clientid4 clientid; + opaque owner; +}; + +struct lock_owner4 { + clientid4 clientid; + opaque owner; +}; + +enum nfs_lock_type4 { + READ_LT = 1, + WRITE_LT = 2, + READW_LT = 3, /* blocking read */ + WRITEW_LT = 4 /* blocking write */ +}; + +/* + * ACCESS: Check access permission + */ +const ACCESS4_READ = 0x00000001; +const ACCESS4_LOOKUP = 0x00000002; +const ACCESS4_MODIFY = 0x00000004; +const ACCESS4_EXTEND = 0x00000008; +const ACCESS4_DELETE = 0x00000010; +const ACCESS4_EXECUTE = 0x00000020; + +struct ACCESS4args { + /* CURRENT_FH: object */ + uint32_t access; +}; + +struct ACCESS4resok { + uint32_t supported; + uint32_t access; +}; + +union ACCESS4res switch (nfsstat4 status) { + case NFS4_OK: + ACCESS4resok resok4; + default: + void; +}; + +/* + * CLOSE: Close a file and release share reservations + */ +struct CLOSE4args { + /* CURRENT_FH: object */ + seqid4 seqid; + stateid4 open_stateid; +}; + +union CLOSE4res switch (nfsstat4 status) { + case NFS4_OK: + stateid4 open_stateid; + default: + void; +}; + +/* + * COMMIT: Commit cached data on server to stable storage + */ +struct COMMIT4args { + /* CURRENT_FH: file */ + offset4 offset; + count4 count; +}; + +struct COMMIT4resok { + verifier4 writeverf; +}; + + +union COMMIT4res switch (nfsstat4 status) { + case NFS4_OK: + COMMIT4resok resok4; + default: + void; +}; + +/* + * CREATE: Create a non-regular file + */ +union createtype4 switch (nfs_ftype4 type) { + case NF4LNK: + linktext4 linkdata; + case NF4BLK: + case NF4CHR: + specdata4 devdata; + case NF4SOCK: + case NF4FIFO: + case NF4DIR: + void; + default: + void; /* server should return NFS4ERR_BADTYPE */ +}; + +struct CREATE4args { + /* CURRENT_FH: directory for creation */ + createtype4 objtype; + component4 objname; + fattr4 createattrs; +}; + +struct CREATE4resok { + change_info4 cinfo; + bitmap4 attrset; /* attributes set */ +}; + +union CREATE4res switch (nfsstat4 status) { + case NFS4_OK: + CREATE4resok resok4; + default: + void; +}; + +/* + * DELEGPURGE: Purge Delegations Awaiting Recovery + */ +struct DELEGPURGE4args { + clientid4 clientid; +}; + +struct DELEGPURGE4res { + nfsstat4 status; +}; + +/* + * DELEGRETURN: Return a delegation + */ +struct DELEGRETURN4args { + /* CURRENT_FH: delegated file */ + stateid4 deleg_stateid; +}; + +struct DELEGRETURN4res { + nfsstat4 status; +}; + +/* + * GETATTR: Get file attributes + */ +struct GETATTR4args { + /* CURRENT_FH: directory or file */ + bitmap4 attr_request; +}; + +struct GETATTR4resok { + fattr4 obj_attributes; +}; + +union GETATTR4res switch (nfsstat4 status) { + case NFS4_OK: + GETATTR4resok resok4; + default: + void; +}; + +/* + * GETFH: Get current filehandle + */ +struct GETFH4resok { + nfs_fh4 object; +}; + +union GETFH4res switch (nfsstat4 status) { + case NFS4_OK: + GETFH4resok resok4; + default: + void; +}; + +/* + * LINK: Create link to an object + */ +struct LINK4args { + /* SAVED_FH: source object */ + /* CURRENT_FH: target directory */ + component4 newname; +}; + +struct LINK4resok { + change_info4 cinfo; +}; + +union LINK4res switch (nfsstat4 status) { + case NFS4_OK: + LINK4resok resok4; + default: + void; +}; + +/* + * For LOCK, transition from open_owner to new lock_owner + */ +struct open_to_lock_owner4 { + seqid4 open_seqid; + stateid4 open_stateid; + seqid4 lock_seqid; + lock_owner4 lock_owner; +}; + +/* + * For LOCK, existing lock_owner continues to request file locks + */ +struct exist_lock_owner4 { + stateid4 lock_stateid; + seqid4 lock_seqid; +}; + +union locker4 switch (bool new_lock_owner) { + case TRUE: + open_to_lock_owner4 open_owner; + case FALSE: + exist_lock_owner4 lock_owner; +}; + +/* + * LOCK/LOCKT/LOCKU: Record lock management + */ +struct LOCK4args { + /* CURRENT_FH: file */ + nfs_lock_type4 locktype; + bool reclaim; + offset4 offset; + length4 length; + locker4 locker; +}; + +struct LOCK4denied { + offset4 offset; + length4 length; + nfs_lock_type4 locktype; + lock_owner4 owner; +}; + +struct LOCK4resok { + stateid4 lock_stateid; +}; + +union LOCK4res switch (nfsstat4 status) { + case NFS4_OK: + LOCK4resok resok4; + case NFS4ERR_DENIED: + LOCK4denied denied; + default: + void; +}; + +struct LOCKT4args { + /* CURRENT_FH: file */ + nfs_lock_type4 locktype; + offset4 offset; + length4 length; + lock_owner4 owner; +}; + +union LOCKT4res switch (nfsstat4 status) { + case NFS4ERR_DENIED: + LOCK4denied denied; + case NFS4_OK: + void; + default: + void; +}; + +struct LOCKU4args { + /* CURRENT_FH: file */ + nfs_lock_type4 locktype; + seqid4 seqid; + stateid4 lock_stateid; + offset4 offset; + length4 length; +}; + +union LOCKU4res switch (nfsstat4 status) { + case NFS4_OK: + stateid4 lock_stateid; + default: + void; +}; + +/* + * LOOKUP: Lookup filename + */ +struct LOOKUP4args { + /* CURRENT_FH: directory */ + component4 objname; +}; + +struct LOOKUP4res { + /* CURRENT_FH: object */ + nfsstat4 status; +}; + +/* + * LOOKUPP: Lookup parent directory + */ +struct LOOKUPP4res { + /* CURRENT_FH: directory */ + nfsstat4 status; +}; + +/* + * NVERIFY: Verify attributes different + */ +struct NVERIFY4args { + /* CURRENT_FH: object */ + fattr4 obj_attributes; +}; + +struct NVERIFY4res { + nfsstat4 status; +}; + +/* + * Various definitions for OPEN + */ +enum createmode4 { + UNCHECKED4 = 0, + GUARDED4 = 1, + EXCLUSIVE4 = 2 +}; + +union createhow4 switch (createmode4 mode) { + case UNCHECKED4: + case GUARDED4: + fattr4 createattrs; + case EXCLUSIVE4: + verifier4 createverf; +}; + +enum opentype4 { + OPEN4_NOCREATE = 0, + OPEN4_CREATE = 1 +}; + +union openflag4 switch (opentype4 opentype) { + case OPEN4_CREATE: + createhow4 how; + default: + void; +}; + +/* Next definitions used for OPEN delegation */ +enum limit_by4 { + NFS_LIMIT_SIZE = 1, + NFS_LIMIT_BLOCKS = 2 + /* others as needed */ +}; + +struct nfs_modified_limit4 { + uint32_t num_blocks; + uint32_t bytes_per_block; +}; + +union nfs_space_limit4 switch (limit_by4 limitby) { + /* limit specified as file size */ + case NFS_LIMIT_SIZE: + uint64_t filesize; + /* limit specified by number of blocks */ + case NFS_LIMIT_BLOCKS: + nfs_modified_limit4 mod_blocks; +} ; + +/* + * Share Access and Deny constants for open argument + */ +const OPEN4_SHARE_ACCESS_READ = 0x00000001; +const OPEN4_SHARE_ACCESS_WRITE = 0x00000002; +const OPEN4_SHARE_ACCESS_BOTH = 0x00000003; + +const OPEN4_SHARE_DENY_NONE = 0x00000000; +const OPEN4_SHARE_DENY_READ = 0x00000001; +const OPEN4_SHARE_DENY_WRITE = 0x00000002; +const OPEN4_SHARE_DENY_BOTH = 0x00000003; + +enum open_delegation_type4 { + OPEN_DELEGATE_NONE = 0, + OPEN_DELEGATE_READ = 1, + OPEN_DELEGATE_WRITE = 2 +}; + +enum open_claim_type4 { + CLAIM_NULL = 0, + CLAIM_PREVIOUS = 1, + CLAIM_DELEGATE_CUR = 2, + CLAIM_DELEGATE_PREV = 3, + CLAIM_FH = 4, /* new to v4.1 */ + CLAIM_DELEG_CUR_FH = 5, /* new to v4.1 */ + CLAIM_DELEG_PREV_FH = 6 /* new to v4.1 */ +}; + +struct open_claim_delegate_cur4 { + stateid4 delegate_stateid; + component4 file; +}; + +union open_claim4 switch (open_claim_type4 claim) { + /* + * No special rights to file. Ordinary OPEN of the specified file. + */ + case CLAIM_NULL: + /* CURRENT_FH: directory */ + component4 file; + + /* + * Right to the file established by an open previous to server + * reboot. File identified by filehandle obtained at that time + * rather than by name. + */ + case CLAIM_PREVIOUS: + /* CURRENT_FH: file being reclaimed */ + open_delegation_type4 delegate_type; + + /* + * Right to file based on a delegation granted by the server. + * File is specified by name. + */ + case CLAIM_DELEGATE_CUR: + /* CURRENT_FH: directory */ + open_claim_delegate_cur4 delegate_cur_info; + + /* Right to file based on a delegation granted to a previous boot + * instance of the client. File is specified by name. + */ + case CLAIM_DELEGATE_PREV: + /* CURRENT_FH: directory */ + component4 file_delegate_prev; +}; + +/* + * OPEN: Open a file, potentially receiving an open delegation + */ +struct OPEN4args { + seqid4 seqid; + uint32_t share_access; + uint32_t share_deny; + open_owner4 owner; + openflag4 openhow; + open_claim4 claim; +}; + +struct open_read_delegation4 { + stateid4 stateid; /* Stateid for delegation*/ + bool recall; /* Pre-recalled flag for + delegations obtained + by reclaim + (CLAIM_PREVIOUS) */ + nfsace4 permissions; /* Defines users who don't + need an ACCESS call to + open for read */ +}; + +struct open_write_delegation4 { + stateid4 stateid; /* Stateid for delegation */ + bool recall; /* Pre-recalled flag for + delegations obtained + by reclaim + (CLAIM_PREVIOUS) */ + nfs_space_limit4 space_limit; /* Defines condition that + the client must check to + determine whether the + file needs to be flushed + to the server on close. + */ + nfsace4 permissions; /* Defines users who don't + need an ACCESS call as + part of a delegated + open. */ +}; + +union open_delegation4 +switch (open_delegation_type4 delegation_type) { + case OPEN_DELEGATE_NONE: + void; + case OPEN_DELEGATE_READ: + open_read_delegation4 read; + case OPEN_DELEGATE_WRITE: + open_write_delegation4 write; +}; +/* + * Result flags + */ +/* Client must confirm open */ +const OPEN4_RESULT_CONFIRM = 0x00000002; +/* Type of file locking behavior at the server */ +const OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004; + +struct OPEN4resok { + stateid4 stateid; /* Stateid for open */ + change_info4 cinfo; /* Directory Change Info */ + uint32_t rflags; /* Result flags */ + bitmap4 attrset; /* attribute set for create*/ + open_delegation4 delegation; /* Info on any open + delegation */ +}; + +union OPEN4res switch (nfsstat4 status) { + case NFS4_OK: + /* CURRENT_FH: opened file */ + OPEN4resok resok4; + default: + void; +}; + +/* + * OPENATTR: open named attributes directory + */ +struct OPENATTR4args { + /* CURRENT_FH: object */ + bool createdir; +}; + +struct OPENATTR4res { + /* CURRENT_FH: named attr directory */ + nfsstat4 status; +}; + +/* + * OPEN_CONFIRM: confirm the open + */ +struct OPEN_CONFIRM4args { + /* CURRENT_FH: opened file */ + stateid4 open_stateid; + seqid4 seqid; +}; + +struct OPEN_CONFIRM4resok { + stateid4 open_stateid; +}; + +union OPEN_CONFIRM4res switch (nfsstat4 status) { + case NFS4_OK: + OPEN_CONFIRM4resok resok4; + default: + void; +}; + +/* + * OPEN_DOWNGRADE: downgrade the access/deny for a file + */ +struct OPEN_DOWNGRADE4args { + /* CURRENT_FH: opened file */ + stateid4 open_stateid; + seqid4 seqid; + uint32_t share_access; + uint32_t share_deny; +}; + +struct OPEN_DOWNGRADE4resok { + stateid4 open_stateid; +}; + +union OPEN_DOWNGRADE4res switch(nfsstat4 status) { + case NFS4_OK: + OPEN_DOWNGRADE4resok resok4; + default: + void; +}; + +/* + * PUTFH: Set current filehandle + */ +struct PUTFH4args { + nfs_fh4 object; +}; + +struct PUTFH4res { + /* CURRENT_FH: */ + nfsstat4 status; +}; + +/* + * PUTPUBFH: Set public filehandle + */ +struct PUTPUBFH4res { + /* CURRENT_FH: public fh */ + nfsstat4 status; +}; + +/* + * PUTROOTFH: Set root filehandle + */ +struct PUTROOTFH4res { + + /* CURRENT_FH: root fh */ + nfsstat4 status; +}; + +/* + * READ: Read from file + */ +struct READ4args { + /* CURRENT_FH: file */ + stateid4 stateid; + offset4 offset; + count4 count; +}; + +struct READ4resok { + bool eof; + opaque data<>; +}; + +union READ4res switch (nfsstat4 status) { + case NFS4_OK: + READ4resok resok4; + default: + void; +}; + +/* + * READDIR: Read directory + */ +struct READDIR4args { + /* CURRENT_FH: directory */ + nfs_cookie4 cookie; + verifier4 cookieverf; + count4 dircount; + count4 maxcount; + bitmap4 attr_request; +}; + +struct entry4 { + nfs_cookie4 cookie; + component4 name; + fattr4 attrs; + entry4 *nextentry; +}; + +struct dirlist4 { + entry4 *entries; + bool eof; +}; + +struct READDIR4resok { + verifier4 cookieverf; + dirlist4 reply; +}; + + +union READDIR4res switch (nfsstat4 status) { + case NFS4_OK: + READDIR4resok resok4; + default: + void; +}; + + +/* + * READLINK: Read symbolic link + */ +struct READLINK4resok { + linktext4 link; +}; + +union READLINK4res switch (nfsstat4 status) { + case NFS4_OK: + READLINK4resok resok4; + default: + void; +}; + +/* + * REMOVE: Remove filesystem object + */ +struct REMOVE4args { + /* CURRENT_FH: directory */ + component4 target; +}; + +struct REMOVE4resok { + change_info4 cinfo; +}; + +union REMOVE4res switch (nfsstat4 status) { + case NFS4_OK: + REMOVE4resok resok4; + default: + void; +}; + +/* + * RENAME: Rename directory entry + */ +struct RENAME4args { + /* SAVED_FH: source directory */ + component4 oldname; + /* CURRENT_FH: target directory */ + + component4 newname; +}; + +struct RENAME4resok { + change_info4 source_cinfo; + change_info4 target_cinfo; +}; + +union RENAME4res switch (nfsstat4 status) { + case NFS4_OK: + RENAME4resok resok4; + default: + void; +}; + +/* + * RENEW: Renew a Lease + */ +struct RENEW4args { + clientid4 clientid; +}; + +struct RENEW4res { + nfsstat4 status; +}; + +/* + * RESTOREFH: Restore saved filehandle + */ + +struct RESTOREFH4res { + /* CURRENT_FH: value of saved fh */ + nfsstat4 status; +}; + +/* + * SAVEFH: Save current filehandle + */ +struct SAVEFH4res { + /* SAVED_FH: value of current fh */ + nfsstat4 status; +}; + +/* + * SECINFO: Obtain Available Security Mechanisms + */ +struct SECINFO4args { + component4 name; +}; + +enum rpc_gss_svc_t { + RPC_GSS_SVC_NONE = 1, + RPC_GSS_SVC_INTEGRITY = 2, + RPC_GSS_SVC_PRIVACY = 3 +}; + +struct rpcsec_gss_info { + sec_oid4 oid; + qop4 qop; + rpc_gss_svc_t service; +}; + +const RPCSEC_GSS = 6; + +union secinfo4 switch (uint32_t flavor) { + case RPCSEC_GSS: + rpcsec_gss_info flavor_info; + default: + void; +}; + +typedef secinfo4 SECINFO4resok<>; + +union SECINFO4res switch (nfsstat4 status) { + case NFS4_OK: + SECINFO4resok resok4; + default: + void; +}; + +/* + * SETATTR: Set attributes + */ +struct SETATTR4args { + /* CURRENT_FH: target object */ + stateid4 stateid; + fattr4 obj_attributes; +}; + +struct SETATTR4res { + nfsstat4 status; + bitmap4 attrsset; +}; + +/* + * SETCLIENTID + */ +struct SETCLIENTID4args { + nfs_client_id4 client; + cb_client4 callback; + uint32_t callback_ident; + +}; + +struct SETCLIENTID4resok { + clientid4 clientid; + verifier4 setclientid_confirm; +}; + +union SETCLIENTID4res switch (nfsstat4 status) { + case NFS4_OK: + SETCLIENTID4resok resok4; + case NFS4ERR_CLID_INUSE: + clientaddr4 client_using; + default: + void; +}; + +struct SETCLIENTID_CONFIRM4args { + clientid4 clientid; + verifier4 setclientid_confirm; +}; + +struct SETCLIENTID_CONFIRM4res { + nfsstat4 status; +}; + +/* + * VERIFY: Verify attributes same + */ +struct VERIFY4args { + /* CURRENT_FH: object */ + fattr4 obj_attributes; +}; + +struct VERIFY4res { + nfsstat4 status; +}; + +/* + * WRITE: Write to file + */ +enum stable_how4 { + UNSTABLE4 = 0, + DATA_SYNC4 = 1, + FILE_SYNC4 = 2 +}; + +struct WRITE4args { + /* CURRENT_FH: file */ + stateid4 stateid; + offset4 offset; + stable_how4 stable; + opaque data<>; +}; + +struct WRITE4resok { + count4 count; + stable_how4 committed; + verifier4 writeverf; +}; + +union WRITE4res switch (nfsstat4 status) { + case NFS4_OK: + WRITE4resok resok4; + default: + void; +}; + +/* + * RELEASE_LOCKOWNER: Notify server to release lockowner + */ +struct RELEASE_LOCKOWNER4args { + lock_owner4 lock_owner; +}; + +struct RELEASE_LOCKOWNER4res { + nfsstat4 status; +}; + +/* + * BACKCHANNEL_CTL + */ +/* +typedef opaque gsshandle4_t<>; + +struct gss_cb_handles4 { + rpc_gss_svc_t gcbp_service; RFC 2203 + gsshandle4_t gcbp_handle_from_server; + gsshandle4_t gcbp_handle_from_client; +}; +*/ + +union callback_sec_parms4 switch (uint32_t cb_secflavor) { +case AUTH_NONE: + void; +case AUTH_SYS: + authsys_parms cbsp_sys_cred; /* RFC 1831 */ +/* + * case RPCSEC_GSS: + * gss_cb_handles4 cbsp_gss_handles; + */ +}; + +/* +struct BACKCHANNEL_CTL4args { + uint32_t bca_cb_program; + callback_sec_parms4 bca_sec_parms<>; +}; +*/ + +/* + * CREATE_SESSION + */ +struct channel_attrs4 { + count4 ca_headerpadsize; + count4 ca_maxrequestsize; + count4 ca_maxresponsesize; + count4 ca_maxresponsesize_cached; + count4 ca_maxoperations; + count4 ca_maxrequests; + uint32_t ca_rdma_ird<1>; +}; + +const CREATE_SESSION4_FLAG_PERSIST = 0x00000001; +const CREATE_SESSION4_FLAG_CONN_BACK_CHAN = 0x00000002; +const CREATE_SESSION4_FLAG_CONN_RDMA = 0x00000004; + +struct CREATE_SESSION4args { + clientid4 csa_clientid; + sequenceid4 csa_sequence; + uint32_t csa_flags; + channel_attrs4 csa_fore_chan_attrs; + channel_attrs4 csa_back_chan_attrs; + uint32_t csa_cb_program; + callback_sec_parms4 csa_sec_parms<>; +}; + +struct CREATE_SESSION4resok { + sessionid4 csr_sessionid; + sequenceid4 csr_sequence; + uint32_t csr_flags; + channel_attrs4 csr_fore_chan_attrs; + channel_attrs4 csr_back_chan_attrs; +}; + +union CREATE_SESSION4res switch (nfsstat4 csr_status) { +case NFS4_OK: + CREATE_SESSION4resok csr_resok4; +default: + void; +}; + +/* + * DESTROY_SESSION + */ +struct DESTROY_SESSION4args { + sessionid4 dsa_sessionid; +}; + +struct DESTROY_SESSION4res { + nfsstat4 dsr_status; +}; + +/* + * FREE_STATEID + */ +struct FREE_STATEID4args { + stateid4 fsa_stateid; +}; + +struct FREE_STATEID4res { + nfsstat4 fsr_status; +}; + +/* + * GET_DIR_DELEGATION + */ +typedef nfstime4 attr_notice4; + +struct GET_DIR_DELEGATION4args { + bool gdda_signal_deleg_avail; + bitmap4 gdda_notification_types; + attr_notice4 gdda_child_attr_delay; + attr_notice4 gdda_dir_attr_delay; + bitmap4 gdda_child_attributes; + bitmap4 gdda_dir_attributes; +}; + +struct GET_DIR_DELEGATION4resok { + verifier4 gddr_cookieverf; + stateid4 gddr_stateid; + bitmap4 gddr_notification; + bitmap4 gddr_child_attributes; + bitmap4 gddr_dir_attributes; +}; + +enum gddrnf4_status { + GDD4_OK = 0, + GDD4_UNAVAIL = 1 +}; + +union GET_DIR_DELEGATION4res_non_fatal switch (gddrnf4_status gddrnf_status) { + case GDD4_OK: + GET_DIR_DELEGATION4resok gddrnf_resok4; + case GDD4_UNAVAIL: + bool gddrnf_will_signal_deleg_avail; +}; + +union GET_DIR_DELEGATION4res switch (nfsstat4 gddr_status) { + case NFS4_OK: + GET_DIR_DELEGATION4res_non_fatal gddr_res_non_fatal4; + default: + void; +}; + +/* + * GETDEVICEINFO + */ +struct GETDEVICEINFO4args { + deviceid4 gdia_device_id; + layouttype4 gdia_layout_type; + count4 gdia_maxcount; + bitmap4 gdia_notify_types; +}; + +struct GETDEVICEINFO4resok { + device_addr4 gdir_device_addr; + bitmap4 gdir_notification; +}; + +union GETDEVICEINFO4res switch (nfsstat4 gdir_status) { +case NFS4_OK: + GETDEVICEINFO4resok gdir_resok4; +case NFS4ERR_TOOSMALL: + count4 gdir_mincount; +default: + void; +}; + +/* + * GETDEVICELIST + */ +struct GETDEVICELIST4args { + layouttype4 gdla_layout_type; + count4 gdla_maxdevices; + nfs_cookie4 gdla_cookie; + verifier4 gdla_cookieverf; +}; + +struct GETDEVICELIST4resok { + nfs_cookie4 gdlr_cookie; + verifier4 gdlr_cookieverf; + deviceid4 gdlr_deviceid_list<>; + bool gdlr_eof; +}; + +union GETDEVICELIST4res switch (nfsstat4 gdlr_status) { +case NFS4_OK: + GETDEVICELIST4resok gdlr_resok4; +default: + void; +}; + +/* + * LAYOUTCOMMIT + */ +union newtime4 switch (bool nt_timechanged) { +case TRUE: + nfstime4 nt_time; +case FALSE: + void; +}; + +union newoffset4 switch (bool no_newoffset) { +case TRUE: + offset4 no_offset; +case FALSE: + void; +}; + +struct LAYOUTCOMMIT4args { + offset4 loca_offset; + length4 loca_length; + bool loca_reclaim; + stateid4 loca_stateid; + newoffset4 loca_last_write_offset; + newtime4 loca_time_modify; + layoutupdate4 loca_layoutupdate; +}; + +union newsize4 switch (bool ns_sizechanged) { +case TRUE: + length4 ns_size; +case FALSE: + void; +}; + +struct LAYOUTCOMMIT4resok { + newsize4 locr_newsize; +}; + +union LAYOUTCOMMIT4res switch (nfsstat4 locr_status) { +case NFS4_OK: + LAYOUTCOMMIT4resok locr_resok4; +default: + void; +}; + +/* + * LAYOUTGET + */ +struct LAYOUTGET4args { + bool loga_signal_layout_avail; + layouttype4 loga_layout_type; + layoutiomode4 loga_iomode; + offset4 loga_offset; + length4 loga_length; + length4 loga_minlength; + stateid4 loga_stateid; + count4 loga_maxcount; +}; + +struct LAYOUTGET4resok { + bool logr_return_on_close; + stateid4 logr_stateid; + layout4 logr_layout<>; +}; + +union LAYOUTGET4res switch (nfsstat4 logr_status) { +case NFS4_OK: + LAYOUTGET4resok logr_resok4; +case NFS4ERR_LAYOUTTRYLATER: + bool logr_will_signal_layout_avail; +default: + void; +}; + +/* + * LAYOUTRETURN + */ +const LAYOUT4_RET_REC_FILE = 1; +const LAYOUT4_RET_REC_FSID = 2; +const LAYOUT4_RET_REC_ALL = 3; + +enum layoutreturn_type4 { + LAYOUTRETURN4_FILE = LAYOUT4_RET_REC_FILE, + LAYOUTRETURN4_FSID = LAYOUT4_RET_REC_FSID, + LAYOUTRETURN4_ALL = LAYOUT4_RET_REC_ALL +}; + +struct layoutreturn_file4 { + offset4 lrf_offset; + length4 lrf_length; + stateid4 lrf_stateid; + opaque lrf_body<>; +}; + +union layoutreturn4 switch(layoutreturn_type4 lr_returntype) { + case LAYOUTRETURN4_FILE: + layoutreturn_file4 lr_layout; + default: + void; +}; + +struct LAYOUTRETURN4args { + bool lora_reclaim; + layouttype4 lora_layout_type; + layoutiomode4 lora_iomode; + layoutreturn4 lora_layoutreturn; +}; + +union layoutreturn_stateid switch (bool lrs_present) { +case TRUE: + stateid4 lrs_stateid; +case FALSE: + void; +}; + +union LAYOUTRETURN4res switch (nfsstat4 lorr_status) { +case NFS4_OK: + layoutreturn_stateid lorr_stateid; +default: + void; +}; + +/* + * SECINFO_NO_NAME + */ +enum secinfo_style4 { + SECINFO_STYLE4_CURRENT_FH = 0, + SECINFO_STYLE4_PARENT = 1 +}; + +typedef secinfo_style4 SECINFO_NO_NAME4args; + +typedef SECINFO4res SECINFO_NO_NAME4res; + +/* + * SEQUENCE + */ +struct SEQUENCE4args { + sessionid4 sa_sessionid; + sequenceid4 sa_sequenceid; + slotid4 sa_slotid; + slotid4 sa_highest_slotid; + bool sa_cachethis; +}; + +const SEQ4_STATUS_CB_PATH_DOWN = 0x00000001; +const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING = 0x00000002; +const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED = 0x00000004; +const SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED = 0x00000008; +const SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED = 0x00000010; +const SEQ4_STATUS_ADMIN_STATE_REVOKED = 0x00000020; +const SEQ4_STATUS_RECALLABLE_STATE_REVOKED = 0x00000040; +const SEQ4_STATUS_LEASE_MOVED = 0x00000080; +const SEQ4_STATUS_RESTART_RECLAIM_NEEDED = 0x00000100; +const SEQ4_STATUS_CB_PATH_DOWN_SESSION = 0x00000200; +const SEQ4_STATUS_BACKCHANNEL_FAULT = 0x00000400; +const SEQ4_STATUS_DEVID_CHANGED = 0x00000800; +const SEQ4_STATUS_DEVID_DELETED = 0x00001000; + +struct SEQUENCE4resok { + sessionid4 sr_sessionid; + sequenceid4 sr_sequenceid; + slotid4 sr_slotid; + slotid4 sr_highest_slotid; + slotid4 sr_target_highest_slotid; + uint32_t sr_status_flags; +}; + +union SEQUENCE4res switch (nfsstat4 sr_status) { +case NFS4_OK: + SEQUENCE4resok sr_resok4; +default: + void; +}; + +/* + * SET_SSV + */ +struct ssa_digest_input4 { + SEQUENCE4args sdi_seqargs; +}; + +struct SET_SSV4args { + opaque ssa_ssv<>; + opaque ssa_digest<>; +}; + +struct ssr_digest_input4 { + SEQUENCE4res sdi_seqres; +}; + +struct SET_SSV4resok { + opaque ssr_digest<>; +}; + +union SET_SSV4res switch (nfsstat4 ssr_status) { +case NFS4_OK: + SET_SSV4resok ssr_resok4; +default: + void; +}; + +/* + * TEST_STATEID + */ +struct TEST_STATEID4args { + stateid4 ts_stateids<>; +}; + +struct TEST_STATEID4resok { + nfsstat4 tsr_status_codes<>; +}; + +union TEST_STATEID4res switch (nfsstat4 tsr_status) { + case NFS4_OK: + TEST_STATEID4resok tsr_resok4; + default: + void; +}; + +/* + * WANT_DELEGATION + */ +union deleg_claim4 switch (open_claim_type4 dc_claim) { +case CLAIM_FH: + void; +case CLAIM_DELEG_PREV_FH: + void; +case CLAIM_PREVIOUS: + open_delegation_type4 dc_delegate_type; +}; + +struct WANT_DELEGATION4args { + uint32_t wda_want; + deleg_claim4 wda_claim; +}; + +union WANT_DELEGATION4res switch (nfsstat4 wdr_status) { +case NFS4_OK: + open_delegation4 wdr_resok4; +default: + void; +}; + +/* + * DESTROY_CLIENTID + */ +struct DESTROY_CLIENTID4args { + clientid4 dca_clientid; +}; + +struct DESTROY_CLIENTID4res { + nfsstat4 dcr_status; +}; + +/* + * RECLAIM_COMPLETE + */ +struct RECLAIM_COMPLETE4args { + bool rca_one_fs; +}; + +struct RECLAIM_COMPLETE4res { + nfsstat4 rcr_status; +}; + +/* + * ILLEGAL: Response for illegal operation numbers + */ +struct ILLEGAL4res { + nfsstat4 status; +}; + +/* + * Operation arrays + */ + +enum nfs_opnum4 { + OP_ACCESS = 3, + OP_CLOSE = 4, + OP_COMMIT = 5, + OP_CREATE = 6, + OP_DELEGPURGE = 7, + OP_DELEGRETURN = 8, + OP_GETATTR = 9, + OP_GETFH = 10, + OP_LINK = 11, + OP_LOCK = 12, + OP_LOCKT = 13, + OP_LOCKU = 14, + OP_LOOKUP = 15, + OP_LOOKUPP = 16, + OP_NVERIFY = 17, + OP_OPEN = 18, + OP_OPENATTR = 19, + OP_OPEN_CONFIRM = 20, + OP_OPEN_DOWNGRADE = 21, + OP_PUTFH = 22, + OP_PUTPUBFH = 23, + OP_PUTROOTFH = 24, + OP_READ = 25, + OP_READDIR = 26, + OP_READLINK = 27, + OP_REMOVE = 28, + OP_RENAME = 29, + OP_RENEW = 30, + OP_RESTOREFH = 31, + OP_SAVEFH = 32, + OP_SECINFO = 33, + OP_SETATTR = 34, + OP_SETCLIENTID = 35, + OP_SETCLIENTID_CONFIRM = 36, + OP_VERIFY = 37, + OP_WRITE = 38, + OP_RELEASE_LOCKOWNER = 39, + OP_CREATE_SESSION = 43, + OP_DESTROY_SESSION = 44, + OP_FREE_STATEID = 45, + OP_GET_DIR_DELEGATION = 46, + OP_GETDEVICEINFO = 47, + OP_GETDEVICELIST = 48, + OP_LAYOUTCOMMIT = 49, + OP_LAYOUTGET = 50, + OP_LAYOUTRETURN = 51, + OP_SECINFO_NO_NAME = 52, + OP_SEQUENCE = 53, + OP_SET_SSV = 54, + OP_TEST_STATEID = 55, + OP_WANT_DELEGATION = 56, + OP_DESTROY_CLIENTID = 57, + OP_RECLAIM_COMPLETE = 58, + OP_ILLEGAL = 10044 +}; + +union nfs_argop4 switch (nfs_opnum4 argop) { + case OP_ACCESS: ACCESS4args opaccess; + case OP_CLOSE: CLOSE4args opclose; + case OP_COMMIT: COMMIT4args opcommit; + case OP_CREATE: CREATE4args opcreate; + case OP_DELEGPURGE: DELEGPURGE4args opdelegpurge; + case OP_DELEGRETURN: DELEGRETURN4args opdelegreturn; + case OP_GETATTR: GETATTR4args opgetattr; + case OP_GETFH: void; + case OP_LINK: LINK4args oplink; + case OP_LOCK: LOCK4args oplock; + case OP_LOCKT: LOCKT4args oplockt; + case OP_LOCKU: LOCKU4args oplocku; + case OP_LOOKUP: LOOKUP4args oplookup; + case OP_LOOKUPP: void; + case OP_NVERIFY: NVERIFY4args opnverify; + case OP_OPEN: OPEN4args opopen; + case OP_OPENATTR: OPENATTR4args opopenattr; + case OP_OPEN_CONFIRM: OPEN_CONFIRM4args opopen_confirm; + case OP_OPEN_DOWNGRADE: OPEN_DOWNGRADE4args opopen_downgrade; + case OP_PUTFH: PUTFH4args opputfh; + case OP_PUTPUBFH: void; + case OP_PUTROOTFH: void; + case OP_READ: READ4args opread; + case OP_READDIR: READDIR4args opreaddir; + case OP_READLINK: void; + case OP_REMOVE: REMOVE4args opremove; + case OP_RENAME: RENAME4args oprename; + case OP_RENEW: RENEW4args oprenew; + case OP_RESTOREFH: void; + case OP_SAVEFH: void; + case OP_SECINFO: SECINFO4args opsecinfo; + case OP_SETATTR: SETATTR4args opsetattr; + case OP_SETCLIENTID: SETCLIENTID4args opsetclientid; + case OP_SETCLIENTID_CONFIRM: SETCLIENTID_CONFIRM4args + opsetclientid_confirm; + case OP_VERIFY: VERIFY4args opverify; + case OP_WRITE: WRITE4args opwrite; + case OP_RELEASE_LOCKOWNER: RELEASE_LOCKOWNER4args + oprelease_lockowner; + case OP_CREATE_SESSION: CREATE_SESSION4args opcreatesession; + case OP_DESTROY_SESSION: DESTROY_SESSION4args opdestroysession; + case OP_FREE_STATEID: FREE_STATEID4args opfreestateid; + case OP_GET_DIR_DELEGATION: GET_DIR_DELEGATION4args opgetdirdelegation; + case OP_GETDEVICEINFO: GETDEVICEINFO4args opgetdeviceinfo; + case OP_GETDEVICELIST: GETDEVICELIST4args opgetdevicelist; + case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4args oplayoutcommit; + case OP_LAYOUTGET: LAYOUTGET4args oplayoutget; + case OP_LAYOUTRETURN: LAYOUTRETURN4args oplayoutreturn; + case OP_SECINFO_NO_NAME: SECINFO_NO_NAME4args opsecinfononame; + case OP_SEQUENCE: SEQUENCE4args opsequence; + case OP_SET_SSV: SET_SSV4args opsetssv; + case OP_TEST_STATEID: TEST_STATEID4args opteststateid; + case OP_WANT_DELEGATION: WANT_DELEGATION4args opwantdelegation; + case OP_DESTROY_CLIENTID: DESTROY_CLIENTID4args opdestroyclientid; + case OP_RECLAIM_COMPLETE: RECLAIM_COMPLETE4args opreclaimcomplete; + case OP_ILLEGAL: void; +}; + +union nfs_resop4 switch (nfs_opnum4 resop){ + case OP_ACCESS: ACCESS4res opaccess; + case OP_CLOSE: CLOSE4res opclose; + case OP_COMMIT: COMMIT4res opcommit; + case OP_CREATE: CREATE4res opcreate; + case OP_DELEGPURGE: DELEGPURGE4res opdelegpurge; + case OP_DELEGRETURN: DELEGRETURN4res opdelegreturn; + case OP_GETATTR: GETATTR4res opgetattr; + case OP_GETFH: GETFH4res opgetfh; + case OP_LINK: LINK4res oplink; + case OP_LOCK: LOCK4res oplock; + case OP_LOCKT: LOCKT4res oplockt; + case OP_LOCKU: LOCKU4res oplocku; + case OP_LOOKUP: LOOKUP4res oplookup; + case OP_LOOKUPP: LOOKUPP4res oplookupp; + case OP_NVERIFY: NVERIFY4res opnverify; + case OP_OPEN: OPEN4res opopen; + case OP_OPENATTR: OPENATTR4res opopenattr; + case OP_OPEN_CONFIRM: OPEN_CONFIRM4res opopen_confirm; + case OP_OPEN_DOWNGRADE: OPEN_DOWNGRADE4res opopen_downgrade; + case OP_PUTFH: PUTFH4res opputfh; + case OP_PUTPUBFH: PUTPUBFH4res opputpubfh; + case OP_PUTROOTFH: PUTROOTFH4res opputrootfh; + case OP_READ: READ4res opread; + case OP_READDIR: READDIR4res opreaddir; + case OP_READLINK: READLINK4res opreadlink; + case OP_REMOVE: REMOVE4res opremove; + case OP_RENAME: RENAME4res oprename; + case OP_RENEW: RENEW4res oprenew; + case OP_RESTOREFH: RESTOREFH4res oprestorefh; + case OP_SAVEFH: SAVEFH4res opsavefh; + case OP_SECINFO: SECINFO4res opsecinfo; + case OP_SETATTR: SETATTR4res opsetattr; + case OP_SETCLIENTID: SETCLIENTID4res opsetclientid; + case OP_SETCLIENTID_CONFIRM: SETCLIENTID_CONFIRM4res + opsetclientid_confirm; + case OP_VERIFY: VERIFY4res opverify; + case OP_WRITE: WRITE4res opwrite; + case OP_RELEASE_LOCKOWNER: RELEASE_LOCKOWNER4res + oprelease_lockowner; + case OP_CREATE_SESSION: CREATE_SESSION4res opcreatesession; + case OP_DESTROY_SESSION: DESTROY_SESSION4res opdestroysession; + case OP_FREE_STATEID: FREE_STATEID4res opfreestateid; + case OP_GET_DIR_DELEGATION: GET_DIR_DELEGATION4res opgetdirdelegation; + case OP_GETDEVICEINFO: GETDEVICEINFO4res opgetdeviceinfo; + case OP_GETDEVICELIST: GETDEVICELIST4res opgetdevicelist; + case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4res oplayoutcommit; + case OP_LAYOUTGET: LAYOUTGET4res oplayoutget; + case OP_LAYOUTRETURN: LAYOUTRETURN4res oplayoutreturn; + case OP_SECINFO_NO_NAME: SECINFO_NO_NAME4res opsecinfononame; + case OP_SEQUENCE: SEQUENCE4res opsequence; + case OP_SET_SSV: SET_SSV4res opsetssv; + case OP_TEST_STATEID: TEST_STATEID4res opteststateid; + case OP_WANT_DELEGATION: WANT_DELEGATION4res opwantdelegation; + case OP_DESTROY_CLIENTID: DESTROY_CLIENTID4res opdestroyclientid; + case OP_RECLAIM_COMPLETE: RECLAIM_COMPLETE4res opreclaimcomplete; + case OP_ILLEGAL: ILLEGAL4res opillegal; +}; + +struct COMPOUND4args { + utf8str_cs tag; + uint32_t minorversion; + nfs_argop4 argarray<>; +}; + +struct COMPOUND4res { + nfsstat4 status; + utf8str_cs tag; + nfs_resop4 resarray<>; +}; + +/* + * Remote file service routines + */ +program NFS4_PROGRAM { + version NFS_V4 { + void + NFSPROC4_NULL(void) = 0; + + COMPOUND4res + NFSPROC4_COMPOUND(COMPOUND4args) = 1; + + } = 4; +} = 100003; + + + +/* + * NFS4 Callback Procedure Definitions and Program + */ + +/* + * CB_GETATTR: Get Current Attributes + */ +struct CB_GETATTR4args { + nfs_fh4 fh; + bitmap4 attr_request; +}; + +struct CB_GETATTR4resok { + fattr4 obj_attributes; +}; + +union CB_GETATTR4res switch (nfsstat4 status) { + case NFS4_OK: + CB_GETATTR4resok resok4; + default: + void; +}; + +/* + * CB_RECALL: Recall an Open Delegation + */ +struct CB_RECALL4args { + stateid4 stateid; + bool truncate; + nfs_fh4 fh; +}; + +struct CB_RECALL4res { + nfsstat4 status; +}; + +/* + * CB_ILLEGAL: Response for illegal operation numbers + */ +struct CB_ILLEGAL4res { + nfsstat4 status; +}; + +/* + * Various definitions for CB_COMPOUND + */ +enum nfs_cb_opnum4 { + OP_CB_GETATTR = 3, + OP_CB_RECALL = 4, + OP_CB_ILLEGAL = 10044 +}; + +union nfs_cb_argop4 switch (unsigned argop) { + case OP_CB_GETATTR: CB_GETATTR4args opcbgetattr; + case OP_CB_RECALL: CB_RECALL4args opcbrecall; + case OP_CB_ILLEGAL: void; +}; + +union nfs_cb_resop4 switch (unsigned resop){ + case OP_CB_GETATTR: CB_GETATTR4res opcbgetattr; + case OP_CB_RECALL: CB_RECALL4res opcbrecall; + case OP_CB_ILLEGAL: CB_ILLEGAL4res opcbillegal; +}; + +struct CB_COMPOUND4args { + utf8str_cs tag; + uint32_t minorversion; + uint32_t callback_ident; + nfs_cb_argop4 argarray<>; +}; + +struct CB_COMPOUND4res { + nfsstat4 status; + utf8str_cs tag; + nfs_cb_resop4 resarray<>; +}; + + +/* + * Program number is in the transient range since the client + * will assign the exact transient program number and provide + * that to the server via the SETCLIENTID operation. + */ +program NFS4_CALLBACK { + version NFS_CB { + void + CB_NULL(void) = 0; + CB_COMPOUND4res + CB_COMPOUND(CB_COMPOUND4args) = 1; + } = 1; +} = 0x40000000; diff --git a/server/plugin/plg_backend_nfs4/repo/internal/nfsconst.go b/server/plugin/plg_backend_nfs4/repo/internal/nfsconst.go new file mode 100644 index 00000000..bad92ee0 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/nfsconst.go @@ -0,0 +1,17 @@ +package internal + +/* +const OPEN4_SHARE_ACCESS_READ = 0x00000001 + +const OPEN4_SHARE_ACCESS_WRITE = 0x00000002 + +const OPEN4_SHARE_ACCESS_BOTH = 0x00000003 + +const OPEN4_SHARE_DENY_NONE = 0x00000000 + +const OPEN4_SHARE_DENY_READ = 0x00000001 + +const OPEN4_SHARE_DENY_WRITE = 0x00000002 + +const OPEN4_SHARE_DENY_BOTH = 0x00000003 +*/ diff --git a/server/plugin/plg_backend_nfs4/repo/internal/rpc.go b/server/plugin/plg_backend_nfs4/repo/internal/rpc.go new file mode 100644 index 00000000..6356078f --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/rpc.go @@ -0,0 +1,917 @@ +// Code generated by goxdr -B -p nfs4 nfs4/rpc.x; DO NOT EDIT. + +package internal +import ( + "context" + "fmt" +) + +var _ = fmt.Sprintf +var _ context.Context + +// +// Data types defined in XDR file +// + +type Auth_flavor int32 +const ( + AUTH_NONE Auth_flavor = 0 + AUTH_SYS Auth_flavor = 1 + AUTH_SHORT Auth_flavor = 2 + AUTH_DH Auth_flavor = 3 +) + +type Opaque_auth struct { + Flavor Auth_flavor + Body []byte // bound 400 +} + +type Msg_type int32 +const ( + CALL Msg_type = 0 + REPLY Msg_type = 1 +) + +/* A reply to a call message can take on two forms: the message was + either accepted or rejected. */ +type Reply_stat int32 +const ( + MSG_ACCEPTED Reply_stat = 0 + MSG_DENIED Reply_stat = 1 +) + +/* Given that a call message was accepted, the following is the status + of an attempt to call a remote procedure. */ +type Accept_stat int32 +const ( + /* RPC executed successfully */ + SUCCESS Accept_stat = 0 + /* remote hasn't exported program */ + PROG_UNAVAIL Accept_stat = 1 + /* remote can't support version # */ + PROG_MISMATCH Accept_stat = 2 + /* program can't support procedure */ + PROC_UNAVAIL Accept_stat = 3 + /* procedure can't decode params */ + GARBAGE_ARGS Accept_stat = 4 + /* e.g. memory allocation failure */ + SYSTEM_ERR Accept_stat = 5 +) + +/* Reasons why a call message was rejected: */ +type Reject_stat int32 +const ( + /* RPC version number != 2 */ + RPC_MISMATCH Reject_stat = 0 + /* remote can't authenticate caller */ + AUTH_ERROR Reject_stat = 1 +) + +/* Why authentication failed: */ +type Auth_stat int32 +const ( + /* success */ + AUTH_OK Auth_stat = 0 + /* bad credential (seal broken) */ + AUTH_BADCRED Auth_stat = 1 + /* client must begin new session */ + AUTH_REJECTEDCRED Auth_stat = 2 + /* bad verifier (seal broken) */ + AUTH_BADVERF Auth_stat = 3 + /* verifier expired or replayed */ + AUTH_REJECTEDVERF Auth_stat = 4 + /* rejected for security reasons */ + AUTH_TOOWEAK Auth_stat = 5 + /* bogus response verifier */ + AUTH_INVALIDRESP Auth_stat = 6 + /* reason unknown */ + AUTH_FAILED Auth_stat = 7 + /* kerberos generic error */ + AUTH_KERB_GENERIC Auth_stat = 8 + /* time of credential expired */ + AUTH_TIMEEXPIRE Auth_stat = 9 + /* problem with ticket file */ + AUTH_TKT_FILE Auth_stat = 10 + /* can't decode authenticator */ + AUTH_DECODE Auth_stat = 11 + /* wrong net address in ticket */ + AUTH_NET_ADDR Auth_stat = 12 + /* no credentials for user */ + RPCSEC_GSS_CREDPROBLEM Auth_stat = 13 + /* problem with context */ + RPCSEC_GSS_CTXPROBLEM Auth_stat = 14 +) + +/* Body of an RPC call: */ +type Call_body struct { + /* must be equal to two (2) */ + Rpcvers uint32 + Prog uint32 + Vers uint32 + Proc uint32 + Cred Opaque_auth + Verf Opaque_auth +} + +/* Reply to an RPC call that was accepted by the server: */ +type Accepted_reply struct { + Verf Opaque_auth + Reply_data XdrAnon_Accepted_reply_Reply_data +} +type XdrAnon_Accepted_reply_Reply_data struct { + // The union discriminant Stat selects among the following arms: + // SUCCESS: + // Results() *[0]byte + // PROG_MISMATCH: + // Mismatch_info() *XdrAnon_Accepted_reply_Reply_data_Mismatch_info + // default: + // void + Stat Accept_stat + U interface{} +} +type XdrAnon_Accepted_reply_Reply_data_Mismatch_info struct { + Low uint32 + High uint32 +} + +/* Reply to an RPC call that was rejected by the server: */ +type Rejected_reply struct { + // The union discriminant Stat selects among the following arms: + // RPC_MISMATCH: + // Mismatch_info() *XdrAnon_Rejected_reply_Mismatch_info + // AUTH_ERROR: + // Rj_why() *Auth_stat + Stat Reject_stat + U interface{} +} +type XdrAnon_Rejected_reply_Mismatch_info struct { + Low uint32 + High uint32 +} + +/* Body of a reply to an RPC call: */ +type Reply_body struct { + // The union discriminant Stat selects among the following arms: + // MSG_ACCEPTED: + // Areply() *Accepted_reply + // MSG_DENIED: + // Rreply() *Rejected_reply + Stat Reply_stat + U interface{} +} + +/* The RPC message: */ +type Rpc_msg struct { + Xid uint32 + Body XdrAnon_Rpc_msg_Body +} +type XdrAnon_Rpc_msg_Body struct { + // The union discriminant Mtype selects among the following arms: + // CALL: + // Cbody() *Call_body + // REPLY: + // Rbody() *Reply_body + Mtype Msg_type + U interface{} +} + +// +// Helper types and generated marshaling functions +// + +var _XdrNames_Auth_flavor = map[int32]string{ + int32(AUTH_NONE): "AUTH_NONE", + int32(AUTH_SYS): "AUTH_SYS", + int32(AUTH_SHORT): "AUTH_SHORT", + int32(AUTH_DH): "AUTH_DH", + int32(RPCSEC_GSS): "RPCSEC_GSS", +} +var _XdrValues_Auth_flavor = map[string]int32{ + "AUTH_NONE": int32(AUTH_NONE), + "AUTH_SYS": int32(AUTH_SYS), + "AUTH_SHORT": int32(AUTH_SHORT), + "AUTH_DH": int32(AUTH_DH), + "RPCSEC_GSS": int32(RPCSEC_GSS), +} +func (Auth_flavor) XdrEnumNames() map[int32]string { + return _XdrNames_Auth_flavor +} +func (v Auth_flavor) String() string { + if s, ok := _XdrNames_Auth_flavor[int32(v)]; ok { + return s + } + return fmt.Sprintf("Auth_flavor#%d", v) +} +func (v *Auth_flavor) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Auth_flavor[stok]; ok { + *v = Auth_flavor(val) + return nil + } else if stok == "Auth_flavor" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Auth_flavor.", stok)) + } +} +func (v Auth_flavor) GetU32() uint32 { return uint32(v) } +func (v *Auth_flavor) SetU32(n uint32) { *v = Auth_flavor(n) } +func (v *Auth_flavor) XdrPointer() interface{} { return v } +func (Auth_flavor) XdrTypeName() string { return "Auth_flavor" } +func (v Auth_flavor) XdrValue() interface{} { return v } +func (v *Auth_flavor) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Auth_flavor = *Auth_flavor +func XDR_Auth_flavor(v *Auth_flavor) *Auth_flavor { return v } +type XdrType_Opaque_auth = *Opaque_auth +func (v *Opaque_auth) XdrPointer() interface{} { return v } +func (Opaque_auth) XdrTypeName() string { return "Opaque_auth" } +func (v Opaque_auth) XdrValue() interface{} { return v } +func (v *Opaque_auth) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Opaque_auth) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sflavor", name), XDR_Auth_flavor(&v.Flavor)) + x.Marshal(x.Sprintf("%sbody", name), XdrVecOpaque{&v.Body, 400}) +} +func XDR_Opaque_auth(v *Opaque_auth) *Opaque_auth { return v } +var _XdrNames_Msg_type = map[int32]string{ + int32(CALL): "CALL", + int32(REPLY): "REPLY", +} +var _XdrValues_Msg_type = map[string]int32{ + "CALL": int32(CALL), + "REPLY": int32(REPLY), +} +func (Msg_type) XdrEnumNames() map[int32]string { + return _XdrNames_Msg_type +} +func (v Msg_type) String() string { + if s, ok := _XdrNames_Msg_type[int32(v)]; ok { + return s + } + return fmt.Sprintf("Msg_type#%d", v) +} +func (v *Msg_type) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Msg_type[stok]; ok { + *v = Msg_type(val) + return nil + } else if stok == "Msg_type" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Msg_type.", stok)) + } +} +func (v Msg_type) GetU32() uint32 { return uint32(v) } +func (v *Msg_type) SetU32(n uint32) { *v = Msg_type(n) } +func (v *Msg_type) XdrPointer() interface{} { return v } +func (Msg_type) XdrTypeName() string { return "Msg_type" } +func (v Msg_type) XdrValue() interface{} { return v } +func (v *Msg_type) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Msg_type = *Msg_type +func XDR_Msg_type(v *Msg_type) *Msg_type { return v } +var _XdrNames_Reply_stat = map[int32]string{ + int32(MSG_ACCEPTED): "MSG_ACCEPTED", + int32(MSG_DENIED): "MSG_DENIED", +} +var _XdrValues_Reply_stat = map[string]int32{ + "MSG_ACCEPTED": int32(MSG_ACCEPTED), + "MSG_DENIED": int32(MSG_DENIED), +} +func (Reply_stat) XdrEnumNames() map[int32]string { + return _XdrNames_Reply_stat +} +func (v Reply_stat) String() string { + if s, ok := _XdrNames_Reply_stat[int32(v)]; ok { + return s + } + return fmt.Sprintf("Reply_stat#%d", v) +} +func (v *Reply_stat) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Reply_stat[stok]; ok { + *v = Reply_stat(val) + return nil + } else if stok == "Reply_stat" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Reply_stat.", stok)) + } +} +func (v Reply_stat) GetU32() uint32 { return uint32(v) } +func (v *Reply_stat) SetU32(n uint32) { *v = Reply_stat(n) } +func (v *Reply_stat) XdrPointer() interface{} { return v } +func (Reply_stat) XdrTypeName() string { return "Reply_stat" } +func (v Reply_stat) XdrValue() interface{} { return v } +func (v *Reply_stat) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Reply_stat = *Reply_stat +func XDR_Reply_stat(v *Reply_stat) *Reply_stat { return v } +var _XdrNames_Accept_stat = map[int32]string{ + int32(SUCCESS): "SUCCESS", + int32(PROG_UNAVAIL): "PROG_UNAVAIL", + int32(PROG_MISMATCH): "PROG_MISMATCH", + int32(PROC_UNAVAIL): "PROC_UNAVAIL", + int32(GARBAGE_ARGS): "GARBAGE_ARGS", + int32(SYSTEM_ERR): "SYSTEM_ERR", +} +var _XdrValues_Accept_stat = map[string]int32{ + "SUCCESS": int32(SUCCESS), + "PROG_UNAVAIL": int32(PROG_UNAVAIL), + "PROG_MISMATCH": int32(PROG_MISMATCH), + "PROC_UNAVAIL": int32(PROC_UNAVAIL), + "GARBAGE_ARGS": int32(GARBAGE_ARGS), + "SYSTEM_ERR": int32(SYSTEM_ERR), +} +func (Accept_stat) XdrEnumNames() map[int32]string { + return _XdrNames_Accept_stat +} +func (v Accept_stat) String() string { + if s, ok := _XdrNames_Accept_stat[int32(v)]; ok { + return s + } + return fmt.Sprintf("Accept_stat#%d", v) +} +func (v *Accept_stat) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Accept_stat[stok]; ok { + *v = Accept_stat(val) + return nil + } else if stok == "Accept_stat" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Accept_stat.", stok)) + } +} +func (v Accept_stat) GetU32() uint32 { return uint32(v) } +func (v *Accept_stat) SetU32(n uint32) { *v = Accept_stat(n) } +func (v *Accept_stat) XdrPointer() interface{} { return v } +func (Accept_stat) XdrTypeName() string { return "Accept_stat" } +func (v Accept_stat) XdrValue() interface{} { return v } +func (v *Accept_stat) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Accept_stat = *Accept_stat +func XDR_Accept_stat(v *Accept_stat) *Accept_stat { return v } +var _XdrNames_Reject_stat = map[int32]string{ + int32(RPC_MISMATCH): "RPC_MISMATCH", + int32(AUTH_ERROR): "AUTH_ERROR", +} +var _XdrValues_Reject_stat = map[string]int32{ + "RPC_MISMATCH": int32(RPC_MISMATCH), + "AUTH_ERROR": int32(AUTH_ERROR), +} +func (Reject_stat) XdrEnumNames() map[int32]string { + return _XdrNames_Reject_stat +} +func (v Reject_stat) String() string { + if s, ok := _XdrNames_Reject_stat[int32(v)]; ok { + return s + } + return fmt.Sprintf("Reject_stat#%d", v) +} +func (v *Reject_stat) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Reject_stat[stok]; ok { + *v = Reject_stat(val) + return nil + } else if stok == "Reject_stat" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Reject_stat.", stok)) + } +} +func (v Reject_stat) GetU32() uint32 { return uint32(v) } +func (v *Reject_stat) SetU32(n uint32) { *v = Reject_stat(n) } +func (v *Reject_stat) XdrPointer() interface{} { return v } +func (Reject_stat) XdrTypeName() string { return "Reject_stat" } +func (v Reject_stat) XdrValue() interface{} { return v } +func (v *Reject_stat) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Reject_stat = *Reject_stat +func XDR_Reject_stat(v *Reject_stat) *Reject_stat { return v } +var _XdrNames_Auth_stat = map[int32]string{ + int32(AUTH_OK): "AUTH_OK", + int32(AUTH_BADCRED): "AUTH_BADCRED", + int32(AUTH_REJECTEDCRED): "AUTH_REJECTEDCRED", + int32(AUTH_BADVERF): "AUTH_BADVERF", + int32(AUTH_REJECTEDVERF): "AUTH_REJECTEDVERF", + int32(AUTH_TOOWEAK): "AUTH_TOOWEAK", + int32(AUTH_INVALIDRESP): "AUTH_INVALIDRESP", + int32(AUTH_FAILED): "AUTH_FAILED", + int32(AUTH_KERB_GENERIC): "AUTH_KERB_GENERIC", + int32(AUTH_TIMEEXPIRE): "AUTH_TIMEEXPIRE", + int32(AUTH_TKT_FILE): "AUTH_TKT_FILE", + int32(AUTH_DECODE): "AUTH_DECODE", + int32(AUTH_NET_ADDR): "AUTH_NET_ADDR", + int32(RPCSEC_GSS_CREDPROBLEM): "RPCSEC_GSS_CREDPROBLEM", + int32(RPCSEC_GSS_CTXPROBLEM): "RPCSEC_GSS_CTXPROBLEM", +} +var _XdrValues_Auth_stat = map[string]int32{ + "AUTH_OK": int32(AUTH_OK), + "AUTH_BADCRED": int32(AUTH_BADCRED), + "AUTH_REJECTEDCRED": int32(AUTH_REJECTEDCRED), + "AUTH_BADVERF": int32(AUTH_BADVERF), + "AUTH_REJECTEDVERF": int32(AUTH_REJECTEDVERF), + "AUTH_TOOWEAK": int32(AUTH_TOOWEAK), + "AUTH_INVALIDRESP": int32(AUTH_INVALIDRESP), + "AUTH_FAILED": int32(AUTH_FAILED), + "AUTH_KERB_GENERIC": int32(AUTH_KERB_GENERIC), + "AUTH_TIMEEXPIRE": int32(AUTH_TIMEEXPIRE), + "AUTH_TKT_FILE": int32(AUTH_TKT_FILE), + "AUTH_DECODE": int32(AUTH_DECODE), + "AUTH_NET_ADDR": int32(AUTH_NET_ADDR), + "RPCSEC_GSS_CREDPROBLEM": int32(RPCSEC_GSS_CREDPROBLEM), + "RPCSEC_GSS_CTXPROBLEM": int32(RPCSEC_GSS_CTXPROBLEM), +} +func (Auth_stat) XdrEnumNames() map[int32]string { + return _XdrNames_Auth_stat +} +func (v Auth_stat) String() string { + if s, ok := _XdrNames_Auth_stat[int32(v)]; ok { + return s + } + return fmt.Sprintf("Auth_stat#%d", v) +} +func (v *Auth_stat) Scan(ss fmt.ScanState, _ rune) error { + if tok, err := ss.Token(true, XdrSymChar); err != nil { + return err + } else { + stok := string(tok) + if val, ok := _XdrValues_Auth_stat[stok]; ok { + *v = Auth_stat(val) + return nil + } else if stok == "Auth_stat" { + if n, err := fmt.Fscanf(ss, "#%d", (*int32)(v)); + n == 1 && err == nil { + return nil + } + } + return XdrError(fmt.Sprintf("%s is not a valid Auth_stat.", stok)) + } +} +func (v Auth_stat) GetU32() uint32 { return uint32(v) } +func (v *Auth_stat) SetU32(n uint32) { *v = Auth_stat(n) } +func (v *Auth_stat) XdrPointer() interface{} { return v } +func (Auth_stat) XdrTypeName() string { return "Auth_stat" } +func (v Auth_stat) XdrValue() interface{} { return v } +func (v *Auth_stat) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +type XdrType_Auth_stat = *Auth_stat +func XDR_Auth_stat(v *Auth_stat) *Auth_stat { return v } +type XdrType_Call_body = *Call_body +func (v *Call_body) XdrPointer() interface{} { return v } +func (Call_body) XdrTypeName() string { return "Call_body" } +func (v Call_body) XdrValue() interface{} { return v } +func (v *Call_body) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Call_body) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%srpcvers", name), XDR_uint32(&v.Rpcvers)) + x.Marshal(x.Sprintf("%sprog", name), XDR_uint32(&v.Prog)) + x.Marshal(x.Sprintf("%svers", name), XDR_uint32(&v.Vers)) + x.Marshal(x.Sprintf("%sproc", name), XDR_uint32(&v.Proc)) + x.Marshal(x.Sprintf("%scred", name), XDR_Opaque_auth(&v.Cred)) + x.Marshal(x.Sprintf("%sverf", name), XDR_Opaque_auth(&v.Verf)) +} +func XDR_Call_body(v *Call_body) *Call_body { return v } +type XdrType_XdrAnon_Accepted_reply_Reply_data_Mismatch_info = *XdrAnon_Accepted_reply_Reply_data_Mismatch_info +func (v *XdrAnon_Accepted_reply_Reply_data_Mismatch_info) XdrPointer() interface{} { return v } +func (XdrAnon_Accepted_reply_Reply_data_Mismatch_info) XdrTypeName() string { return "XdrAnon_Accepted_reply_Reply_data_Mismatch_info" } +func (v XdrAnon_Accepted_reply_Reply_data_Mismatch_info) XdrValue() interface{} { return v } +func (v *XdrAnon_Accepted_reply_Reply_data_Mismatch_info) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *XdrAnon_Accepted_reply_Reply_data_Mismatch_info) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slow", name), XDR_uint32(&v.Low)) + x.Marshal(x.Sprintf("%shigh", name), XDR_uint32(&v.High)) +} +func XDR_XdrAnon_Accepted_reply_Reply_data_Mismatch_info(v *XdrAnon_Accepted_reply_Reply_data_Mismatch_info) *XdrAnon_Accepted_reply_Reply_data_Mismatch_info { return v } +type _XdrArray_0_opaque [0]byte +func (v *_XdrArray_0_opaque) GetByteSlice() []byte { return v[:] } +func (v *_XdrArray_0_opaque) XdrTypeName() string { return "opaque[]" } +func (v *_XdrArray_0_opaque) XdrValue() interface{} { return v[:] } +func (v *_XdrArray_0_opaque) XdrPointer() interface{} { return (*[0]byte)(v) } +func (v *_XdrArray_0_opaque) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *_XdrArray_0_opaque) String() string { return fmt.Sprintf("%x", v[:]) } +func (v *_XdrArray_0_opaque) Scan(ss fmt.ScanState, c rune) error { + return XdrArrayOpaqueScan(v[:], ss, c) +} +func (_XdrArray_0_opaque) XdrArraySize() uint32 { + const bound uint32 = 0 // Force error if not const or doesn't fit + return bound +} +func (u *XdrAnon_Accepted_reply_Reply_data) Results() *[0]byte { + switch u.Stat { + case SUCCESS: + if v, ok := u.U.(*[0]byte); ok { + return v + } else { + var zero [0]byte + u.U = &zero + return &zero + } + default: + XdrPanic("XdrAnon_Accepted_reply_Reply_data.Results accessed when Stat == %v", u.Stat) + return nil + } +} +func (u *XdrAnon_Accepted_reply_Reply_data) Mismatch_info() *XdrAnon_Accepted_reply_Reply_data_Mismatch_info { + switch u.Stat { + case PROG_MISMATCH: + if v, ok := u.U.(*XdrAnon_Accepted_reply_Reply_data_Mismatch_info); ok { + return v + } else { + var zero XdrAnon_Accepted_reply_Reply_data_Mismatch_info + u.U = &zero + return &zero + } + default: + XdrPanic("XdrAnon_Accepted_reply_Reply_data.Mismatch_info accessed when Stat == %v", u.Stat) + return nil + } +} +func (u XdrAnon_Accepted_reply_Reply_data) XdrValid() bool { + return true +} +func (u *XdrAnon_Accepted_reply_Reply_data) XdrUnionTag() XdrNum32 { + return XDR_Accept_stat(&u.Stat) +} +func (u *XdrAnon_Accepted_reply_Reply_data) XdrUnionTagName() string { + return "Stat" +} +func (u *XdrAnon_Accepted_reply_Reply_data) XdrUnionBody() XdrType { + switch u.Stat { + case SUCCESS: + return (*_XdrArray_0_opaque)(u.Results()) + case PROG_MISMATCH: + return XDR_XdrAnon_Accepted_reply_Reply_data_Mismatch_info(u.Mismatch_info()) + default: + return nil + } +} +func (u *XdrAnon_Accepted_reply_Reply_data) XdrUnionBodyName() string { + switch u.Stat { + case SUCCESS: + return "Results" + case PROG_MISMATCH: + return "Mismatch_info" + default: + return "" + } +} +type XdrType_XdrAnon_Accepted_reply_Reply_data = *XdrAnon_Accepted_reply_Reply_data +func (v *XdrAnon_Accepted_reply_Reply_data) XdrPointer() interface{} { return v } +func (XdrAnon_Accepted_reply_Reply_data) XdrTypeName() string { return "XdrAnon_Accepted_reply_Reply_data" } +func (v XdrAnon_Accepted_reply_Reply_data) XdrValue() interface{} { return v } +func (v *XdrAnon_Accepted_reply_Reply_data) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *XdrAnon_Accepted_reply_Reply_data) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Accept_stat(&u.Stat).XdrMarshal(x, x.Sprintf("%sstat", name)) + switch u.Stat { + case SUCCESS: + x.Marshal(x.Sprintf("%sresults", name), (*_XdrArray_0_opaque)(u.Results())) + return + case PROG_MISMATCH: + x.Marshal(x.Sprintf("%smismatch_info", name), XDR_XdrAnon_Accepted_reply_Reply_data_Mismatch_info(u.Mismatch_info())) + return + default: + return + } +} +func XDR_XdrAnon_Accepted_reply_Reply_data(v *XdrAnon_Accepted_reply_Reply_data) *XdrAnon_Accepted_reply_Reply_data { return v} +type XdrType_Accepted_reply = *Accepted_reply +func (v *Accepted_reply) XdrPointer() interface{} { return v } +func (Accepted_reply) XdrTypeName() string { return "Accepted_reply" } +func (v Accepted_reply) XdrValue() interface{} { return v } +func (v *Accepted_reply) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Accepted_reply) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sverf", name), XDR_Opaque_auth(&v.Verf)) + x.Marshal(x.Sprintf("%sreply_data", name), XDR_XdrAnon_Accepted_reply_Reply_data(&v.Reply_data)) +} +func XDR_Accepted_reply(v *Accepted_reply) *Accepted_reply { return v } +type XdrType_XdrAnon_Rejected_reply_Mismatch_info = *XdrAnon_Rejected_reply_Mismatch_info +func (v *XdrAnon_Rejected_reply_Mismatch_info) XdrPointer() interface{} { return v } +func (XdrAnon_Rejected_reply_Mismatch_info) XdrTypeName() string { return "XdrAnon_Rejected_reply_Mismatch_info" } +func (v XdrAnon_Rejected_reply_Mismatch_info) XdrValue() interface{} { return v } +func (v *XdrAnon_Rejected_reply_Mismatch_info) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *XdrAnon_Rejected_reply_Mismatch_info) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%slow", name), XDR_uint32(&v.Low)) + x.Marshal(x.Sprintf("%shigh", name), XDR_uint32(&v.High)) +} +func XDR_XdrAnon_Rejected_reply_Mismatch_info(v *XdrAnon_Rejected_reply_Mismatch_info) *XdrAnon_Rejected_reply_Mismatch_info { return v } +var _XdrTags_Rejected_reply = map[int32]bool{ + XdrToI32(RPC_MISMATCH): true, + XdrToI32(AUTH_ERROR): true, +} +func (_ Rejected_reply) XdrValidTags() map[int32]bool { + return _XdrTags_Rejected_reply +} +func (u *Rejected_reply) Mismatch_info() *XdrAnon_Rejected_reply_Mismatch_info { + switch u.Stat { + case RPC_MISMATCH: + if v, ok := u.U.(*XdrAnon_Rejected_reply_Mismatch_info); ok { + return v + } else { + var zero XdrAnon_Rejected_reply_Mismatch_info + u.U = &zero + return &zero + } + default: + XdrPanic("Rejected_reply.Mismatch_info accessed when Stat == %v", u.Stat) + return nil + } +} +func (u *Rejected_reply) Rj_why() *Auth_stat { + switch u.Stat { + case AUTH_ERROR: + if v, ok := u.U.(*Auth_stat); ok { + return v + } else { + var zero Auth_stat + u.U = &zero + return &zero + } + default: + XdrPanic("Rejected_reply.Rj_why accessed when Stat == %v", u.Stat) + return nil + } +} +func (u Rejected_reply) XdrValid() bool { + switch u.Stat { + case RPC_MISMATCH,AUTH_ERROR: + return true + } + return false +} +func (u *Rejected_reply) XdrUnionTag() XdrNum32 { + return XDR_Reject_stat(&u.Stat) +} +func (u *Rejected_reply) XdrUnionTagName() string { + return "Stat" +} +func (u *Rejected_reply) XdrUnionBody() XdrType { + switch u.Stat { + case RPC_MISMATCH: + return XDR_XdrAnon_Rejected_reply_Mismatch_info(u.Mismatch_info()) + case AUTH_ERROR: + return XDR_Auth_stat(u.Rj_why()) + } + return nil +} +func (u *Rejected_reply) XdrUnionBodyName() string { + switch u.Stat { + case RPC_MISMATCH: + return "Mismatch_info" + case AUTH_ERROR: + return "Rj_why" + } + return "" +} +type XdrType_Rejected_reply = *Rejected_reply +func (v *Rejected_reply) XdrPointer() interface{} { return v } +func (Rejected_reply) XdrTypeName() string { return "Rejected_reply" } +func (v Rejected_reply) XdrValue() interface{} { return v } +func (v *Rejected_reply) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Rejected_reply) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Reject_stat(&u.Stat).XdrMarshal(x, x.Sprintf("%sstat", name)) + switch u.Stat { + case RPC_MISMATCH: + x.Marshal(x.Sprintf("%smismatch_info", name), XDR_XdrAnon_Rejected_reply_Mismatch_info(u.Mismatch_info())) + return + case AUTH_ERROR: + x.Marshal(x.Sprintf("%srj_why", name), XDR_Auth_stat(u.Rj_why())) + return + } + XdrPanic("invalid Stat (%v) in Rejected_reply", u.Stat) +} +func XDR_Rejected_reply(v *Rejected_reply) *Rejected_reply { return v} +var _XdrTags_Reply_body = map[int32]bool{ + XdrToI32(MSG_ACCEPTED): true, + XdrToI32(MSG_DENIED): true, +} +func (_ Reply_body) XdrValidTags() map[int32]bool { + return _XdrTags_Reply_body +} +func (u *Reply_body) Areply() *Accepted_reply { + switch u.Stat { + case MSG_ACCEPTED: + if v, ok := u.U.(*Accepted_reply); ok { + return v + } else { + var zero Accepted_reply + u.U = &zero + return &zero + } + default: + XdrPanic("Reply_body.Areply accessed when Stat == %v", u.Stat) + return nil + } +} +func (u *Reply_body) Rreply() *Rejected_reply { + switch u.Stat { + case MSG_DENIED: + if v, ok := u.U.(*Rejected_reply); ok { + return v + } else { + var zero Rejected_reply + u.U = &zero + return &zero + } + default: + XdrPanic("Reply_body.Rreply accessed when Stat == %v", u.Stat) + return nil + } +} +func (u Reply_body) XdrValid() bool { + switch u.Stat { + case MSG_ACCEPTED,MSG_DENIED: + return true + } + return false +} +func (u *Reply_body) XdrUnionTag() XdrNum32 { + return XDR_Reply_stat(&u.Stat) +} +func (u *Reply_body) XdrUnionTagName() string { + return "Stat" +} +func (u *Reply_body) XdrUnionBody() XdrType { + switch u.Stat { + case MSG_ACCEPTED: + return XDR_Accepted_reply(u.Areply()) + case MSG_DENIED: + return XDR_Rejected_reply(u.Rreply()) + } + return nil +} +func (u *Reply_body) XdrUnionBodyName() string { + switch u.Stat { + case MSG_ACCEPTED: + return "Areply" + case MSG_DENIED: + return "Rreply" + } + return "" +} +type XdrType_Reply_body = *Reply_body +func (v *Reply_body) XdrPointer() interface{} { return v } +func (Reply_body) XdrTypeName() string { return "Reply_body" } +func (v Reply_body) XdrValue() interface{} { return v } +func (v *Reply_body) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *Reply_body) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Reply_stat(&u.Stat).XdrMarshal(x, x.Sprintf("%sstat", name)) + switch u.Stat { + case MSG_ACCEPTED: + x.Marshal(x.Sprintf("%sareply", name), XDR_Accepted_reply(u.Areply())) + return + case MSG_DENIED: + x.Marshal(x.Sprintf("%srreply", name), XDR_Rejected_reply(u.Rreply())) + return + } + XdrPanic("invalid Stat (%v) in Reply_body", u.Stat) +} +func XDR_Reply_body(v *Reply_body) *Reply_body { return v} +var _XdrTags_XdrAnon_Rpc_msg_Body = map[int32]bool{ + XdrToI32(CALL): true, + XdrToI32(REPLY): true, +} +func (_ XdrAnon_Rpc_msg_Body) XdrValidTags() map[int32]bool { + return _XdrTags_XdrAnon_Rpc_msg_Body +} +func (u *XdrAnon_Rpc_msg_Body) Cbody() *Call_body { + switch u.Mtype { + case CALL: + if v, ok := u.U.(*Call_body); ok { + return v + } else { + var zero Call_body + u.U = &zero + return &zero + } + default: + XdrPanic("XdrAnon_Rpc_msg_Body.Cbody accessed when Mtype == %v", u.Mtype) + return nil + } +} +func (u *XdrAnon_Rpc_msg_Body) Rbody() *Reply_body { + switch u.Mtype { + case REPLY: + if v, ok := u.U.(*Reply_body); ok { + return v + } else { + var zero Reply_body + u.U = &zero + return &zero + } + default: + XdrPanic("XdrAnon_Rpc_msg_Body.Rbody accessed when Mtype == %v", u.Mtype) + return nil + } +} +func (u XdrAnon_Rpc_msg_Body) XdrValid() bool { + switch u.Mtype { + case CALL,REPLY: + return true + } + return false +} +func (u *XdrAnon_Rpc_msg_Body) XdrUnionTag() XdrNum32 { + return XDR_Msg_type(&u.Mtype) +} +func (u *XdrAnon_Rpc_msg_Body) XdrUnionTagName() string { + return "Mtype" +} +func (u *XdrAnon_Rpc_msg_Body) XdrUnionBody() XdrType { + switch u.Mtype { + case CALL: + return XDR_Call_body(u.Cbody()) + case REPLY: + return XDR_Reply_body(u.Rbody()) + } + return nil +} +func (u *XdrAnon_Rpc_msg_Body) XdrUnionBodyName() string { + switch u.Mtype { + case CALL: + return "Cbody" + case REPLY: + return "Rbody" + } + return "" +} +type XdrType_XdrAnon_Rpc_msg_Body = *XdrAnon_Rpc_msg_Body +func (v *XdrAnon_Rpc_msg_Body) XdrPointer() interface{} { return v } +func (XdrAnon_Rpc_msg_Body) XdrTypeName() string { return "XdrAnon_Rpc_msg_Body" } +func (v XdrAnon_Rpc_msg_Body) XdrValue() interface{} { return v } +func (v *XdrAnon_Rpc_msg_Body) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (u *XdrAnon_Rpc_msg_Body) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + XDR_Msg_type(&u.Mtype).XdrMarshal(x, x.Sprintf("%smtype", name)) + switch u.Mtype { + case CALL: + x.Marshal(x.Sprintf("%scbody", name), XDR_Call_body(u.Cbody())) + return + case REPLY: + x.Marshal(x.Sprintf("%srbody", name), XDR_Reply_body(u.Rbody())) + return + } + XdrPanic("invalid Mtype (%v) in XdrAnon_Rpc_msg_Body", u.Mtype) +} +func XDR_XdrAnon_Rpc_msg_Body(v *XdrAnon_Rpc_msg_Body) *XdrAnon_Rpc_msg_Body { return v} +type XdrType_Rpc_msg = *Rpc_msg +func (v *Rpc_msg) XdrPointer() interface{} { return v } +func (Rpc_msg) XdrTypeName() string { return "Rpc_msg" } +func (v Rpc_msg) XdrValue() interface{} { return v } +func (v *Rpc_msg) XdrMarshal(x XDR, name string) { x.Marshal(name, v) } +func (v *Rpc_msg) XdrRecurse(x XDR, name string) { + if name != "" { + name = x.Sprintf("%s.", name) + } + x.Marshal(x.Sprintf("%sxid", name), XDR_uint32(&v.Xid)) + x.Marshal(x.Sprintf("%sbody", name), XDR_XdrAnon_Rpc_msg_Body(&v.Body)) +} +func XDR_Rpc_msg(v *Rpc_msg) *Rpc_msg { return v } diff --git a/server/plugin/plg_backend_nfs4/repo/internal/rpc.x b/server/plugin/plg_backend_nfs4/repo/internal/rpc.x new file mode 100644 index 00000000..5695b2bd --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/rpc.x @@ -0,0 +1,138 @@ +/* RPC message format as defined by RFC 5531 */ + +enum auth_flavor { + AUTH_NONE = 0, + AUTH_SYS = 1, + AUTH_SHORT = 2, + AUTH_DH = 3, + RPCSEC_GSS = 6 +}; + +struct opaque_auth { + auth_flavor flavor; + opaque body<400>; +}; + +enum msg_type { + CALL = 0, + REPLY = 1 +}; + +/* A reply to a call message can take on two forms: the message was + either accepted or rejected. */ +enum reply_stat { + MSG_ACCEPTED = 0, + MSG_DENIED = 1 +}; + +/* Given that a call message was accepted, the following is the status + of an attempt to call a remote procedure. */ +enum accept_stat { + SUCCESS = 0, /* RPC executed successfully */ + PROG_UNAVAIL = 1, /* remote hasn't exported program */ + PROG_MISMATCH = 2, /* remote can't support version # */ + PROC_UNAVAIL = 3, /* program can't support procedure */ + GARBAGE_ARGS = 4, /* procedure can't decode params */ + SYSTEM_ERR = 5 /* e.g. memory allocation failure */ +}; + +/* Reasons why a call message was rejected: */ +enum reject_stat { + RPC_MISMATCH = 0, /* RPC version number != 2 */ + AUTH_ERROR = 1 /* remote can't authenticate caller */ +}; + +/* Why authentication failed: */ +enum auth_stat { + AUTH_OK = 0, /* success */ + /* + * failed at remote end + */ + AUTH_BADCRED = 1, /* bad credential (seal broken) */ + AUTH_REJECTEDCRED = 2, /* client must begin new session */ + AUTH_BADVERF = 3, /* bad verifier (seal broken) */ + AUTH_REJECTEDVERF = 4, /* verifier expired or replayed */ + AUTH_TOOWEAK = 5, /* rejected for security reasons */ + /* + * failed locally + */ + AUTH_INVALIDRESP = 6, /* bogus response verifier */ + AUTH_FAILED = 7, /* reason unknown */ + /* + * AUTH_KERB errors; deprecated. See [RFC2695] + */ + AUTH_KERB_GENERIC = 8, /* kerberos generic error */ + AUTH_TIMEEXPIRE = 9, /* time of credential expired */ + AUTH_TKT_FILE = 10, /* problem with ticket file */ + AUTH_DECODE = 11, /* can't decode authenticator */ + AUTH_NET_ADDR = 12, /* wrong net address in ticket */ + /* + * RPCSEC_GSS GSS related errors + */ + RPCSEC_GSS_CREDPROBLEM = 13, /* no credentials for user */ + RPCSEC_GSS_CTXPROBLEM = 14 /* problem with context */ +}; + +/* Body of an RPC call: */ +struct call_body { + unsigned int rpcvers; /* must be equal to two (2) */ + unsigned int prog; + unsigned int vers; + unsigned int proc; + opaque_auth cred; + opaque_auth verf; + /* procedure-specific parameters start here */ +}; + +/* Reply to an RPC call that was accepted by the server: */ +struct accepted_reply { + opaque_auth verf; + union switch (accept_stat stat) { + case SUCCESS: + opaque results[0]; + /* + * procedure-specific results start here + */ + case PROG_MISMATCH: + struct { + unsigned int low; + unsigned int high; + } mismatch_info; + default: + /* + * Void. Cases include PROG_UNAVAIL, PROC_UNAVAIL, + * GARBAGE_ARGS, and SYSTEM_ERR. + */ + void; + } reply_data; +}; + +/* Reply to an RPC call that was rejected by the server: */ +union rejected_reply switch (reject_stat stat) { + case RPC_MISMATCH: + struct { + unsigned int low; + unsigned int high; + } mismatch_info; + case AUTH_ERROR: + auth_stat rj_why; +}; + +/* Body of a reply to an RPC call: */ +union reply_body switch (reply_stat stat) { + case MSG_ACCEPTED: + accepted_reply areply; + case MSG_DENIED: + rejected_reply rreply; +}; + +/* The RPC message: */ +struct rpc_msg { + unsigned int xid; + union switch (msg_type mtype) { + case CALL: + call_body cbody; + case REPLY: + reply_body rbody; + } body; +}; diff --git a/server/plugin/plg_backend_nfs4/repo/internal/types.go b/server/plugin/plg_backend_nfs4/repo/internal/types.go new file mode 100644 index 00000000..32dd2a66 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/internal/types.go @@ -0,0 +1,28 @@ +package internal + +//goland:noinspection GoSnakeCaseUsage +type Uint32_t = uint32 +//goland:noinspection GoSnakeCaseUsage +type Uint64_t = uint64 +//goland:noinspection GoSnakeCaseUsage +type Int64_t = int64 + +//goland:noinspection GoSnakeCaseUsage +type XDR_Uint32_t = *XdrUint32 +//goland:noinspection GoSnakeCaseUsage +type XdrType_Uint32_t = XdrType_uint32 +//goland:noinspection GoSnakeCaseUsage +type XDR_Uint64_t = *XdrUint64 +//goland:noinspection GoSnakeCaseUsage +type XdrType_Uint64_t = XdrType_uint64 +//goland:noinspection GoSnakeCaseUsage +type XdrType_Int64_t = XdrType_int64 +//goland:noinspection GoSnakeCaseUsage +type XDR_Int64_t = *XdrInt64 + +func MinUint64(i1, i2 uint64) uint64 { + if i1 < i2 { + return i1 + } + return i2 +} \ No newline at end of file diff --git a/server/plugin/plg_backend_nfs4/repo/nfs4/client.go b/server/plugin/plg_backend_nfs4/repo/nfs4/client.go new file mode 100644 index 00000000..85091a7f --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/nfs4/client.go @@ -0,0 +1,903 @@ +package nfs4 + +import ( + "bytes" + "context" + "crypto/rand" + "encoding/binary" + "encoding/hex" + "fmt" + "io" + "math" + "net" + "os" + "strings" + "time" + + . "github.com/mickael-kerjean/filestash/server/plugin/plg_backend_nfs4/repo/internal" +) + +const NfsReadBlockLen = 512 * 1024 + +var standardNfsAttrs = Bitmap4{ + 1< 255 { + machName = machName[0:255] + } + + ap := Authsys_parms{ + Machinename: machName, + Uid: auth.Uid, + Gid: auth.Gid, + Gids: nil, + } + + // Fill the machine ID (needs not to be super-unique but nice to have them distinct) + _ = binary.Read(rand.Reader, binary.LittleEndian, &ap.Stamp) + + apBuf := bytes.NewBuffer([]byte{}) + XdrOut{Out: apBuf}.Marshal("", &ap) + + return apBuf.Bytes() +} + +func (c *NfsClient) sendMessage(proc XdrProc) (xid uint32, err error) { + xid = c.xid + c.xid++ + + msg := Rpc_msg{ + Xid: xid, + Body: XdrAnon_Rpc_msg_Body{ + Mtype: CALL, + U: &Call_body{ + Rpcvers: 2, + Prog: proc.Prog(), + Vers: proc.Vers(), + Proc: proc.Proc(), + Cred: Opaque_auth{ + Flavor: c.authType, + Body: c.authData, + }, + Verf: Opaque_auth{ + Flavor: AUTH_NONE, + }, + }, + }, + } + + // The marshaller for some reason loves to panic. + defer func() { + if i := recover(); i != nil { + if e, ok := i.(XdrError); ok { + err = e + } else { + panic(i) + } + } + }() + + buffer := bytes.NewBuffer([]byte{}) + out := XdrOut{Out: buffer} + out.Marshal("", &msg) + if _, ok := proc.GetArg().(XdrType_void); !ok { + out.Marshal("", proc.GetArg()) + } + + // Yep, the RPC protocol requires this strange OR + err = binary.Write(c.conn, binary.BigEndian, 0x80000000|uint32(buffer.Len())) + if err != nil { + return + } + _, err = c.conn.Write(buffer.Bytes()) + if err != nil { + return + } + + return +} + +func (c *NfsClient) readNfsMessage(result XdrType) (xid uint32, err error) { + lenBuf := make([]byte, 4) + _, err = io.ReadFull(c.conn, lenBuf) + if err != nil { + return + } + // The RPC protocol sets the MSB to 1 for length fields. Don't ask me why. + msgLen := binary.BigEndian.Uint32(lenBuf) & 0x7fffffff + + msgBuf := make([]byte, msgLen) + _, err = io.ReadFull(c.conn, msgBuf) + if err != nil { + return + } + + // The unmarshaller for some reason loves to panic. Sigh. + defer func() { + if i := recover(); i != nil { + if e, ok := i.(XdrError); ok { + err = e + } else { + panic(i) + } + } + }() + + reply := Rpc_msg{} + in := XdrIn{In: bytes.NewReader(msgBuf)} + in.Marshal("", &reply) + if _, ok := result.(XdrType_void); !ok { + in.Marshal("", result) + } + + if !c.isRpcSuccess(&reply) { + err = fmt.Errorf("RPC error: %s", c.getRpcError(&reply)) + return + } + xid = reply.Xid + + return +} + +// Returns true iff msg is an accepted REPLY with status SUCCESS. +func (c *NfsClient) isRpcSuccess(msg *Rpc_msg) bool { + return msg != nil && + msg.Body.Mtype == REPLY && + msg.Body.Rbody().Stat == MSG_ACCEPTED && + msg.Body.Rbody().Areply().Reply_data.Stat == SUCCESS +} + +// An *Rpc_msg can represent an error. Call IsSuccess to see if there +// was actually an error. +func (c *NfsClient) getRpcError(m *Rpc_msg) string { + if m.Body.Mtype != REPLY { + return "RPC message not a REPLY" + } else if m.Body.Rbody().Stat == MSG_ACCEPTED { + stat := m.Body.Rbody().Areply().Reply_data.Stat + c := stat.String() + if stat == PROG_MISMATCH { + mmi := m.Body.Rbody().Areply().Reply_data.Mismatch_info() + c = fmt.Sprintf("%s (low %d, high %d)", c, mmi.Low, mmi.High) + } + return c + } else if m.Body.Rbody().Stat == MSG_DENIED { + stat := m.Body.Rbody().Rreply().Stat + c := stat.String() + return c + } + return "Invalid reply_stat" +} + +func (c *NfsClient) Ping() error { + nullProc := XdrProc_NFSPROC4_NULL{} + + xid, err := c.sendMessage(&nullProc) + if err != nil { + return err + } + xidRes, err := c.readNfsMessage(nullProc.GetRes()) + if err != nil { + return err + } + if xidRes != xid { + return fmt.Errorf("mismathced xids: %d and %d", xid, xidRes) + } + + return nil +} + +func (c *NfsClient) runNfsTransaction(ops []Nfs_argop4, pathHint string) ([]Nfs_resop4, error) { + compound := XdrProc_NFSPROC4_COMPOUND{} + + args := compound.GetArg().(*COMPOUND4args) + args.Argarray = ops + + xid, err := c.sendMessage(&compound) + if err != nil { + return nil, err + } + xid2, err := c.readNfsMessage(compound.GetRes()) + if err != nil { + return nil, err + } + if xid != xid2 { + return nil, fmt.Errorf("xids don't match: %d and %d", xid, xid2) + } + + res := compound.GetRes().(*COMPOUND4res) + // TODO: translate the error better + if res.Status != NFS4_OK { + return nil, &NfsError{ + Path: pathHint, + ErrorCode: NfsErrorCode(res.Status), + ErrorString: fmt.Sprintf("NFS error: %s (%d), path='%s'", + res.Status.String(), int32(res.Status), pathHint), + } + } + + return res.Resarray, nil +} + +func (c *NfsClient) setClientId() error { + res, err := c.runNfsTransaction([]Nfs_argop4{{ + Argop: OP_SETCLIENTID, + U: &SETCLIENTID4args{ + Client: Nfs_client_id4{ + Verifier: Verifier4{}, + Id: []byte(c.clientId), + }, + Callback: Cb_client4{}, + Callback_ident: 0, + }, + }}, "") + if err != nil { + return err + } + + resOk := res[0].Opsetclientid().Resok4() + c.clientIdShort = resOk.Clientid + + _, err = c.runNfsTransaction([]Nfs_argop4{{ + Argop: OP_SETCLIENTID_CONFIRM, + U: &SETCLIENTID_CONFIRM4args{ + Clientid: resOk.Clientid, + Setclientid_confirm: resOk.Setclientid_confirm, + }, + }}, "") + if err != nil { + return err + } + + return nil +} + +func (c *NfsClient) retrieveRootFh() error { + res, err := c.runNfsTransaction([]Nfs_argop4{ + { + Argop: OP_PUTROOTFH, + }, + { + Argop: OP_GETFH, + }, + }, "/") + if err != nil { + return err + } + c.rootFh = res[1].Opgetfh().Resok4().Object + return nil +} + +func splitPath(path string) []string { + splits := strings.Split(path, "/") + curPos := 0 + for _, s := range splits { + if s == "" { + continue + } + splits[curPos] = s + curPos++ + } + return splits[0:curPos] +} + +func (c *NfsClient) GetFileList(path string) ([]FileInfo, error) { + var args = c.makePathLookupArgs(splitPath(path)) + + args = append(args, + Nfs_argop4{Argop: OP_GETFH}, + Nfs_argop4{Argop: OP_READDIR, + U: &READDIR4args{ + Cookie: 0, + Cookieverf: Verifier4{}, + Dircount: 1024 * 128, + Maxcount: 1024 * 128, + Attr_request: standardNfsAttrs, + }}, + ) + + res, err := c.runNfsTransaction(args, path) + if err != nil { + return nil, err + } + + var fileList []FileInfo + + dirFh := res[len(res)-2].Opgetfh().Resok4().Object + + curDirList := res[len(res)-1].Opreaddir().Resok4() + for { + ent := curDirList.Reply.Entries + if ent == nil { + break + } + for { + fileList = append(fileList, c.translateFileMeta(string(ent.Name), ent.Attrs)) + if ent.Nextentry == nil { + break + } + ent = ent.Nextentry + } + + if curDirList.Reply.Eof { + break + } + res, err := c.runNfsTransaction([]Nfs_argop4{ + { + Argop: OP_PUTFH, + U: &PUTFH4args{Object: dirFh}, + }, + { + Argop: OP_READDIR, + U: &READDIR4args{ + Cookie: ent.Cookie, + Cookieverf: curDirList.Cookieverf, + Dircount: 1024 * 128, + Maxcount: 1024 * 128, + Attr_request: standardNfsAttrs, + }, + }, + }, path) + if err != nil { + return nil, err + } + curDirList = res[1].Opreaddir().Resok4() + } + + return fileList, nil +} + +// Make the commands to navigate the path to its leaf +func (c *NfsClient) makePathLookupArgs(path []string) []Nfs_argop4 { + var args []Nfs_argop4 + args = append(args, Nfs_argop4{Argop: OP_PUTROOTFH}) + + // Add lookups for the path components + for _, p := range path { + args = append(args, Nfs_argop4{ + Argop: OP_LOOKUP, + U: &LOOKUP4args{Objname: Component4(p)}, + }) + } + return args +} + +func (c *NfsClient) translateFileMeta(name string, attrs Fattr4) FileInfo { + res := FileInfo{ + Name: name, + } + + curOff := 0 + + atm := attrs.Attrmask + if len(atm) > 0 && atm[0]&(1< 0 && atm[0]&(1< 1 && atm[1]&(1<<(FATTR4_TIME_MODIFY-32)) != 0 { + mtimeSec := binary.BigEndian.Uint64(attrs.Attr_vals[curOff : curOff+8]) + curOff += 8 + + mtimeNsec := binary.BigEndian.Uint32(attrs.Attr_vals[curOff : curOff+4]) + curOff += 4 + + // I hope this works for times before 1970-01-01... + res.Mtime = time.Unix(int64(mtimeSec), int64(mtimeNsec)) + } + + return res +} + +func (c *NfsClient) GetFileInfo(path string) (FileInfo, error) { + args := c.makePathLookupArgs(splitPath(path)) + args = append(args, + Nfs_argop4{ + Argop: OP_GETATTR, + U: &GETATTR4args{ + Attr_request: standardNfsAttrs, + }, + }) + + res, err := c.runNfsTransaction(args, path) + if err != nil { + return FileInfo{}, err + } + + splits := splitPath(path) + var name string + if len(splits) == 1 { + name = path + } else { + name = splits[len(splits)-1] + } + + resInfo := c.translateFileMeta(name, + res[len(res)-1].Opgetattr().Resok4().Obj_attributes) + return resInfo, nil +} + +func (c *NfsClient) ReadFileAll(path string, writer io.Writer) (uint64, error) { + return c.ReadFile(path, 0, math.MaxUint64, writer) +} + +func (c *NfsClient) ReadFile(path string, offset, count uint64, writer io.Writer) (uint64, error) { + anonymousStateId := Stateid4{} + args := c.makePathLookupArgs(splitPath(path)) + + args = append(args, + Nfs_argop4{Argop: OP_GETFH}, + Nfs_argop4{ + Argop: OP_READ, + U: &READ4args{ + Stateid: anonymousStateId, + Offset: offset, + Count: Count4(MinUint64(NfsReadBlockLen, count)), + }, + }) + + res, err := c.runNfsTransaction(args, path) + if err != nil { + return 0, err + } + flDataBlock := res[len(res)-1].Opread().Resok4() + fileFh := res[len(res)-2].Opgetfh().Resok4().Object + + var dataRead uint64 + for { + _, err := writer.Write(flDataBlock.Data) + if err != nil { + return 0, err + } + ln := len(flDataBlock.Data) + offset += uint64(ln) + count -= uint64(ln) + dataRead += uint64(ln) + if flDataBlock.Eof || count == 0 { + break + } + + // Get the next file block + res, err := c.runNfsTransaction([]Nfs_argop4{ + { + Argop: OP_PUTFH, + U: &PUTFH4args{Object: fileFh}, + }, + { + Argop: OP_READ, + U: &READ4args{ + Stateid: anonymousStateId, + Offset: offset, + Count: Count4(MinUint64(NfsReadBlockLen, count)), + }, + }, + }, path) + if err != nil { + return 0, err + } + flDataBlock = res[1].Opread().Resok4() + } + + return dataRead, nil +} + +func (c *NfsClient) openFileForWrite(path string, truncate bool) (Stateid4, Nfs_fh4, error) { + splits := splitPath(path) + + // Put the directory FH as the current one + args := c.makePathLookupArgs(splits[0 : len(splits)-1]) + // Make the file claim (i.e. the file name on top of the directory FH) + flClaim := Component4(splits[len(splits)-1]) + + var fileAttrs Fattr4 + if truncate { + // Set the file size and mode (Unix access mask) + fileAttrs.Attr_vals = make([]byte, 12) + // This file size is set to 0 + binary.BigEndian.PutUint32(fileAttrs.Attr_vals[8:], MODE4_WUSR|MODE4_RUSR|MODE4_WGRP|MODE4_RGRP) + fileAttrs.Attrmask = Bitmap4{1 << FATTR4_SIZE, 1 << (FATTR4_MODE - 32)} + } else { + // Set the file mode (Unix access mask) + fileAttrs.Attr_vals = make([]byte, 4) + binary.BigEndian.PutUint32(fileAttrs.Attr_vals, MODE4_WUSR|MODE4_RUSR|MODE4_WGRP|MODE4_RGRP) + fileAttrs.Attrmask = Bitmap4{0, 1 << (FATTR4_MODE - 32)} + } + + args = append(args, + Nfs_argop4{ + Argop: OP_OPEN, + U: &OPEN4args{ + Seqid: c.nfsSeqId, + Share_access: OPEN4_SHARE_ACCESS_WRITE, + Share_deny: OPEN4_SHARE_DENY_NONE, + Owner: Open_owner4{ + Clientid: c.clientIdShort, + Owner: []byte(c.clientId), + }, + Openhow: Openflag4{ + Opentype: OPEN4_CREATE, + U: &Createhow4{ + Mode: UNCHECKED4, + U: &fileAttrs, + }, + }, + Claim: Open_claim4{ + Claim: CLAIM_NULL, + U: &flClaim, + }, + }, + }, + Nfs_argop4{ + Argop: OP_GETFH, + }) + + res, err := c.runNfsTransaction(args, path) + c.incrementNfsSeq(err) + if err != nil { + return Stateid4{}, Nfs_fh4{}, err + } + + openRes := res[len(res)-2].Opopen().Resok4() + openFh := res[len(res)-1].Opgetfh().Resok4().Object + + // We need to confirm the opened file receipt the first time we run the operation + if !c.openConfirmed { + res, err = c.runNfsTransaction([]Nfs_argop4{ + { + Argop: OP_PUTFH, + U: &PUTFH4args{Object: openFh}, + }, + { + Argop: OP_OPEN_CONFIRM, + U: &OPEN_CONFIRM4args{ + Open_stateid: openRes.Stateid, + Seqid: c.nfsSeqId, + }, + }, + }, path) + c.incrementNfsSeq(err) + if err != nil { + return Stateid4{}, Nfs_fh4{}, err + } + c.openConfirmed = true + return res[len(res)-1].Opopen_confirm().Resok4().Open_stateid, openFh, nil + } + + return openRes.Stateid, openFh, nil +} + +func (c *NfsClient) closeFile(stateId Stateid4, fh Nfs_fh4, path string) error { + _, err := c.runNfsTransaction([]Nfs_argop4{ + { + Argop: OP_PUTFH, + U: &PUTFH4args{Object: fh}, + }, + { + Argop: OP_CLOSE, + U: &CLOSE4args{ + Open_stateid: stateId, + Seqid: c.nfsSeqId, + }, + }, + }, path) + c.incrementNfsSeq(err) + + if err != nil { + return err + } + + return nil +} + +func (c *NfsClient) ReWriteFile(path string, reader io.Reader) (written uint64, err error) { + return c.WriteFile(path, true, 0, reader) +} + +func (c *NfsClient) WriteFile(path string, truncate bool, offset uint64, + reader io.Reader) (written uint64, err error) { + + stateId, fh, err := c.openFileForWrite(path, truncate) + if err != nil { + return + } + defer func() { + err = c.closeFile(stateId, fh, path) + }() + + block := make([]byte, NfsReadBlockLen) + for { + var curRead int + curRead, err = reader.Read(block) + if curRead == 0 || err == io.EOF { + break + } + if err != nil { + return + } + + // Write the block! + err = c.writeBlock(stateId, fh, written+offset, block[0:curRead], path) + if err != nil { + return + } + + written += uint64(curRead) + } + + return +} + +func (c *NfsClient) writeBlock(id Stateid4, fh Nfs_fh4, offset uint64, data []byte, path string) error { + for len(data) > 0 { + res, err := c.runNfsTransaction([]Nfs_argop4{ + { + Argop: OP_PUTFH, + U: &PUTFH4args{Object: fh}, + }, + { + Argop: OP_WRITE, + U: &WRITE4args{ + Stateid: id, + Offset: offset, + Stable: UNSTABLE4, + Data: data, + }, + }, + }, path) + + if err != nil { + return err + } + + written := res[1].Opwrite().Resok4().Count + data = data[written:] + } + + return nil +} + +func (c *NfsClient) DeleteFile(path string) error { + splits := splitPath(path) + // Put the directory FH as the current one + args := c.makePathLookupArgs(splits[0 : len(splits)-1]) + // Make the file claim (i.e. the file name on top of the directory FH) + flClaim := Component4(splits[len(splits)-1]) + + args = append(args, + Nfs_argop4{ + Argop: OP_REMOVE, + U: &REMOVE4args{ + Target: flClaim, + }, + }) + + _, err := c.runNfsTransaction(args, path) + if err != nil { + return err + } + + return nil +} + +func (c *NfsClient) MakePath(path string) error { + curPath := "" + var curPathElems []string + + for _, curElem := range splitPath(path) { + if curPath != "" { + curPath += "/" + } + curPath += curElem + curPathElems = append(curPathElems, curElem) + + fi, err := c.GetFileInfo(curPath) + if err == nil && !fi.IsDir { + return &NfsError{ + ErrorCode: ERROR_NOTDIR, + ErrorString: fmt.Sprintf("NFS error: should be a directory (%d), path='%s'", + ERROR_NOTDIR, curPath), + Path: curPath, + } + } + + if err != nil { + if IsNfsError(err, ERROR_NOENT) { + args := c.makePathLookupArgs(curPathElems[0 : len(curPathElems)-1]) + // Make the file claim (i.e. the file name on top of the directory FH) + flClaim := Component4(curElem) + + // Set the file mode (Unix access mask) + var dirAttrs Fattr4 + dirAttrs.Attr_vals = make([]byte, 4) + binary.BigEndian.PutUint32(dirAttrs.Attr_vals, + MODE4_WUSR|MODE4_RUSR|MODE4_XUSR|MODE4_WGRP|MODE4_RGRP|MODE4_XGRP) + dirAttrs.Attrmask = Bitmap4{0, 1 << (FATTR4_MODE - 32)} + + args = append(args, + Nfs_argop4{ + Argop: OP_CREATE, + U: &CREATE4args{ + Objtype: Createtype4{ + Type: NF4DIR, + }, + Objname: flClaim, + Createattrs: dirAttrs, + }, + }) + _, err := c.runNfsTransaction(args, curPath) + if err != nil { + return err + } + } else { + return err + } + } + } + + return nil +} + +// Increment NFS sequence ID for all operations, even the ones that return +// errors, except for a pre-defined list in https://tools.ietf.org/html/rfc3530#section-8.1.5 +func (c *NfsClient) incrementNfsSeq(err error) { + if err == nil { + c.nfsSeqId++ + return + } + + nfsErr, ok := err.(*NfsError) + if !ok { + c.nfsSeqId++ + return + } + + switch Nfsstat4(nfsErr.ErrorCode) { + case + NFS4ERR_STALE_CLIENTID, NFS4ERR_STALE_STATEID, + NFS4ERR_BAD_STATEID, NFS4ERR_BAD_SEQID, NFS4ERR_BADXDR, + NFS4ERR_RESOURCE, NFS4ERR_NOFILEHANDLE: + return + default: + c.nfsSeqId++ + } +} + +func RemoveRecursive(nfs NfsInterface, path string) error { + list, err := nfs.GetFileList(path) + if IsNfsError(err, ERROR_NOENT) { + return nil + } + if err != nil { + return err + } + + for _, fl := range list { + curPath := path + "/" + fl.Name + if fl.IsDir { + err = RemoveRecursive(nfs, curPath) + if err != nil { + return err + } + } else { + err = nfs.DeleteFile(curPath) + if err != nil { + return err + } + } + } + + err = nfs.DeleteFile(path) + if err != nil { + return err + } + + return nil +} diff --git a/server/plugin/plg_backend_nfs4/repo/nfs4/nfs_err.go b/server/plugin/plg_backend_nfs4/repo/nfs4/nfs_err.go new file mode 100644 index 00000000..7ea50fd6 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/nfs4/nfs_err.go @@ -0,0 +1,153 @@ +package nfs4 + +type NfsError struct { + Path string + ErrorCode NfsErrorCode + ErrorString string +} + +func (n *NfsError) Error() string { + return n.ErrorString +} + +func IsNfsError(err error, code NfsErrorCode) bool { + ne, ok := err.(*NfsError) + return ok && ne.ErrorCode == code +} + +/* + * Error status. See https://www.rfc-editor.org/rfc/rfc7530 + */ +type NfsErrorCode int32 +const ( + /* everything is okay */ + OK NfsErrorCode = 0 + /* caller not privileged */ + ERROR_PERM NfsErrorCode = 1 + /* no such file/directory */ + ERROR_NOENT NfsErrorCode = 2 + /* hard I/O error */ + ERROR_IO NfsErrorCode = 5 + /* no such device */ + ERROR_NXIO NfsErrorCode = 6 + /* access denied */ + ERROR_ACCESS NfsErrorCode = 13 + /* file already exists */ + ERROR_EXIST NfsErrorCode = 17 + /* different filesystems */ + ERROR_XDEV NfsErrorCode = 18 + /* should be a directory */ + ERROR_NOTDIR NfsErrorCode = 20 + /* should not be directory */ + ERROR_ISDIR NfsErrorCode = 21 + /* invalid argument */ + ERROR_INVAL NfsErrorCode = 22 + /* file exceeds server max */ + ERROR_FBIG NfsErrorCode = 27 + /* no space on filesystem */ + ERROR_NOSPC NfsErrorCode = 28 + /* read-only filesystem */ + ERROR_ROFS NfsErrorCode = 30 + /* too many hard links */ + ERROR_MLINK NfsErrorCode = 31 + /* name exceeds server max */ + ERROR_NAMETOOLONG NfsErrorCode = 63 + /* directory not empty */ + ERROR_NOTEMPTY NfsErrorCode = 66 + /* hard quota limit reached*/ + ERROR_DQUOT NfsErrorCode = 69 + /* file no longer exists */ + ERROR_STALE NfsErrorCode = 70 + /* Illegal filehandle */ + ERROR_BADHANDLE NfsErrorCode = 10001 + /* READDIR cookie is stale */ + ERROR_BAD_COOKIE NfsErrorCode = 10003 + /* operation not supported */ + ERROR_NOTSUPP NfsErrorCode = 10004 + /* response limit exceeded */ + ERROR_TOOSMALL NfsErrorCode = 10005 + /* undefined server error */ + ERROR_SERVERFAULT NfsErrorCode = 10006 + /* type invalid for CREATE */ + ERROR_BADTYPE NfsErrorCode = 10007 + /* file "busy" - retry */ + ERROR_DELAY NfsErrorCode = 10008 + /* nverify says attrs same */ + ERROR_SAME NfsErrorCode = 10009 + /* lock unavailable */ + ERROR_DENIED NfsErrorCode = 10010 + /* lock lease expired */ + ERROR_EXPIRED NfsErrorCode = 10011 + /* I/O failed due to lock */ + ERROR_LOCKED NfsErrorCode = 10012 + /* in grace period */ + ERROR_GRACE NfsErrorCode = 10013 + /* filehandle expired */ + ERROR_FHEXPIRED NfsErrorCode = 10014 + /* share reserve denied */ + ERROR_SHARE_DENIED NfsErrorCode = 10015 + /* wrong security flavor */ + ERROR_WRONGSEC NfsErrorCode = 10016 + /* clientid in use */ + ERROR_CLID_INUSE NfsErrorCode = 10017 + /* resource exhaustion */ + ERROR_RESOURCE NfsErrorCode = 10018 + /* filesystem relocated */ + ERROR_MOVED NfsErrorCode = 10019 + /* current FH is not set */ + ERROR_NOFILEHANDLE NfsErrorCode = 10020 + /* minor vers not supp */ + ERROR_MINOR_VERS_MISMATCH NfsErrorCode = 10021 + /* server has rebooted */ + ERROR_STALE_CLIENTID NfsErrorCode = 10022 + /* server has rebooted */ + ERROR_STALE_STATEID NfsErrorCode = 10023 + /* state is out of sync */ + ERROR_OLD_STATEID NfsErrorCode = 10024 + /* incorrect stateid */ + ERROR_BAD_STATEID NfsErrorCode = 10025 + /* request is out of seq. */ + ERROR_BAD_SEQID NfsErrorCode = 10026 + /* verify - attrs not same */ + ERROR_NOT_SAME NfsErrorCode = 10027 + /* lock range not supported*/ + ERROR_LOCK_RANGE NfsErrorCode = 10028 + /* should be file/directory*/ + ERROR_SYMLINK NfsErrorCode = 10029 + /* no saved filehandle */ + ERROR_RESTOREFH NfsErrorCode = 10030 + /* some filesystem moved */ + ERROR_LEASE_MOVED NfsErrorCode = 10031 + /* recommended attr not sup*/ + ERROR_ATTRNOTSUPP NfsErrorCode = 10032 + /* reclaim outside of grace*/ + ERROR_NO_GRACE NfsErrorCode = 10033 + /* reclaim error at server */ + ERROR_RECLAIM_BAD NfsErrorCode = 10034 + /* conflict on reclaim */ + ERROR_RECLAIM_CONFLICT NfsErrorCode = 10035 + /* ZDR decode failed */ + ERROR_BADZDR NfsErrorCode = 10036 + /* file locks held at CLOSE*/ + ERROR_LOCKS_HELD NfsErrorCode = 10037 + /* conflict in OPEN and I/O*/ + ERROR_OPENMODE NfsErrorCode = 10038 + /* owner translation bad */ + ERROR_BADOWNER NfsErrorCode = 10039 + /* utf-8 char not supported*/ + ERROR_BADCHAR NfsErrorCode = 10040 + /* name not supported */ + ERROR_BADNAME NfsErrorCode = 10041 + /* lock range not supported*/ + ERROR_BAD_RANGE NfsErrorCode = 10042 + /* no atomic up/downgrade */ + ERROR_LOCK_NOTSUPP NfsErrorCode = 10043 + /* undefined operation */ + ERROR_OP_ILLEGAL NfsErrorCode = 10044 + /* file locking deadlock */ + ERROR_DEADLOCK NfsErrorCode = 10045 + /* open file blocks op. */ + ERROR_FILE_OPEN NfsErrorCode = 10046 + /* lockowner state revoked */ + ERROR_ADMIN_REVOKED NfsErrorCode = 10047 +) diff --git a/server/plugin/plg_backend_nfs4/repo/nfs4/supervised_conn.go b/server/plugin/plg_backend_nfs4/repo/nfs4/supervised_conn.go new file mode 100644 index 00000000..b73b7758 --- /dev/null +++ b/server/plugin/plg_backend_nfs4/repo/nfs4/supervised_conn.go @@ -0,0 +1,136 @@ +package nfs4 + +import ( + "context" + "io" + "net" + "sync" + "time" +) + +// A wrapper for net.Conn that adds ability to cancel operations via a context.Context and +// also supports deadlines. +type SupervisedConnection struct { + delegate net.Conn + ctx context.Context + deadline time.Time + + mtx sync.Mutex + closeSignal chan bool + closeErr error + isClosed int32 +} + +func NewSupervisedConnection(delegate net.Conn, + ctx context.Context) (*SupervisedConnection, error) { + + res := &SupervisedConnection{ + delegate: delegate, + ctx: ctx, + closeSignal: make(chan bool), + } + go func() { + select { + case <-ctx.Done(): + res.signalDone() + case <-res.closeSignal: + } + }() + + deadline, ok := ctx.Deadline() + if ok { + res.deadline = deadline + err := delegate.SetDeadline(deadline) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (s *SupervisedConnection) signalDone() { + s.mtx.Lock() + defer s.mtx.Unlock() + if s.isClosed != 0 { + return + } + // Cancel pending operations + s.closeErr = s.delegate.Close() + s.isClosed = 1 +} + +func (s *SupervisedConnection) SetReadDeadline(t time.Time) error { + s.mtx.Lock() + defer s.mtx.Unlock() + + // Don't allow deadline extensions if we're getting interrupted + if !s.deadline.IsZero() && s.deadline.Before(t) { + return nil + } + + return s.delegate.SetReadDeadline(t) +} + +func (s *SupervisedConnection) SetWriteDeadline(t time.Time) error { + s.mtx.Lock() + defer s.mtx.Unlock() + + // Don't allow deadline extensions if we're getting interrupted + if !s.deadline.IsZero() && s.deadline.Before(t) { + return nil + } + + return s.delegate.SetWriteDeadline(t) +} + +func (s *SupervisedConnection) SetDeadline(t time.Time) error { + s.mtx.Lock() + defer s.mtx.Unlock() + + // Don't allow deadline extensions if we're getting interrupted + if !s.deadline.IsZero() && s.deadline.Before(t) { + return nil + } + + return s.delegate.SetDeadline(t) +} + +func (s *SupervisedConnection) Close() error { + s.mtx.Lock() + defer s.mtx.Unlock() + if s.isClosed != 0 { + return s.closeErr + } + + close(s.closeSignal) + s.isClosed = 1 + + s.closeErr = s.delegate.Close() + return s.closeErr +} + +func (s *SupervisedConnection) Read(b []byte) (n int, err error) { + // s.isClosed can only go from 0 to 1, so there's no need to do + // synchronization here. + if s.isClosed != 0 { + return 0, io.EOF + } + return s.delegate.Read(b) +} + +func (s *SupervisedConnection) Write(b []byte) (n int, err error) { + // s.isClosed can only go from 0 to 1, so there's no need to do + // synchronization here. + if s.isClosed != 0 { + return 0, io.EOF + } + return s.delegate.Write(b) +} + +func (s *SupervisedConnection) LocalAddr() net.Addr { + return s.delegate.LocalAddr() +} + +func (s *SupervisedConnection) RemoteAddr() net.Addr { + return s.delegate.RemoteAddr() +}