diff options
Diffstat (limited to 'src/protocols')
| -rw-r--r-- | src/protocols/cifs/cifs.cpp | 91 | ||||
| -rw-r--r-- | src/protocols/cifs/cifs.h | 233 | ||||
| -rw-r--r-- | src/protocols/cifs2/cifs2.cpp | 162 | ||||
| -rw-r--r-- | src/protocols/cifs2/cifs2.h | 203 | ||||
| -rw-r--r-- | src/protocols/cifs2/cifs2_utils.cpp | 719 | ||||
| -rw-r--r-- | src/protocols/cifs2/cifs2_utils.h | 95 | ||||
| -rw-r--r-- | src/protocols/ip/ipv4_header.h | 4 | ||||
| -rw-r--r-- | src/protocols/netbios/netbios.cpp | 37 | ||||
| -rw-r--r-- | src/protocols/netbios/netbios.h | 71 | ||||
| -rw-r--r-- | src/protocols/nfs/nfs_procedure.h | 96 | ||||
| -rw-r--r-- | src/protocols/nfs/nfs_utils.cpp | 55 | ||||
| -rw-r--r-- | src/protocols/nfs/nfs_utils.h | 41 | ||||
| -rw-r--r-- | src/protocols/nfs/nfsv41.x | 190 | ||||
| -rw-r--r-- | src/protocols/nfs3/nfs3_rpcgen.cpp | 1808 | ||||
| -rw-r--r-- | src/protocols/nfs3/nfs3_utils.cpp | 2630 | ||||
| -rw-r--r-- | src/protocols/nfs3/nfs3_utils.h | 384 | ||||
| -rw-r--r-- | src/protocols/nfs4/nfs41_utils.cpp | 8691 | ||||
| -rw-r--r-- | src/protocols/nfs4/nfs41_utils.h | 629 | ||||
| -rw-r--r-- | src/protocols/nfs4/nfs4_rpcgen.cpp | 2800 | ||||
| -rw-r--r-- | src/protocols/nfs4/nfs4_utils.cpp | 4040 | ||||
| -rw-r--r-- | src/protocols/nfs4/nfs4_utils.h | 362 | ||||
| -rw-r--r-- | src/protocols/xdr/xdr_decoder.h | 1 |
22 files changed, 18150 insertions, 5192 deletions
diff --git a/src/protocols/cifs/cifs.cpp b/src/protocols/cifs/cifs.cpp new file mode 100644 index 0000000..348722b --- /dev/null +++ b/src/protocols/cifs/cifs.cpp @@ -0,0 +1,91 @@ +//------------------------------------------------------------------------------ +// Author: Andrey Kuznetsov +// Description: Helpers for parsing CIFS structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#include <cassert> + +#include "protocols/cifs/cifs.h" +//------------------------------------------------------------------------------ +using namespace NST::protocols::CIFSv1; +using namespace NST::API; +union SMBCode +{ + uint8_t codes[4]; + uint32_t code; +}; + +static inline uint32_t get_code() +{ + SMBCode code; + + code.codes[0] = static_cast<uint8_t>(ProtocolCodes::SMB1); + code.codes[1] = 'S'; + code.codes[2] = 'M'; + code.codes[3] = 'B'; + + return code.code; +} + +const NST::protocols::CIFSv1::MessageHeader* NST::protocols::CIFSv1::get_header(const uint8_t* data) +{ + static uint32_t code = get_code (); + + const MessageHeader* header (reinterpret_cast<const MessageHeader*>(data)); + if (header->head_code == code) + { + return header; + } + return nullptr; +} + +bool MessageHeader::isFlag(const Flags flag) const +{ + return static_cast<const uint8_t>(flag) & static_cast<const uint8_t>(flags); +} + +const char* NST::protocols::CIFSv1::print_cifs1_procedures(SMBv1Commands cmd_code) +{ + assert(cmd_code < SMBv1Commands::CMD_COUNT); + + static const char* const commandNames[] = + { + "CREATE_DIRECTORY", "DELETE_DIRECTORY", "OPEN", "CREATE", + "CLOSE", "FLUSH", "DELETE", "RENAME", + "QUERY_INFORMATION", "SET_INFORMATION", "READ", "WRITE", + "LOCK_BYTE_RANGE", "UNLOCK_BYTE_RANGE", "CREATE_TEMPORARY", "CREATE_NEW", + "CHECK_DIRECTORY", "PROCESS_EXIT", "SEEK", "LOCK_AND_READ", + "WRITE_AND_UNLOCK", "READ_RAW", "READ_MPX", "READ_MPX_SECONDARY", + "WRITE_RAW", "WRITE_MPX", "WRITE_MPX_SECONDARY", "WRITE_COMPLETE", + "QUERY_SERVER", "SET_INFORMATION2", "QUERY_INFORMATION2", "LOCKING_ANDX", + "TRANSACTION", "TRANSACTION_SECONDARY", "IOCTL", "IOCTL_SECONDARY", + "COPY", "MOVE", "ECHO", "WRITE_AND_CLOSE", + "OPEN_ANDX", "READ_ANDX", "WRITE_ANDX", "NEW_FILE_SIZE", + "CLOSE_AND_TREE_DISC", "TRANSACTION2", "TRANSACTION2_SECONDARY", "FIND_CLOSE2", + "FIND_NOTIFY_CLOSE", "TREE_CONNECT", "TREE_DISCONNECT", "NEGOTIATE", + "SESSION_SETUP_ANDX", "LOGOFF_ANDX", "TREE_CONNECT_ANDX", "SECURITY_PACKAGE_ANDX", + "QUERY_INFORMATION_DISK", "SEARCH", "FIND", "FIND_UNIQUE", + "FIND_CLOSE", "NT_TRANSACT", "NT_TRANSACT_SECONDARY", "NT_CREATE_ANDX", + "NT_CANCEL", "NT_RENAME", "OPEN_PRINT_FILE", "WRITE_PRINT_FILE", + "CLOSE_PRINT_FILE", "GET_PRINT_QUEUE", "READ_BULK", "WRITE_BULK", + "WRITE_BULK_DATA", "INVALID", "NO_ANDX_COMMAND" + }; + + return commandNames[static_cast<int>(cmd_code)]; +} diff --git a/src/protocols/cifs/cifs.h b/src/protocols/cifs/cifs.h new file mode 100644 index 0000000..7d6f557 --- /dev/null +++ b/src/protocols/cifs/cifs.h @@ -0,0 +1,233 @@ +//------------------------------------------------------------------------------ +// Author: Andrey Kuznetsov +// Description: Helpers for parsing CIFS structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#ifndef CIFS_HEADER_H +#define CIFS_HEADER_H +//------------------------------------------------------------------------------ +#include <cstdint> + +#include "api/cifs_types.h" +#include "protocols/netbios/netbios.h" +//------------------------------------------------------------------------------ +#define NST_PUBLIC __attribute__ ((visibility("default"))) +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace CIFSv1 +{ + +using SMBv1Commands = NST::API::SMBv1::SMBv1Commands; + +/*! Flags of message + */ +enum class Flags : uint8_t +{ + LOCK_AND_READ_OK = 0x01, //!< This bit is set (1) in the SMB_COM_NEGOTIATE (0x72) Response (section 2.2.4.52.2) if the server supports SMB_COM_LOCK_AND_READ (0x13) (section 2.2.4.20) and SMB_COM_WRITE_AND_UNLOCK (0x14) (section 2.2.4.21) commands. + BUF_AVAIL = 0x02, //!< Obsolete. When set (on an SMB request being sent to the server), the client guarantees that there is a receive buffer posted such that a send without acknowledgment can be used by the server to respond to the client's request. This behavior is specific to an obsolete transport. This bit MUST be set to zero by the client and MUST be ignored by the server. + Reserved = 0x04, //!< This flag MUST be set to zero by the client and MUST be ignored by the server. + CASE_INSENSITIVE = 0x08, //!< Obsolete. If this bit is set then all pathnames in the SMB SHOULD be treated as case-insensitive.<26> + CANONICALIZED_PATHS = 0x10, //!< Obsolescent. When set in session setup, this bit indicates that all paths sent to the server are already in canonical format. That is, all file and directory names are composed of valid file name characters in all upper-case, and that the path segments are separated by backslash characters ('\'). + OPLOCK = 0x20, //!< Obsolescent. This bit has meaning only in the deprecatedSMB_COM_OPEN (0x02) Request (section 2.2.4.3.1), SMB_COM_CREATE (0x03) Request (section 2.2.4.4.1), and SMB_COM_CREATE_NEW (0x0F) Request (section 2.2.4.16.1) messages, where it is used to indicate that the client is requesting an Exclusive OpLock. It SHOULD be set to zero by the client, and ignored by the server, in all other SMB requests. If the server grants this OpLock request, then this bit SHOULD remain set in the corresponding response SMB to indicate to the client that the OpLock request was granted. + OPBATCH = 0x40, //!< Obsolescent. This bit has meaning only in the deprecated SMB_COM_OPEN (0x02) Request (section 2.2.4.3.1), SMB_COM_CREATE (0x03) Request (section 2.2.4.4.1), and SMB_COM_CREATE_NEW (0x0F) Request (section 2.2.4.16.1) messages, where it is used to indicate that the client is requesting a Batch OpLock. It SHOULD be set to zero by the client, and ignored by the server, in all other SMB requests. If the server grants this OpLock request, then this bit SHOULD remain set in the corresponding response SMB to indicate to the client that the OpLock request was granted. If the SMB_FLAGS_OPLOCK bit is clear (0), then the SMB_FLAGS_OPBATCH bit is ignored. + REPLY = 0x80, //!< When on, this message is being sent from the server in response to a client request. The Command field usually contains the same value in a protocol request from the client to the server as in the matching response from the server to the client. This bit unambiguously distinguishes the message as a server response. +}; + +/*! CIFS commands + */ +enum class Commands : uint8_t +{ + CREATE_DIRECTORY = 0x00, //!< Create a new directory. + DELETE_DIRECTORY = 0x01, //!< Delete an empty directory. + OPEN = 0x02, //!< Open a file. + CREATE = 0x03, //!< Create or open a file. + CLOSE = 0x04, //!< Close a file. + FLUSH = 0x05, //!< Flush data for a file + DELETE = 0x06, //!< Delete a file. + RENAME = 0x07, //!< Rename a file or set of files. + QUERY_INFORMATION = 0x08, //!< Get file attributes. + SET_INFORMATION = 0x09, //!< Set file attributes. + READ = 0x0A, //!< Read from a file. + WRITE = 0x0B, //!< Write to a file. + LOCK_BYTE_RANGE = 0x0C, //!< Request a byte-range lock on a file. + UNLOCK_BYTE_RANGE = 0x0D, //!< Release a byte-range lock on a file. + CREATE_TEMPORARY = 0x0E, //!< Create a temporary file. + CREATE_NEW = 0x0F, //!< Create and open a new file. + CHECK_DIRECTORY = 0x10, //!< Verify that the specified pathname resolves to a directory.Listed as SMBchkpath in some documentation. + PROCESS_EXIT = 0x11, //!< Indicate process exit. + SEEK = 0x12, //!< Set the current file pointer within a file. + LOCK_AND_READ = 0x13, //!< Lock and read a byte-range within a file. + WRITE_AND_UNLOCK = 0x14, //!< Write and unlock a byte-range within a file. + READ_RAW = 0x1A, //!< Read a block in raw mode. + READ_MPX = 0x1B, //!< Multiplexed block read. Listed as SMBreadmpx in some documentation. + READ_MPX_SECONDARY = 0x1C, //!< Multiplexed block read + WRITE_RAW = 0x1D, //!< Write a block in raw mode. + WRITE_MPX = 0x1E, //!< Multiplexed block write. + WRITE_MPX_SECONDARY = 0x1F, //!< Multiplexed block write + WRITE_COMPLETE = 0x20, //!< Raw block write + QUERY_SERVER = 0x21, //!< Reserved + SET_INFORMATION2 = 0x22, //!< Set an extended set of file attributes. + QUERY_INFORMATION2 = 0x23, //!< Get an extended set of file attributes. + LOCKING_ANDX = 0x24, //!< Lock multiple byte ranges; AndX chaining. + TRANSACTION = 0x25, //!< Transaction. + TRANSACTION_SECONDARY = 0x26, //!< Transaction secondary request. + IOCTL = 0x27, //!< Pass an I/O Control function request to the server. + IOCTL_SECONDARY = 0x28, //!< IOCTL secondary request. + COPY = 0x29, //!< Copy a file or directory. + MOVE = 0x2A, //!< Move a file or directory. + ECHO = 0x2B, //!< Echo request (ping). + WRITE_AND_CLOSE = 0x2C, //!< Write to and close a file. + OPEN_ANDX = 0x2D, //!< Extended file open with AndX chaining. + READ_ANDX = 0x2E, //!< Extended file read with AndX chaining. + WRITE_ANDX = 0x2F, //!< Extended file write with AndX chaining. + NEW_FILE_SIZE = 0x30, //!< Reserved + CLOSE_AND_TREE_DISC = 0x31, //!< Close an open file and tree disconnect. + TRANSACTION2 = 0x32, //!< Transaction 2 format request/response. + TRANSACTION2_SECONDARY = 0x33, //!< Transaction 2 secondary request. + FIND_CLOSE2 = 0x34, //!< Close an active search. + FIND_NOTIFY_CLOSE = 0x35, //!< Notification of the closure of an active search. + TREE_CONNECT = 0x70, //!< Tree connect. + TREE_DISCONNECT = 0x71, //!< Tree disconnect. + NEGOTIATE = 0x72, //!< Negotiate protocol dialect. + SESSION_SETUP_ANDX = 0x73, //!< Session Setup with AndX chaining. + LOGOFF_ANDX = 0x74, //!< User logoff with AndX chaining. + TREE_CONNECT_ANDX = 0x75, //!< Tree connect with AndX chaining. + SECURITY_PACKAGE_ANDX = 0x7E, //!< Negotiate security packages with AndX chaining. + QUERY_INFORMATION_DISK = 0x80, //!< Retrieve file system information from the server. + SEARCH = 0x81, //!< Directory wildcard search. + FIND = 0x82, //!< Start or continue an extended wildcard directory search. + FIND_UNIQUE = 0x83, //!< Perform a one-time extended wildcard directory search. + FIND_CLOSE = 0x84, //!< End an extended wildcard directory search. + NT_TRANSACT = 0xA0, //!< NT format transaction request/response. + NT_TRANSACT_SECONDARY = 0xA1, //!< NT format transaction secondary request. + NT_CREATE_ANDX = 0xA2, //!< Create or open a file or a directory. + NT_CANCEL = 0xA4, //!< Cancel a request currently pending at the server. + NT_RENAME = 0xA5, //!< File rename with extended semantics. + OPEN_PRINT_FILE = 0xC0, //!< Create a print queue spool file. + WRITE_PRINT_FILE = 0xC1, //!< Write to a print queue spool file. + CLOSE_PRINT_FILE = 0xC2, //!< Close a print queue spool file. + GET_PRINT_QUEUE = 0xC3, //!< Request print queue information. + READ_BULK = 0xD8, //!< Reserved + WRITE_BULK = 0xD9, //!< Reserved + WRITE_BULK_DATA = 0xDA, //!< Reserved + INVALID = 0xFE, //!< As the name suggests + NO_ANDX_COMMAND = 0xFF //!< Also known as the NIL command. It identifies the end of an AndX Chain +}; + +/*! SMB protocol codes + */ +enum class ProtocolCodes : uint8_t +{ + SMB2 = 0xFE, //!< SMB v2.0-2.1 + SMB1 = 0xFF //!< SMB v.1.0 +}; + +/*! \class First part of CIFS header + */ +struct MessageHeaderHead +{ + ProtocolCodes protocol_code;//!< Protocol version - 0xFF or 0xF3 + int8_t protocol[3];//!< Protocol name (SMB) +} __attribute__ ((__packed__)); + +/*! Security field for CIFS header + */ +struct SecurityField +{ + int8_t key[4];//!< Somethink about security + int16_t CID;//!< A connection identifier (CID). + int16_t sequenceNumber;//!< A number used to identify the sequence of a message over connectionless transports. +}; + +/*! \class Raw CIFS message header + */ +struct RawMessageHeader +{ + union + { + MessageHeaderHead head;//!< Head of header + uint32_t head_code;//!< For fast checking + }; + Commands cmd_code;//!< Code of SMB command + int32_t status;//!< Used to communicate error messages from the server to the client. + Flags flags;//!< 1-bit flags describing various features in effect for the message. + uint8_t flags2[2];//!< A 16-bit field of 1-bit flags that represent various features in effect for the message. Unspecified bits are reserved and MUST be zero. + + int16_t PIDHigh;//!< If set to a nonzero value, this field represents the high-order bytes of a process identifier (PID). It is combined with the PIDLow field below to form a full PID. + union // Depends on command + { + int8_t securityFeatures[8];//!< Somethink about security + SecurityField sec;//!< Security field structure + }; + int16_t _;//!< Reserved + + int16_t TID;//!< A tree identifier + int16_t PIDLow;//!< The lower 16-bits of the PID + + int16_t UID;//!< A user identifier + int16_t MID;//!< A multiplex identifier +} __attribute__ ((__packed__)); + +/*! High level user friendly message structure + */ +struct MessageHeader : public RawMessageHeader +{ + /*! Check flag + * \param flag - flag to be check + * \return True, if flag set, and False in other case + */ + bool isFlag(const Flags flag) const; +}; + +/*! Check is data valid CIFS message's header and return header or nullptr + * \param data - raw packet data + * \return pointer to input data which is casted to header structure or nullptr (if it is not valid header) + */ +const MessageHeader* get_header(const uint8_t* data); + +/*! Constructs new command for API from raw message + * \param request - Call's header + * \param response - Reply's header + * \return Command structure + */ +template <typename Cmd, typename Data, typename Session> +inline const Cmd command(Data& request, Data& response, Session* session) +{ + Cmd cmd; + cmd.session = session; + // Set time stamps + cmd.ctimestamp = &request->timestamp; + cmd.rtimestamp = &response->timestamp; + + return cmd; +} + +extern "C" +NST_PUBLIC +const char* print_cifs1_procedures(SMBv1Commands cmd_code); + +} // namespace CIFSv1 +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ +#endif//CIFS_HEADER_H +//------------------------------------------------------------------------------ diff --git a/src/protocols/cifs2/cifs2.cpp b/src/protocols/cifs2/cifs2.cpp new file mode 100644 index 0000000..980ecca --- /dev/null +++ b/src/protocols/cifs2/cifs2.cpp @@ -0,0 +1,162 @@ +//------------------------------------------------------------------------------ +// Author: Andrey Kuznetsov +// Description: Helpers for parsing CIFS structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#include <cassert> + +#include <arpa/inet.h> +#include <assert.h> + +#include "protocols/cifs2/cifs2.h" +#include "protocols/cifs/cifs.h" +#include "api/cifs_pc_to_net.h" +//------------------------------------------------------------------------------ +using namespace NST::protocols::CIFSv2; + +# if NFSTRACE_BYTE_ORDER == NFSTRACE_BIG_ENDIAN + +inline uint64_t ntohll(uint64_t input) +{ + // Network byte order == Big Endian + return input; +} + +# else +# if NFSTRACE_BYTE_ORDER == NFSTRACE_LITTLE_ENDIAN + +inline uint64_t ntohll(uint64_t input) +{ + return be64toh(input); +} +# endif +# endif + +union SMBCode +{ + uint8_t codes[4]; + uint32_t code; +}; + +static inline uint32_t get_code() +{ + SMBCode code; + + code.codes[0] = static_cast<uint8_t>(NST::protocols::CIFSv1::ProtocolCodes::SMB2); + code.codes[1] = 'S'; + code.codes[2] = 'M'; + code.codes[3] = 'B'; + + return code.code; +} + +const NST::protocols::CIFSv2::MessageHeader* NST::protocols::CIFSv2::get_header(const uint8_t* data) +{ + static uint32_t code = get_code (); + + const MessageHeader* header (reinterpret_cast<const MessageHeader*>(data)); + if (header->head_code == code) + { + return header; + } + return nullptr; +} + +bool MessageHeader::isFlag(const Flags flag) const +{ + return static_cast<uint32_t>(flag) & flags; +} + +void NST::protocols::CIFSv2::parseGuid(uint8_t (&guid)[16]) +{ + Guid &p = reinterpret_cast<Guid&>(guid); + p.Data1 = le32toh(p.Data1); + p.Data2 = le16toh(p.Data2); + p.Data3 = le16toh(p.Data3); +} + +void NST::protocols::CIFSv2::parse(SMBv2::ErrResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::NegotiateRequest*& p) +{ + parseGuid(p->clientGUID); +} +void NST::protocols::CIFSv2::parse(SMBv2::NegotiateResponse*& p) +{ + parseGuid(p->serverGUID); +} +void NST::protocols::CIFSv2::parse(SMBv2::SessionSetupRequest*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::SessionSetupResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::LogOffRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::LogOffResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::TreeConnectRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::TreeConnectResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::TreeDisconnectRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::TreeDisconnectResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::CreateRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::CreateResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::CloseRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::CloseResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::EchoRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::EchoResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::QueryInfoRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::QueryInfoResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::QueryDirRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::QueryDirResponse*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::FlushRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::FlushResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::ReadRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::ReadResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::Lock*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::WriteRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::WriteResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::LockRequest*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::LockResponse*&) { } +void NST::protocols::CIFSv2::parse(SMBv2::ChangeNotifyRequest*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::FileNotifyInformation*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::ChangeNotifyResponse*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::OplockAcknowledgment*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::OplockResponse*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::IoCtlRequest*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::IoCtlResponse*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::SetInfoRequest*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::SetInfoResponse*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::CancelResponce*&){ } +void NST::protocols::CIFSv2::parse(SMBv2::CancelRequest*&){ } + +// TODO: This implementation currently copy of +// epm-nfs/analyzers/src/cifs/cifs2_commands.cpp +// const std::string NST::breakdown::SMBv2Commands::command_name(int cmd_code) +// Futre fix: We need to merege these enums +// TODO: Move implementation to some common module +const char* NST::protocols::CIFSv2::print_cifs2_procedures(SMBv2Commands cmd) +{ + assert(cmd < SMBv2Commands::CMD_COUNT); + + static const char* const commandNames[] = + { + "NEGOTIATE", "SESSION SETUP", "LOGOFF", "TREE CONNECT", + "TREE DISCONNECT", "CREATE", "CLOSE", "FLUSH", + "READ", "WRITE", "LOCK", "IOCTL", + "CANCEL", "ECHO", "QUERY DIRECTORY", "CHANGE NOTIFY", + "QUERY INFO", "SET INFO", "OPLOCK BREAK" + }; + + return commandNames[static_cast<int>(cmd)]; +} + diff --git a/src/protocols/cifs2/cifs2.h b/src/protocols/cifs2/cifs2.h new file mode 100644 index 0000000..f25020c --- /dev/null +++ b/src/protocols/cifs2/cifs2.h @@ -0,0 +1,203 @@ +//------------------------------------------------------------------------------ +// Author: Andrey Kuznetsov +// Description: Helpers for parsing CIFS v2 structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#ifndef CIFSv2_HEADER_H +#define CIFSv2_HEADER_H +//------------------------------------------------------------------------------ +#include "api/cifs_commands.h" +#include "api/cifs2_commands.h" +#include "protocols/cifs/cifs.h" +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace CIFSv2 +{ + +using SMBv2Commands = NST::API::SMBv2::SMBv2Commands; +namespace SMBv2 = NST::API::SMBv2; +// https://msdn.microsoft.com/en-us/library/ff718266.aspx +struct Guid +{ + uint32_t Data1; // unsigned long replaced by uint32_t + uint16_t Data2; // unsigned short replaced by uint16_t + uint16_t Data3; // unsigned short replaced by uint16_t + uint8_t Data4[8]; // byte replaced by uint8_t +} __attribute__ ((__packed__)); + +/*! CIFS v2 Flags + */ +enum class Flags : uint32_t +{ + SERVER_TO_REDIR = API::SMBv2::pc_to_net<uint32_t>(0x00000001), //!< When set, indicates the message is a response, rather than a request. This MUST be set on responses sent from the server to the client and MUST NOT be set on requests sent from the client to the server. + ASYNC_COMMAND = API::SMBv2::pc_to_net<uint32_t>(0x00000002), //!< When set, indicates that this is an ASYNC SMB2 header. This flag MUST NOT be set when using the SYNC SMB2 header. + RELATED_OPERATIONS = API::SMBv2::pc_to_net<uint32_t>(0x00000004), //!< When set in an SMB2 request, indicates that this request is a related operation in a compounded request chain. The use of this flag in an SMB2 request is as specified in 3.2.4.1.4. + //!< When set in an SMB2 compound response, indicates that the request corresponding to this response was part of a related operation in a compounded request chain. The use of this flag in an SMB2 response is as specified in 3.3.5.2.7.2. + SIGNED = API::SMBv2::pc_to_net<uint32_t>(0x00000008), //!< When set, indicates that this packet has been signed. The use of this flag is as specified in 3.1.5.1. + DFS_OPERATIONS = API::SMBv2::pc_to_net<uint32_t>(0x01000000), //!< When set, indicates that this command is a DFS operation. The use of this flag is as specified in 3.3.5.9. + REPLAY_OPERATION = API::SMBv2::pc_to_net<uint32_t>(0x02000000) //!< This flag is only valid for the SMB 3.x dialect family. When set, it indicates that this command is a replay operation. The client MUST ignore this bit on receipt. +}; + +/*! \class Raw CIFS v2 message header + */ +struct RawMessageHeader +{ + union + { + CIFSv1::MessageHeaderHead head;//!< Head of header + uint32_t head_code;//!< For fast checking + }; + + int16_t StructureSize;//!< In the SMB 2.002 dialect, this field MUST NOT be used and MUST be reserved. The sender MUST set this to 0, and the receiver MUST ignore it. In all other dialects, this field indicates the number of credits that this request consumes. + int16_t CreditCharge;//!< In a request, this field is interpreted in different ways depending on the SMB2 dialect. In the SMB 3.x dialect family, this field is interpreted as the ChannelSequence field followed by the Reserved field in a request. + + uint32_t status;//!< Used to communicate error messages from the server to the client. + + SMBv2Commands cmd_code;//!< Code of SMB command + int16_t Credit;//!< This MUST be set to 64, which is the size, in bytes, of the SMB2 header structure. + + int32_t flags;//!< 1-bit flags describing various features in effect for the message. + + int32_t nextCommand;//!< For a compounded request, this field MUST be set to the offset, in bytes, from the beginning of this SMB2 header to the start of the subsequent 8-byte aligned SMB2 header. If this is not a compounded request, or this is the last header in a compounded request, this value MUST be 0. + int64_t messageId;//!< A value that identifies a message request and response uniquely across all messages that are sent on the same SMB 2 Protocol transport connection. + int32_t _;//!< The client SHOULD<3> set this field to 0. The server MAY<4> ignore this field on receipt. + int32_t TreeId;//!< Uniquely identifies the tree connect for the command. This MUST be 0 for the SMB2 TREE_CONNECT Request. The TreeId can be any unsigned 32-bit integer that is received from a previous SMB2 TREE_CONNECT Response. The following SMB 2 Protocol commands do not require the TreeId to be set to a nonzero value received from a previous SMB2 TREE_CONNECT Response. + /*! + TreeId SHOULD be set to 0 for the following commands: + SMB2 NEGOTIATE Request + SMB2 NEGOTIATE Response + SMB2 SESSION_SETUP Request + SMB2 SESSION_SETUP Response + SMB2 LOGOFF Request + SMB2 LOGOFF Response + SMB2 ECHO Request + SMB2 ECHO Response + SMB2 CANCEL Request + */ + int64_t SessionId;//!< Uniquely identifies the established session for the command + uint8_t Signature[16];//!< he 16-byte signature of the message, if SMB2_FLAGS_SIGNED is set in the Flags field of the SMB2 header. If the message is not signed, this field MUST be 0. +} __attribute__ ((__packed__)); + +/*! High level user friendly message structure + */ +struct MessageHeader : public RawMessageHeader +{ + /*! Check flag + * \param flag - flag to be check + * \return True, if flag set, and False in other case + */ + bool isFlag(const Flags flag) const; +}; + +/*! Check is data valid CIFS message's header and return header or nullptr + * \param data - raw packet data + * \return pointer to input data which is casted to header structure or nullptr (if it is not valid header) + */ +const MessageHeader* get_header(const uint8_t* data); + +void parseGuid(uint8_t (&guid)[16]); +void parse(SMBv2::ErrResponse*&); +void parse(SMBv2::NegotiateRequest*&); +void parse(SMBv2::NegotiateResponse*&); +void parse(SMBv2::SessionSetupRequest*&); +void parse(SMBv2::SessionSetupResponse*&); +void parse(SMBv2::LogOffRequest*&); +void parse(SMBv2::LogOffResponse*&); +void parse(SMBv2::TreeConnectRequest*&); +void parse(SMBv2::TreeConnectResponse*&); +void parse(SMBv2::TreeDisconnectRequest*&); +void parse(SMBv2::TreeDisconnectResponse*&); +void parse(SMBv2::CreateRequest*&); +void parse(SMBv2::CreateResponse*&); +void parse(SMBv2::CloseRequest*&); +void parse(SMBv2::CloseResponse*&); +void parse(SMBv2::EchoRequest*&); +void parse(SMBv2::EchoResponse*&); +void parse(SMBv2::QueryInfoRequest*&); +void parse(SMBv2::QueryInfoResponse*&); +void parse(SMBv2::QueryDirRequest*&); +void parse(SMBv2::QueryDirResponse*&); +void parse(SMBv2::FlushRequest*&); +void parse(SMBv2::FlushResponse*&); +void parse(SMBv2::ReadRequest*&); +void parse(SMBv2::ReadResponse*&); +void parse(SMBv2::Lock*&); +void parse(SMBv2::WriteRequest*&); +void parse(SMBv2::WriteResponse*&); +void parse(SMBv2::LockRequest*&); +void parse(SMBv2::LockResponse*&); +void parse(SMBv2::ChangeNotifyRequest*&); +void parse(SMBv2::FileNotifyInformation*&); +void parse(SMBv2::ChangeNotifyResponse*&); +void parse(SMBv2::OplockAcknowledgment*&); +void parse(SMBv2::OplockResponse*&); +void parse(SMBv2::IoCtlRequest*&); +void parse(SMBv2::IoCtlResponse*&); +void parse(SMBv2::SetInfoRequest*&); +void parse(SMBv2::SetInfoResponse*&); +void parse(SMBv2::CancelResponce*&); +void parse(SMBv2::CancelRequest*&); + +/*! Constructs new command for API from raw message + * \param request - Call's + * \param response - Reply's + * \param session - session + * \return Command structure + */ +template <typename Cmd, typename Data, typename Session> +inline const Cmd command(Data& request, Data& response, Session* session) +{ + Cmd cmd; + cmd.session = session; + // Set time stamps + cmd.ctimestamp = &request->timestamp; + cmd.rtimestamp = response ? &response->timestamp : &request->timestamp; + + // + // Since we have to modify structures before command creation + // we have to cast raw data to pointer type ( in contrast to const pointer ) + // + auto req_header = reinterpret_cast<RawMessageHeader*>(request->data); + auto pargs = reinterpret_cast<typename Cmd::RequestType*>(request->data + sizeof(RawMessageHeader)); + + parse(pargs); + + cmd.req_header = req_header; + if(response) + { + cmd.res_header = reinterpret_cast<RawMessageHeader*>(response->data); + cmd.pres = reinterpret_cast<typename Cmd::ResponseType*>(response->data + sizeof(RawMessageHeader)); + } + cmd.parg = pargs; + return cmd; +} + +extern "C" +NST_PUBLIC +const char* print_cifs2_procedures(SMBv2Commands cmd_code); + +} // namespace CIFSv2 +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ +#endif//CIFSv2_HEADER_H +//------------------------------------------------------------------------------ diff --git a/src/protocols/cifs2/cifs2_utils.cpp b/src/protocols/cifs2/cifs2_utils.cpp new file mode 100644 index 0000000..ec065fc --- /dev/null +++ b/src/protocols/cifs2/cifs2_utils.cpp @@ -0,0 +1,719 @@ +//------------------------------------------------------------------------------ +// Author: Artsem Iliasau +// Description: Helpers for parsing CIFSv2 structures. +// Copyright (c) 2015 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#include <iostream> +#include <type_traits> + +#include "cifs2.h" +#include "cifs2_utils.h" +#include "protocols/nfs/nfs_utils.h" +//------------------------------------------------------------------------------ +static const std::string flagDelimiter = " | "; +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace CIFSv2 +{ + +using namespace NST::API::SMBv2; + +namespace +{ + +template <typename T> +void print_flag_if_set(std::ostream& out, const std::string& name, typename std::underlying_type<T>::type& value, T flag) +{ + auto int_flag = to_integral(flag); + if (value & int_flag) + { + out << name; + value = value & ~int_flag; + if(value > 0) + out << flagDelimiter; + } +} + +const char* enumToString(OplockLevels value) +{ + switch (value) + { + case OplockLevels::NONE: return "NONE"; + case OplockLevels::II: return "II"; + case OplockLevels::EXCLUSIVE: return "EXCLUSIVE"; + case OplockLevels::BATCH: return "BATCH"; + case OplockLevels::LEASE: return "LEASE"; + } + + return nullptr; +} + +const char* enumToString(ImpersonationLevels value) +{ + switch (value) + { + case ImpersonationLevels::ANONYMOUS: return "ANONYMOUS"; + case ImpersonationLevels::IDENTIFICATION: return "IDENTIFICATION"; + case ImpersonationLevels::IMPERSONATION: return "IMPERSONATION"; + case ImpersonationLevels::DELEGATE: return "DELEGATE"; + } + + return nullptr; +} + +const char* enumToString(CreateDisposition value) +{ + switch (value) + { + case CreateDisposition::SUPERSEDE: return "SUPERSEDE"; + case CreateDisposition::OPEN: return "OPEN"; + case CreateDisposition::CREATE: return "CREATE"; + case CreateDisposition::OPEN_IF: return "OPEN_IF"; + case CreateDisposition::OVERWRITE: return "OVERWRITE"; + case CreateDisposition::OVERWRITE_IF: return "OVERWRITE_IF"; + } + + return nullptr; +} + +const char* enumToString(CreateActions value) +{ + switch (value) + { + case CreateActions::SUPERSEDED: return "SUPERSEDED"; + case CreateActions::OPENED: return "OPENED"; + case CreateActions::CREATED: return "CREATED"; + case CreateActions::FILE_OVERWRITTEN: return "FILE_OVERWRITTEN"; + } + + return nullptr; +} + +const char* enumToString(ShareTypes value) +{ + switch (value) + { + case ShareTypes::DISK: return "SMB2_SHARE_TYPE_DISK"; + case ShareTypes::PIPE: return "SMB2_SHARE_TYPE_PIPE"; + case ShareTypes::PRINT: return "SMB2_SHARE_TYPE_PRINT"; + } + + return nullptr; +} + +const char* enumToString(NTStatus value) +{ + switch (value) + { + case NTStatus::STATUS_SUCCESS: return "STATUS_SUCCESS"; + case NTStatus::STATUS_NO_MORE_FILES: return "STATUS_NO_MORE_FILES"; + case NTStatus::STATUS_INVALID_HANDLE: return "STATUS_INVALID_HANDLE"; + case NTStatus::STATUS_INVALID_PARAMETER: return "STATUS_INVALID_PARAMETER"; + case NTStatus::STATUS_NO_SUCH_FILE: return "STATUS_NO_SUCH_FILE"; + case NTStatus::STATUS_MORE_PROCESSING_REQUIRED: return "STATUS_MORE_PROCESSING_REQUIRED"; + case NTStatus::STATUS_INVALID_SYSTEM_SERVICE: return "STATUS_INVALID_SYSTEM_SERVICE"; + case NTStatus::STATUS_ACCESS_DENIED: return "STATUS_ACCESS_DENIED"; + case NTStatus::STATUS_OBJECT_NAME_INVALID: return "STATUS_OBJECT_NAME_INVALID"; + case NTStatus::STATUS_OBJECT_NAME_NOT_FOUND: return "STATUS_OBJECT_NAME_NOT_FOUND"; + case NTStatus::STATUS_OBJECT_NAME_COLLISION: return "STATUS_OBJECT_NAME_COLLISION"; + case NTStatus::STATUS_OBJECT_PATH_NOT_FOUND: return "STATUS_OBJECT_PATH_NOT_FOUND"; + case NTStatus::STATUS_OBJECT_PATH_SYNTAX_BAD: return "STATUS_OBJECT_PATH_SYNTAX_BAD"; + case NTStatus::STATUS_SHARING_VIOLATION: return "STATUS_SHARING_VIOLATION"; + case NTStatus::STATUS_EA_TOO_LARGE: return "STATUS_EA_TOO_LARGE"; + case NTStatus::STATUS_FILE_LOCK_CONFLICT: return "STATUS_FILE_LOCK_CONFLICT"; + case NTStatus::STATUS_LOCK_NOT_GRANTED: return "STATUS_LOCK_NOT_GRANTED"; + case NTStatus::STATUS_LOGON_FAILURE: return "STATUS_LOGON_FAILURE"; + case NTStatus::STATUS_RANGE_NOT_LOCKED: return "STATUS_RANGE_NOT_LOCKED"; + case NTStatus::STATUS_FILE_IS_A_DIRECTORY: return "STATUS_FILE_IS_A_DIRECTORY"; + case NTStatus::STATUS_NOT_SUPPORTED: return "STATUS_NOT_SUPPORTED"; + case NTStatus::STATUS_BAD_DEVICE_TYPE: return "STATUS_BAD_DEVICE_TYPE"; + case NTStatus::STATUS_REQUEST_NOT_ACCEPTED: return "STATUS_REQUEST_NOT_ACCEPTED"; + case NTStatus::STATUS_DIRECTORY_NOT_EMPTY: return "STATUS_DIRECTORY_NOT_EMPTY"; + case NTStatus::STATUS_NOT_A_DIRECTORY: return "STATUS_NOT_A_DIRECTORY"; + case NTStatus::STATUS_CANCELLED: return "STATUS_CANCELLED"; + } + + return nullptr; +} + +const char* enumToString(FsInfoLevels value) +{ + switch (value) + { + case FsInfoLevels::SMB2_FS_INFO_01: return "SMB2_FS_INFO_01"; + case FsInfoLevels::SMB2_FS_INFO_02: return "SMB2_FS_INFO_02"; + case FsInfoLevels::SMB2_FS_INFO_03: return "SMB2_FS_INFO_03"; + case FsInfoLevels::SMB2_FS_INFO_04: return "SMB2_FS_INFO_04"; + case FsInfoLevels::SMB2_FS_INFO_05: return "SMB2_FS_INFO_05"; + case FsInfoLevels::SMB2_FS_INFO_06: return "SMB2_FS_INFO_06"; + case FsInfoLevels::SMB2_FS_INFO_07: return "SMB2_FS_INFO_07"; + } + + return nullptr; +} + +const char* enumToString(QueryInfoLevels value) +{ + switch (value) + { + case QueryInfoLevels::DIRECTORY_INFORMATION: return "DIRECTORY_INFORMATION"; + case QueryInfoLevels::FULL_DIRECTORY_INFORMATION: return "FULL_DIRECTORY_INFORMATION"; + case QueryInfoLevels::BOTH_DIRECTORY_INFORMATION: return "BOTH_DIRECTORY_INFORMATION"; + case QueryInfoLevels::BASIC_INFORMATION: return "BASIC_INFORMATION"; + case QueryInfoLevels::STANDARD_INFORMATION: return "STANDARD_INFORMATION"; + case QueryInfoLevels::INTERNAL_INFORMATION: return "INTERNAL_INFORMATION"; + case QueryInfoLevels::EA_INFORMATION: return "EA_INFORMATION"; + case QueryInfoLevels::ACCESS_INFORMATION: return "ACCESS_INFORMATION"; + case QueryInfoLevels::NAME_INFORMATION: return "NAME_INFORMATION"; + case QueryInfoLevels::RENAME_INFORMATION: return "RENAME_INFORMATION"; + case QueryInfoLevels::LINK_INFORMATION: return "LINK_INFORMATION"; + case QueryInfoLevels::NAMES_INFORMATION: return "NAMES_INFORMATION"; + case QueryInfoLevels::DISPOSITION_INFORMATION: return "DISPOSITION_INFORMATION"; + case QueryInfoLevels::POSITION_INFORMATION: return "POSITION_INFORMATION"; + case QueryInfoLevels::FULL_EA_INFORMATION: return "FULL_EA_INFORMATION"; + case QueryInfoLevels::MODE_INFORMATION: return "MODE_INFORMATION"; + case QueryInfoLevels::ALIGNMENT_INFORMATION: return "ALIGNMENT_INFORMATION"; + case QueryInfoLevels::ALL_INFORMATION: return "ALL_INFORMATION"; + case QueryInfoLevels::ALLOCATION_INFORMATION: return "ALLOCATION_INFORMATION"; + case QueryInfoLevels::END_OF_FILE_INFORMATION: return "END_OF_FILE_INFORMATION"; + case QueryInfoLevels::ALTERNATE_NAME_INFORMATION: return "ALTERNATE_NAME_INFORMATION"; + case QueryInfoLevels::STREAM_INFORMATION: return "STREAM_INFORMATION"; + case QueryInfoLevels::PIPE_INFORMATION: return "PIPE_INFORMATION"; + case QueryInfoLevels::PIPE_LOCAL_INFORMATION: return "PIPE_LOCAL_INFORMATION"; + case QueryInfoLevels::PIPE_REMOTE_INFORMATION: return "PIPE_REMOTE_INFORMATION"; + case QueryInfoLevels::MAILSLOT_QUERY_INFORMATION: return "MAILSLOT_QUERY_INFORMATION"; + case QueryInfoLevels::MAILSLOT_SET_INFORMATION: return "MAILSLOT_SET_INFORMATION"; + case QueryInfoLevels::COMPRESSION_INFORMATION: return "COMPRESSION_INFORMATION"; + case QueryInfoLevels::OBJECT_ID_INFORMATION: return "OBJECT_ID_INFORMATION"; + case QueryInfoLevels::MOVE_CLUSTER_INFORMATION: return "MOVE_CLUSTER_INFORMATION"; + case QueryInfoLevels::QUOTA_INFORMATION: return "QUOTA_INFORMATION"; + case QueryInfoLevels::REPARSE_POINT_INFORMATION: return "REPARSE_POINT_INFORMATION"; + case QueryInfoLevels::NETWORK_OPEN_INFORMATION: return "NETWORK_OPEN_INFORMATION"; + case QueryInfoLevels::ATTRIBUTE_TAG_INFORMATION: return "ATTRIBUTE_TAG_INFORMATION"; + case QueryInfoLevels::TRACKING_INFORMATION: return "TRACKING_INFORMATION"; + case QueryInfoLevels::ID_BOTH_DIRECTORY_INFORMATION: return "ID_BOTH_DIRECTORY_INFORMATION"; + case QueryInfoLevels::ID_FULL_DIRECTORY_INFORMATION: return "ID_FULL_DIRECTORY_INFORMATION"; + case QueryInfoLevels::VALID_DATA_LENGTH_INFORMATION: return "VALID_DATA_LENGTH_INFORMATION"; + case QueryInfoLevels::SHORT_NAME_INFORMATION: return "SHORT_NAME_INFORMATION"; + case QueryInfoLevels::SFIO_RESERVE_INFORMATION: return "SFIO_RESERVE_INFORMATION"; + case QueryInfoLevels::SFIO_VOLUME_INFORMATION: return "SFIO_VOLUME_INFORMATION"; + case QueryInfoLevels::HARD_LINK_INFORMATION: return "HARD_LINK_INFORMATION"; + case QueryInfoLevels::NORMALIZED_NAME_INFORMATION: return "NORMALIZED_NAME_INFORMATION"; + case QueryInfoLevels::ID_GLOBAL_TX_DIRECTORY_INFORMATION: return "ID_GLOBAL_TX_DIRECTORY_INFORMATION"; + case QueryInfoLevels::STANDARD_LINK_INFORMATION: return "STANDARD_LINK_INFORMATION"; + } + + return nullptr; +} + +const char* enumToString(CtlCodes value) +{ + switch (value) + { + case CtlCodes::SCTL_DFS_GET_REFERRALS: return "SCTL_DFS_GET_REFERRALS"; + case CtlCodes::FSCTL_PIPE_PEEK: return "FSCTL_PIPE_PEEK"; + case CtlCodes::FSCTL_PIPE_WAIT: return "FSCTL_PIPE_WAIT"; + case CtlCodes::FSCTL_PIPE_TRANSCEIVE: return "FSCTL_PIPE_TRANSCEIVE"; + case CtlCodes::FSCTL_SRV_COPYCHUNK: return "FSCTL_SRV_COPYCHUNK"; + case CtlCodes::FSCTL_SRV_ENUMERATE_SNAPSHOTS: return "FSCTL_SRV_ENUMERATE_SNAPSHOTS"; + case CtlCodes::FSCTL_SRV_REQUEST_RESUME_KEY: return "FSCTL_SRV_REQUEST_RESUME_KEY"; + case CtlCodes::FSCTL_SRV_READ_HASH: return "FSCTL_SRV_READ_HASH"; + case CtlCodes::FSCTL_SRV_COPYCHUNK_WRITE: return "FSCTL_SRV_COPYCHUNK_WRITE"; + case CtlCodes::FSCTL_LMR_REQUEST_RESILIENCY: return "FSCTL_LMR_REQUEST_RESILIENCY"; + case CtlCodes::FSCTL_QUERY_NETWORK_INTERFACE_INFO: return "FSCTL_QUERY_NETWORK_INTERFACE_INFO"; + case CtlCodes::FSCTL_SET_REPARSE_POINT: return "FSCTL_SET_REPARSE_POINT"; + case CtlCodes::FSCTL_DFS_GET_REFERRALS_EX: return "FSCTL_DFS_GET_REFERRALS_EX"; + case CtlCodes::FSCTL_FILE_LEVEL_TRIM: return "FSCTL_FILE_LEVEL_TRIM"; + case CtlCodes::FSCTL_VALIDATE_NEGOTIATE_INFO: return "FSCTL_VALIDATE_NEGOTIATE_INFO"; + } + + return nullptr; +} + +const char* enumToString(InfoTypes value) +{ + switch (value) + { + case InfoTypes::FILE: return "SMB2_0_INFO_FILE"; + case InfoTypes::FILESYSTEM: return "SMB2_0_INFO_FILESYSTEM"; + case InfoTypes::SECURITY: return "SMB2_0_INFO_SECURITY"; + case InfoTypes::QUOTA: return "SMB2_0_INFO_QUOTA"; + } + + return nullptr; +} + +const char* enumToString(SessionFlagsBinding value) + { + switch (value) + { + case SessionFlagsBinding::NONE: return "NONE"; + case SessionFlagsBinding::BINDING: return "BINDING"; + } + + return nullptr; + } + +} + +std::ostream& operator<<(std::ostream& out, const SMBv2::SMBv2Commands value) +{ + const char* strCommand = NST::protocols::CIFSv2::print_cifs2_procedures(value); + + out << "(" << strCommand << ")"; + + return out; +} + +std::ostream& operator<<(std::ostream& out, const OplockLevels value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const ImpersonationLevels value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const CreateDisposition value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const CreateActions value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const ShareTypes value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const NTStatus value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const DesiredAccessFlags value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "READ_DATA_LE", int_value, DesiredAccessFlags::READ_DATA_LE); + print_flag_if_set(out, "WRITE_DATA_LE", int_value, DesiredAccessFlags::WRITE_DATA_LE); + print_flag_if_set(out, "APPEND_DATA_LE", int_value, DesiredAccessFlags::APPEND_DATA_LE); + print_flag_if_set(out, "READ_EA_LE", int_value, DesiredAccessFlags::READ_EA_LE); + print_flag_if_set(out, "WRITE_EA_LE", int_value, DesiredAccessFlags::WRITE_EA_LE); + print_flag_if_set(out, "EXECUTE_LE", int_value, DesiredAccessFlags::EXECUTE_LE); + print_flag_if_set(out, "READ_ATTRIBUTES_LE", int_value, DesiredAccessFlags::READ_ATTRIBUTES_LE); + print_flag_if_set(out, "WRITE_ATTRIBUTES_LE", int_value, DesiredAccessFlags::WRITE_ATTRIBUTES_LE); + print_flag_if_set(out, "DELETE_LE", int_value, DesiredAccessFlags::DELETE_LE); + print_flag_if_set(out, "READ_CONTROL_LE", int_value, DesiredAccessFlags::READ_CONTROL_LE); + print_flag_if_set(out, "WRITE_DAC_LE", int_value, DesiredAccessFlags::WRITE_DAC_LE); + print_flag_if_set(out, "WRITE_OWNER_LE", int_value, DesiredAccessFlags::WRITE_OWNER_LE); + print_flag_if_set(out, "SYNCHRONIZE_LE", int_value, DesiredAccessFlags::SYNCHRONIZE_LE); + print_flag_if_set(out, "ACCESS_SYSTEM_SECURITY_LE", int_value, DesiredAccessFlags::ACCESS_SYSTEM_SECURITY_LE); + print_flag_if_set(out, "MAXIMAL_ACCESS_LE", int_value, DesiredAccessFlags::MAXIMAL_ACCESS_LE); + print_flag_if_set(out, "GENERIC_ALL_LE", int_value, DesiredAccessFlags::GENERIC_ALL_LE); + print_flag_if_set(out, "GENERIC_EXECUTE_LE", int_value, DesiredAccessFlags::GENERIC_EXECUTE_LE); + print_flag_if_set(out, "GENERIC_WRITE_LE", int_value, DesiredAccessFlags::GENERIC_WRITE_LE); + print_flag_if_set(out, "GENERIC_READ_LE", int_value, DesiredAccessFlags::GENERIC_READ_LE); + out << ")"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const FileAttributes value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "READONLY", int_value, FileAttributes::READONLY); + print_flag_if_set(out, "HIDDEN", int_value, FileAttributes::HIDDEN); + print_flag_if_set(out, "SYSTEM", int_value, FileAttributes::SYSTEM); + print_flag_if_set(out, "DIRECTORY", int_value, FileAttributes::DIRECTORY); + print_flag_if_set(out, "ARCHIVE", int_value, FileAttributes::ARCHIVE); + print_flag_if_set(out, "NORMAL", int_value, FileAttributes::NORMAL); + print_flag_if_set(out, "TEMPORARY", int_value, FileAttributes::TEMPORARY); + print_flag_if_set(out, "SPARSE_FILE", int_value, FileAttributes::SPARSE_FILE); + print_flag_if_set(out, "REPARSE_POINT", int_value, FileAttributes::REPARSE_POINT); + print_flag_if_set(out, "COMPRESSED", int_value, FileAttributes::COMPRESSED); + print_flag_if_set(out, "OFFLINE", int_value, FileAttributes::OFFLINE); + print_flag_if_set(out, "NOT_CONTENT_INDEXED", int_value, FileAttributes::NOT_CONTENT_INDEXED); + print_flag_if_set(out, "ENCRYPTED", int_value, FileAttributes::ENCRYPTED); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const ShareAccessFlags value) +{ + auto int_value = to_integral(value); + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "SHARE_READ_LE", int_value, ShareAccessFlags::SHARE_READ_LE); + print_flag_if_set(out, "SHARE_WRITE_LE", int_value, ShareAccessFlags::SHARE_WRITE_LE); + print_flag_if_set(out, "SHARE_DELETE_LE", int_value, ShareAccessFlags::SHARE_DELETE_LE); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const CreateOptionsFlags value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "DIRECTORY_FILE_LE", int_value, CreateOptionsFlags::DIRECTORY_FILE_LE); + print_flag_if_set(out, "WRITE_THROUGH_LE", int_value, CreateOptionsFlags::WRITE_THROUGH_LE); + print_flag_if_set(out, "SEQUENTIAL_ONLY_LE", int_value, CreateOptionsFlags::SEQUENTIAL_ONLY_LE); + print_flag_if_set(out, "NO_INTERMEDIATE_BUFFERRING_LE",int_value, CreateOptionsFlags::NO_INTERMEDIATE_BUFFERRING_LE); + print_flag_if_set(out, "SYNCHRONOUS_IO_ALERT_LE", int_value, CreateOptionsFlags::SYNCHRONOUS_IO_ALERT_LE); + print_flag_if_set(out, "SYNCHRONOUS_IO_NON_ALERT_LE", int_value, CreateOptionsFlags::SYNCHRONOUS_IO_NON_ALERT_LE); + print_flag_if_set(out, "NON_DIRECTORY_FILE_LE", int_value, CreateOptionsFlags::NON_DIRECTORY_FILE_LE); + print_flag_if_set(out, "COMPLETE_IF_OPLOCKED_LE", int_value, CreateOptionsFlags::COMPLETE_IF_OPLOCKED_LE); + print_flag_if_set(out, "NO_EA_KNOWLEDGE_LE", int_value, CreateOptionsFlags::NO_EA_KNOWLEDGE_LE); + print_flag_if_set(out, "RANDOM_ACCESS_LE", int_value, CreateOptionsFlags::RANDOM_ACCESS_LE); + print_flag_if_set(out, "DELETE_ON_CLOSE_LE", int_value, CreateOptionsFlags::DELETE_ON_CLOSE_LE); + print_flag_if_set(out, "OPEN_BY_FILE_ID_LE", int_value, CreateOptionsFlags::OPEN_BY_FILE_ID_LE); + print_flag_if_set(out, "OPEN_FOR_BACKUP_INTENT_LE", int_value, CreateOptionsFlags::OPEN_FOR_BACKUP_INTENT_LE); + print_flag_if_set(out, "NO_COMPRESSION_LE", int_value, CreateOptionsFlags::NO_COMPRESSION_LE); + print_flag_if_set(out, "RESERVE_OPFILTER_LE", int_value, CreateOptionsFlags::RESERVE_OPFILTER_LE); + print_flag_if_set(out, "OPEN_REPARSE_POINT_LE", int_value, CreateOptionsFlags::OPEN_REPARSE_POINT_LE); + print_flag_if_set(out, "OPEN_NO_RECALL_LE", int_value, CreateOptionsFlags::OPEN_NO_RECALL_LE); + print_flag_if_set(out, "OPEN_FOR_FREE_SPACE_QUERY_LE", int_value, CreateOptionsFlags::OPEN_FOR_FREE_SPACE_QUERY_LE); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const WriteFlags value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "SMB2_WRITEFLAG_WRITE_THROUGH", int_value, WriteFlags::SMB2_WRITEFLAG_WRITE_THROUGH); + print_flag_if_set(out, "SMB2_WRITEFLAG_WRITE_UNBUFFERED", int_value, WriteFlags::SMB2_WRITEFLAG_WRITE_UNBUFFERED); + out << ")"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const ShareFlags value) +{ + auto int_value = to_integral(value) & ~to_integral(ShareFlags::NO_CACHING); + + out << "Caching policy = "; + switch(to_integral(value) & to_integral(ShareFlags::NO_CACHING)) + { + case to_integral(ShareFlags::MANUAL_CACHING): out << "MANUAL_CACHING"; break; + case to_integral(ShareFlags::AUTO_CACHING): out << "AUTO_CACHING"; break; + case to_integral(ShareFlags::VDO_CACHING): out << "VDO_CACHING"; break; + case to_integral(ShareFlags::NO_CACHING): out << "NO_CACHING"; break; + } + + if(int_value > 0) + { + out << flagDelimiter; + print_flag_if_set(out, "SMB2_SHAREFLAG_DFS", int_value, ShareFlags::DFS); + print_flag_if_set(out, "SMB2_SHAREFLAG_DFS_ROOT", int_value, ShareFlags::DFS_ROOT); + print_flag_if_set(out, "SMB2_SHAREFLAG_RESTRICT_EXCLUSIVE_OPENS", int_value, ShareFlags::RESTRICT_EXCLUSIVE_OPENS); + print_flag_if_set(out, "SMB2_SHAREFLAG_FORCE_SHARED_DELETE", int_value, ShareFlags::FORCE_SHARED_DELETE); + print_flag_if_set(out, "SMB2_SHAREFLAG_ALLOW_NAMESPACE_CACHING", int_value, ShareFlags::ALLOW_NAMESPACE_CACHING); + print_flag_if_set(out, "SMB2_SHAREFLAG_ACCESS_BASED_DIRECTORY_ENUM", int_value, ShareFlags::ACCESS_BASED_DIRECTORY_ENUM); + print_flag_if_set(out, "SMB2_SHAREFLAG_FORCE_LEVELII_OPLOCK", int_value, ShareFlags::FORCE_LEVELII_OPLOCK); + print_flag_if_set(out, "SMB2_SHAREFLAG_ENABLE_HASH_V1", int_value, ShareFlags::ENABLE_HASH); + print_flag_if_set(out, "SMB2_SHAREFLAG_ENABLE_HASH_V2", int_value, ShareFlags::ENABLE_HASH_2); + print_flag_if_set(out, "SMB2_SHAREFLAG_ENCRYPT_DATA", int_value, ShareFlags::ENABLE_ENCRYPT_DATA); + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const ShareCapabilities value) +{ + auto int_value = to_integral(value); + + if(int_value > 0) + { + out << "("; + print_flag_if_set(out, "SMB2_SHARE_CAP_DFS", int_value, ShareCapabilities::DFS); + print_flag_if_set(out, "SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY", int_value, ShareCapabilities::CONTINUOUS_AVAILABILITY); + print_flag_if_set(out, "SMB2_SHARE_CAP_SCALEOUT", int_value, ShareCapabilities::SCALEOUT); + print_flag_if_set(out, "SMB2_SHARE_CAP_CLUSTER", int_value, ShareCapabilities::CLUSTER); + print_flag_if_set(out, "SMB2_SHARE_CAP_ASYMMETRIC", int_value, ShareCapabilities::ASYMMETRIC); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const SecurityModeShort value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "SIGNING_ENABLED", int_value, SecurityModeShort::SIGNING_ENABLED); + print_flag_if_set(out, "SIGNING_REQUIRED", int_value, SecurityModeShort::SIGNING_REQUIRED); + out << ")"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const Capabilities value) +{ + auto int_value = to_integral(value); + + if(int_value > 0) + { + out << "("; + print_flag_if_set(out, "DFS", int_value, Capabilities::DFS); + print_flag_if_set(out, "LEASING", int_value, Capabilities::LEASING); + print_flag_if_set(out, "LARGE_MTU", int_value, Capabilities::LARGE_MTU); + print_flag_if_set(out, "MULTI_CHANNEL", int_value, Capabilities::MULTI_CHANNEL); + print_flag_if_set(out, "PERSISTENT_HANDLES",int_value, Capabilities::PERSISTENT_HANDLES); + print_flag_if_set(out, "DIRECTORY_LEASING", int_value, Capabilities::DIRECTORY_LEASING); + print_flag_if_set(out, "ENCRYPTION", int_value, Capabilities::ENCRYPTION); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const SessionFlags value) +{ + auto int_value = to_integral(value); + + print_flag_if_set(out, "NONE", int_value, SessionFlags::NONE); + print_flag_if_set(out, "SMB2_SESSION_FLAG_IS_GUEST", int_value, SessionFlags::IS_GUEST); + print_flag_if_set(out, "SMB2_SESSION_FLAG_IS_NULL", int_value, SessionFlags::IS_NULL); + print_flag_if_set(out, "SMB2_SESSION_FLAG_ENCRYPT_DATA",int_value, SessionFlags::IS_ENCRYPT_DATA); + + return out; +} + +std::ostream& operator<<(std::ostream& out, const AccessMask value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "FILE_READ_DATA", int_value, AccessMask::FILE_READ_DATA); + print_flag_if_set(out, "FILE_WRITE_DATA", int_value, AccessMask::FILE_WRITE_DATA); + print_flag_if_set(out, "FILE_APPEND_DATA", int_value, AccessMask::FILE_APPEND_DATA); + print_flag_if_set(out, "FILE_READ_EA", int_value, AccessMask::FILE_READ_EA); + print_flag_if_set(out, "FILE_WRITE_EA", int_value, AccessMask::FILE_WRITE_EA); + print_flag_if_set(out, "FILE_DELETE_CHILD", int_value, AccessMask::FILE_DELETE_CHILD); + print_flag_if_set(out, "FILE_EXECUTE", int_value, AccessMask::FILE_EXECUTE); + print_flag_if_set(out, "FILE_READ_ATTRIBUTES", int_value, AccessMask::FILE_READ_ATTRIBUTES); + print_flag_if_set(out, "FILE_WRITE_ATTRIBUTES", int_value, AccessMask::FILE_WRITE_ATTRIBUTES); + print_flag_if_set(out, "DELETE", int_value, AccessMask::DELETE); + print_flag_if_set(out, "READ_CONTROL", int_value, AccessMask::READ_CONTROL); + print_flag_if_set(out, "WRITE_DAC", int_value, AccessMask::WRITE_DAC); + print_flag_if_set(out, "WRITE_OWNER", int_value, AccessMask::WRITE_OWNER); + print_flag_if_set(out, "SYNCHRONIZE", int_value, AccessMask::SYNCHRONIZE); + print_flag_if_set(out, "ACCESS_SYSTEM_SECURITY", int_value, AccessMask::ACCESS_SYSTEM_SECURITY); + print_flag_if_set(out, "MAXIMUM_ALLOWED", int_value, AccessMask::MAXIMUM_ALLOWED); + print_flag_if_set(out, "GENERIC_ALL", int_value, AccessMask::GENERIC_ALL); + print_flag_if_set(out, "GENERIC_EXECUTE", int_value, AccessMask::GENERIC_EXECUTE); + print_flag_if_set(out, "GENERIC_WRITE", int_value, AccessMask::GENERIC_WRITE); + print_flag_if_set(out, "GENERIC_READ", int_value, AccessMask::GENERIC_READ); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const CloseFlags value) +{ + auto int_value = to_integral(value); + + if(int_value > 0) + { + out << "("; + print_flag_if_set(out, "POSTQUERY_ATTRIB", int_value, CloseFlags::POSTQUERY_ATTRIB); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const SecurityMode value) +{ + auto int_value = to_integral(value); + + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "SIGNING_ENABLED", int_value, SecurityMode::SIGNING_ENABLED); + print_flag_if_set(out, "SIGNING_REQUIRED", int_value, SecurityMode::SIGNING_REQUIRED); + out << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const FsInfoLevels value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const QueryInfoLevels value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const CtlCodes value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const InfoTypes value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const SessionFlagsBinding value) +{ + const char *strValue = enumToString(value); + if (strValue != nullptr) + { + out << "(" << strValue << ")"; + } + + return out; +} + +std::ostream& operator<<(std::ostream& out, const Flags value) +{ + auto int_value = to_integral(value); + if (int_value > 0) + { + out << "("; + print_flag_if_set(out, "SERVER_TO_REDIR", int_value, Flags::SERVER_TO_REDIR); + print_flag_if_set(out, "ASYNC_COMMAND", int_value, Flags::ASYNC_COMMAND); + print_flag_if_set(out, "RELATED_OPERATIONS", int_value, Flags::RELATED_OPERATIONS); + print_flag_if_set(out, "SIGNED", int_value, Flags::SIGNED); + print_flag_if_set(out, "DFS_OPERATIONS", int_value, Flags::DFS_OPERATIONS); + print_flag_if_set(out, "REPLAY_OPERATION", int_value, Flags::REPLAY_OPERATION); + out << ")"; + } + + return out; +} + +std::ostream& print_info_levels(std::ostream& out, const InfoTypes infoType, const uint8_t infoClass) +{ + switch(infoType) + { + case InfoTypes::FILE: + print_enum(out, "InfoLevel", static_cast<QueryInfoLevels>(infoClass)); + break; + case InfoTypes::FILESYSTEM: + print_enum(out, "InfoLevel", static_cast<FsInfoLevels>(infoClass)); + break; + default: + //we dont handle other classes + ; + } + return out; +} +} // namespace CIFSv2 +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ diff --git a/src/protocols/cifs2/cifs2_utils.h b/src/protocols/cifs2/cifs2_utils.h new file mode 100644 index 0000000..9666630 --- /dev/null +++ b/src/protocols/cifs2/cifs2_utils.h @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// Author: Artsem Iliasau +// Description: Helpers for parsing CIFSv2 structures. +// Copyright (c) 2015 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#ifndef CIFS2_UTILS_H +#define CIFS2_UTILS_H +//------------------------------------------------------------------------------ +#include <iosfwd> +#include <sstream> + +#include "api/cifs2_commands.h" +#include "protocols/nfs/nfs_utils.h" +#include "cifs2.h" +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace CIFSv2 +{ + +namespace SMBv2 = NST::API::SMBv2; + +/*! Convert enum type to underlying integer type + * \param e - instance of enumeration to be converted + * \return integer representation of enumeration + */ +template<typename E> +inline constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type +{ + return static_cast<typename std::underlying_type<E>::type>(e); +} +std::ostream& operator<<(std::ostream& out, const SMBv2::SMBv2Commands value); +std::ostream& operator<<(std::ostream& out, const SMBv2::QueryInfoLevels value); +std::ostream& operator<<(std::ostream& out, const SMBv2::FsInfoLevels value); +std::ostream& operator<<(std::ostream& out, const SMBv2::CtlCodes value); +std::ostream& operator<<(std::ostream& out, const SMBv2::InfoTypes value); +std::ostream& operator<<(std::ostream& out, const SMBv2::ShareTypes value); +std::ostream& operator<<(std::ostream& out, const SMBv2::ShareFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::ShareCapabilities value); +std::ostream& operator<<(std::ostream& out, const SMBv2::OplockLevels value); +std::ostream& operator<<(std::ostream& out, const SMBv2::ImpersonationLevels value); +std::ostream& operator<<(std::ostream& out, const SMBv2::DesiredAccessFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::FileAttributes value); +std::ostream& operator<<(std::ostream& out, const SMBv2::ShareAccessFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::CreateDisposition value); +std::ostream& operator<<(std::ostream& out, const SMBv2::CreateOptionsFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::CreateActions value); +std::ostream& operator<<(std::ostream& out, const SMBv2::WriteFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::SessionFlagsBinding value); +std::ostream& operator<<(std::ostream& out, const SMBv2::SecurityModeShort value); +std::ostream& operator<<(std::ostream& out, const SMBv2::Capabilities value); +std::ostream& operator<<(std::ostream& out, const SMBv2::SessionFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::NTStatus value); +std::ostream& operator<<(std::ostream& out, const SMBv2::AccessMask value); +std::ostream& operator<<(std::ostream& out, const SMBv2::CloseFlags value); +std::ostream& operator<<(std::ostream& out, const SMBv2::SecurityMode value); +std::ostream& operator<<(std::ostream& out, Flags value); + +template <typename T> +std::ostream& print_enum(std::ostream& out, const std::string name, T value ) +{ + using namespace NST::protocols::NFS; + out << " " << name << " = "; + auto int_value = to_integral(value); + print_hex(out, int_value); + out << " " << value; + return out; +} + +std::ostream& print_info_levels(std::ostream& os, const NST::API::SMBv2::InfoTypes infoType, const uint8_t infoClass); + +} // namespace CIFSv2 +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ +#endif//CIFS2_UTILS_H +//------------------------------------------------------------------------------ diff --git a/src/protocols/ip/ipv4_header.h b/src/protocols/ip/ipv4_header.h index 856b47f..8f649ce 100644 --- a/src/protocols/ip/ipv4_header.h +++ b/src/protocols/ip/ipv4_header.h @@ -76,10 +76,10 @@ struct IPv4Header : private ipv4_header inline in_addr_t dst() const { return ipv4_dst; } inline uint16_t checksum() const { return ntohs(ipv4_checksum); } - inline bool is_fragmented() const { return ipv4_fragmentation & 0xff3f /*0xff3f == htons(MF | OFFMASK)*/; } + inline bool is_fragmented() const { return ipv4_fragmentation & htons(MF | OFFMASK); } inline bool is_fragmented_and_not_the_first_part() const { - return ipv4_fragmentation & 0xff1f /*offset() != 0*/; + return ipv4_fragmentation & htons(OFFMASK) /*offset() != 0*/; } } __attribute__ ((__packed__)); diff --git a/src/protocols/netbios/netbios.cpp b/src/protocols/netbios/netbios.cpp new file mode 100644 index 0000000..263f91a --- /dev/null +++ b/src/protocols/netbios/netbios.cpp @@ -0,0 +1,37 @@ +//------------------------------------------------------------------------------ +// Author: Andrey Kuznetsov +// Description: Helpers for parsing NETBios structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#include <arpa/inet.h> + +#include "protocols/netbios/netbios.h" +//------------------------------------------------------------------------------ +using namespace NST::protocols::NetBIOS; + +int8_t MessageHeader::start() const +{ + return _start; +} + +size_t MessageHeader::len() const +{ + // reserved field "_" is used as part of "length" field when length more than 65535 bytes + return ntohs(length) | (_ << 16); +} diff --git a/src/protocols/netbios/netbios.h b/src/protocols/netbios/netbios.h new file mode 100644 index 0000000..9fd5bd3 --- /dev/null +++ b/src/protocols/netbios/netbios.h @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// Author: Andrey Kuznetsov +// Description: Helpers for parsing NetBIOS structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#ifndef NETBIOS_HEADER_H +#define NETBIOS_HEADER_H +//------------------------------------------------------------------------------ +#include <stdlib.h> +#include <cstdint> +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace NetBIOS +{ + +/*! \class NetBIOS message header in SMB-direct case + */ +struct RawMessageHeader +{ + uint8_t _start;//!< In SMB direct always 0x00 + uint8_t _; + uint16_t length;//!< Packet length +} __attribute__ ((__packed__)); + +/*! \class NetBIOS message header wrapper + */ +struct MessageHeader : private RawMessageHeader +{ + int8_t start() const; + size_t len() const; +}; + +/*! Check is data valid NetBIOS message's header and return header or nullptr + * \param data - raw packet data + * \return pointer to input data which is casted to header structure or nullptr (if it is not valid header) + */ +inline const struct MessageHeader* get_header(const uint8_t* data) +{ + const MessageHeader* header (reinterpret_cast<const MessageHeader*>(data)); + if (header->start() == 0x00) + { + return header; + } + return nullptr; +} + +} // namespace NetBIOS +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ +#endif//NETBIOS_HEADER_H +//------------------------------------------------------------------------------ diff --git a/src/protocols/nfs/nfs_procedure.h b/src/protocols/nfs/nfs_procedure.h index 765dc16..9fc93dc 100644 --- a/src/protocols/nfs/nfs_procedure.h +++ b/src/protocols/nfs/nfs_procedure.h @@ -24,17 +24,20 @@ //------------------------------------------------------------------------------ #include <rpc/rpc.h> -#include "api/rpc_procedure.h" +#include "api/rpc_types.h" #include "protocols/nfs3/nfs3_utils.h" #include "protocols/nfs4/nfs4_utils.h" +#include "protocols/nfs4/nfs41_utils.h" #include "utils/sessions.h" //------------------------------------------------------------------------------ namespace NST { namespace protocols { -using namespace NFS3; -using namespace NFS4; + +using NFS3::proc_t_of; +using NFS4::proc_t_of; +using NFS41::proc_t_of; template < @@ -48,15 +51,15 @@ public: : parg{&arg} // set pointer to argument , pres{&res} // set pointer to result { - memset(&rpc_call, 0,sizeof(rpc_call )); - memset(&rpc_reply,0,sizeof(rpc_reply)); + memset(&call, 0,sizeof(call )); + memset(&reply,0,sizeof(reply)); memset(&arg, 0,sizeof(arg )); memset(&res, 0,sizeof(res )); // fill call - if(!xdr_callmsg(c.xdr(), &rpc_call)) + if(!xdr_callmsg(c.xdr(), &call)) { - xdr_free((xdrproc_t)xdr_callmsg, (char*)&rpc_call); + xdr_free((xdrproc_t)xdr_callmsg, (char*)&call); throw xdr::XDRDecoderError{"XDRDecoder: cann't read call data"}; } @@ -64,31 +67,31 @@ public: if(!proc_t_of(arg)(c.xdr(),&arg)) { xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg ); - xdr_free((xdrproc_t)xdr_callmsg, (char*)&rpc_call); + xdr_free((xdrproc_t)xdr_callmsg, (char*)&call); throw xdr::XDRDecoderError{"XDRDecoder: cann't read call arguments"}; } - rpc_reply.ru.RM_rmb.ru.RP_ar.ru.AR_results.proc = &return_true; + reply.ru.RM_rmb.ru.RP_ar.ru.AR_results.proc = &return_true; // fill reply - if(!xdr_replymsg (r.xdr(), &rpc_reply)) + if(!xdr_replymsg (r.xdr(), &reply)) { - xdr_free((xdrproc_t)xdr_replymsg, (char*)&rpc_reply); + xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply); xdr_free((xdrproc_t)proc_t_of(arg),(char*)&arg ); - xdr_free((xdrproc_t)xdr_callmsg, (char*)&rpc_call ); + xdr_free((xdrproc_t)xdr_callmsg, (char*)&call ); throw xdr::XDRDecoderError{"XDRDecoder: cann't read reply data"}; } - if(rpc_reply.ru.RM_rmb.rp_stat == reply_stat::MSG_ACCEPTED && - rpc_reply.ru.RM_rmb.ru.RP_ar.ar_stat == accept_stat::SUCCESS) + if(reply.ru.RM_rmb.rp_stat == reply_stat::MSG_ACCEPTED && + reply.ru.RM_rmb.ru.RP_ar.ar_stat == accept_stat::SUCCESS) { // fill reply results if(!proc_t_of(res)(r.xdr(),&res)) { xdr_free((xdrproc_t)proc_t_of(res), (char*)&res ); - xdr_free((xdrproc_t)xdr_replymsg, (char*)&rpc_reply); + xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply); xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg ); - xdr_free((xdrproc_t)xdr_callmsg, (char*)&rpc_call ); + xdr_free((xdrproc_t)xdr_callmsg, (char*)&call ); throw xdr::XDRDecoderError{"XDRDecoder: cann't read reply results"}; } } @@ -106,9 +109,9 @@ public: inline ~NFSProcedure() { if(pres) xdr_free((xdrproc_t)proc_t_of(res), (char*)&res ); - xdr_free((xdrproc_t)xdr_replymsg, (char*)&rpc_reply); + xdr_free((xdrproc_t)xdr_replymsg, (char*)&reply); xdr_free((xdrproc_t)proc_t_of(arg), (char*)&arg ); - xdr_free((xdrproc_t)xdr_callmsg, (char*)&rpc_call ); + xdr_free((xdrproc_t)xdr_callmsg, (char*)&call ); } // pointers to procedure specific argument and result @@ -125,34 +128,43 @@ private: namespace NFS3 { -using NFSPROC3RPCGEN_NULL = NFSProcedure <rpcgen::NULL3args, rpcgen::NULL3res>; -using NFSPROC3RPCGEN_GETATTR = NFSProcedure <rpcgen::GETATTR3args, rpcgen::GETATTR3res>; -using NFSPROC3RPCGEN_SETATTR = NFSProcedure <rpcgen::SETATTR3args, rpcgen::SETATTR3res>; -using NFSPROC3RPCGEN_LOOKUP = NFSProcedure <rpcgen::LOOKUP3args, rpcgen::LOOKUP3res>; -using NFSPROC3RPCGEN_ACCESS = NFSProcedure <rpcgen::ACCESS3args, rpcgen::ACCESS3res>; -using NFSPROC3RPCGEN_READLINK = NFSProcedure <rpcgen::READLINK3args, rpcgen::READLINK3res>; -using NFSPROC3RPCGEN_READ = NFSProcedure <rpcgen::READ3args, rpcgen::READ3res>; -using NFSPROC3RPCGEN_WRITE = NFSProcedure <rpcgen::WRITE3args, rpcgen::WRITE3res>; -using NFSPROC3RPCGEN_CREATE = NFSProcedure <rpcgen::CREATE3args, rpcgen::CREATE3res>; -using NFSPROC3RPCGEN_MKDIR = NFSProcedure <rpcgen::MKDIR3args, rpcgen::MKDIR3res>; -using NFSPROC3RPCGEN_SYMLINK = NFSProcedure <rpcgen::SYMLINK3args, rpcgen::SYMLINK3res>; -using NFSPROC3RPCGEN_MKNOD = NFSProcedure <rpcgen::MKNOD3args, rpcgen::MKNOD3res>; -using NFSPROC3RPCGEN_REMOVE = NFSProcedure <rpcgen::REMOVE3args, rpcgen::REMOVE3res>; -using NFSPROC3RPCGEN_RMDIR = NFSProcedure <rpcgen::RMDIR3args, rpcgen::RMDIR3res>; -using NFSPROC3RPCGEN_RENAME = NFSProcedure <rpcgen::RENAME3args, rpcgen::RENAME3res>; -using NFSPROC3RPCGEN_LINK = NFSProcedure <rpcgen::LINK3args, rpcgen::LINK3res>; -using NFSPROC3RPCGEN_READDIR = NFSProcedure <rpcgen::READDIR3args, rpcgen::READDIR3res>; -using NFSPROC3RPCGEN_READDIRPLUS = NFSProcedure <rpcgen::READDIRPLUS3args, rpcgen::READDIRPLUS3res>; -using NFSPROC3RPCGEN_FSSTAT = NFSProcedure <rpcgen::FSSTAT3args, rpcgen::FSSTAT3res>; -using NFSPROC3RPCGEN_FSINFO = NFSProcedure <rpcgen::FSINFO3args, rpcgen::FSINFO3res>; -using NFSPROC3RPCGEN_PATHCONF = NFSProcedure <rpcgen::PATHCONF3args, rpcgen::PATHCONF3res>; -using NFSPROC3RPCGEN_COMMIT = NFSProcedure <rpcgen::COMMIT3args, rpcgen::COMMIT3res>; +namespace NFS3 = NST::API::NFS3; +using NFSPROC3RPCGEN_NULL = NFSProcedure <NFS3::NULL3args, NFS3::NULL3res>; +using NFSPROC3RPCGEN_GETATTR = NFSProcedure <NFS3::GETATTR3args, NFS3::GETATTR3res>; +using NFSPROC3RPCGEN_SETATTR = NFSProcedure <NFS3::SETATTR3args, NFS3::SETATTR3res>; +using NFSPROC3RPCGEN_LOOKUP = NFSProcedure <NFS3::LOOKUP3args, NFS3::LOOKUP3res>; +using NFSPROC3RPCGEN_ACCESS = NFSProcedure <NFS3::ACCESS3args, NFS3::ACCESS3res>; +using NFSPROC3RPCGEN_READLINK = NFSProcedure <NFS3::READLINK3args, NFS3::READLINK3res>; +using NFSPROC3RPCGEN_READ = NFSProcedure <NFS3::READ3args, NFS3::READ3res>; +using NFSPROC3RPCGEN_WRITE = NFSProcedure <NFS3::WRITE3args, NFS3::WRITE3res>; +using NFSPROC3RPCGEN_CREATE = NFSProcedure <NFS3::CREATE3args, NFS3::CREATE3res>; +using NFSPROC3RPCGEN_MKDIR = NFSProcedure <NFS3::MKDIR3args, NFS3::MKDIR3res>; +using NFSPROC3RPCGEN_SYMLINK = NFSProcedure <NFS3::SYMLINK3args, NFS3::SYMLINK3res>; +using NFSPROC3RPCGEN_MKNOD = NFSProcedure <NFS3::MKNOD3args, NFS3::MKNOD3res>; +using NFSPROC3RPCGEN_REMOVE = NFSProcedure <NFS3::REMOVE3args, NFS3::REMOVE3res>; +using NFSPROC3RPCGEN_RMDIR = NFSProcedure <NFS3::RMDIR3args, NFS3::RMDIR3res>; +using NFSPROC3RPCGEN_RENAME = NFSProcedure <NFS3::RENAME3args, NFS3::RENAME3res>; +using NFSPROC3RPCGEN_LINK = NFSProcedure <NFS3::LINK3args, NFS3::LINK3res>; +using NFSPROC3RPCGEN_READDIR = NFSProcedure <NFS3::READDIR3args, NFS3::READDIR3res>; +using NFSPROC3RPCGEN_READDIRPLUS = NFSProcedure <NFS3::READDIRPLUS3args, NFS3::READDIRPLUS3res>; +using NFSPROC3RPCGEN_FSSTAT = NFSProcedure <NFS3::FSSTAT3args, NFS3::FSSTAT3res>; +using NFSPROC3RPCGEN_FSINFO = NFSProcedure <NFS3::FSINFO3args, NFS3::FSINFO3res>; +using NFSPROC3RPCGEN_PATHCONF = NFSProcedure <NFS3::PATHCONF3args, NFS3::PATHCONF3res>; +using NFSPROC3RPCGEN_COMMIT = NFSProcedure <NFS3::COMMIT3args, NFS3::COMMIT3res>; } namespace NFS4 { -using NFSPROC4RPCGEN_NULL = NFSProcedure <rpcgen::NULL4args, rpcgen::NULL4res>; -using NFSPROC4RPCGEN_COMPOUND = NFSProcedure <rpcgen::COMPOUND4args, rpcgen::COMPOUND4res>; +namespace NFS4 = NST::API::NFS4; +using NFSPROC4RPCGEN_NULL = NFSProcedure <NFS4::NULL4args, NFS4::NULL4res>; +using NFSPROC4RPCGEN_COMPOUND = NFSProcedure <NFS4::COMPOUND4args, NFS4::COMPOUND4res>; +} + +namespace NFS41 +{ +namespace NFS41 = NST::API::NFS41; +using NFSPROC41RPCGEN_NULL = NFSProcedure <NFS41::NULL4args, NFS41::NULL4res>; +using NFSPROC41RPCGEN_COMPOUND = NFSProcedure <NFS41::COMPOUND4args, NFS41::COMPOUND4res>; } } // namespace protocols diff --git a/src/protocols/nfs/nfs_utils.cpp b/src/protocols/nfs/nfs_utils.cpp index 0203634..a2517b9 100644 --- a/src/protocols/nfs/nfs_utils.cpp +++ b/src/protocols/nfs/nfs_utils.cpp @@ -1,5 +1,5 @@ //------------------------------------------------------------------------------ -// Author: Alexey Costroma +// Author: Alexey Costroma // Description: Helpers for parsing NFS structures. // Copyright (c) 2014 EPAM Systems //------------------------------------------------------------------------------ @@ -30,12 +30,39 @@ namespace protocols namespace NFS { +void print_hex64(std::ostream& out, uint64_t val) + +{ + out << "0x" << std::setfill('0') << std::setw(16) << std::hex << val + << std::dec << std::setfill(' '); +} + +void print_hex32(std::ostream& out, uint32_t val) +{ + out << "0x" << std::setfill('0') << std::setw(8) << std::hex << val + << std::dec << std::setfill(' '); +} + +void print_hex16(std::ostream& out, uint16_t val) +{ + out << "0x" << std::setfill('0') << std::setw(4) << std::hex << val + << std::dec << std::setfill(' '); +} + +void print_hex8(std::ostream& out, uint8_t val) +{ + out << "0x" << std::setfill('0') << std::setw(2) << std::hex + << static_cast<u_int16_t>(val) // prevent implicit cast to char + << std::dec << std::setfill(' '); +} + + void print_hex(std::ostream& out, const uint32_t* const val, const uint32_t len) { - if(len) + if (len) { - out << std::hex << std::setfill('0'); - for(uint32_t i {0}; i < len; i++) + out << std::hex << std::setfill('0') << "0x"; + for (uint32_t i {0}; i < len; i++) { out << std::setw(2) << val[i]; } @@ -49,13 +76,13 @@ void print_hex(std::ostream& out, const uint32_t* const val, const uint32_t len) void print_hex(std::ostream& out, const char* const val, const uint32_t len) { - if(len) + if (len) { - out << std::hex << std::setfill('0'); - for(uint32_t i {0}; i < len; i++) + out << std::hex << std::setfill('0') << "0x"; + for (uint32_t i {0}; i < len; i++) { - out << std::setw(2) - << ((static_cast<int32_t>(val[i])) & 0xFF); + out << std::setw(2) + << ((static_cast<int32_t>(val[i])) & 0xFF); } out << std::dec << std::setfill(' '); } @@ -67,12 +94,12 @@ void print_hex(std::ostream& out, const char* const val, const uint32_t len) void print_nfs_fh(std::ostream& out, const char* const val, const uint32_t len) { - if(len) + if (len) { out << std::hex << std::setfill('0'); - if(len <= 8 || out_all()) + if (len <= 8 || out_all()) { - for(uint32_t i {0}; i < len; i++) + for (uint32_t i {0}; i < len; i++) { out << std::setw(2) << ((static_cast<int32_t>(val[i])) & 0xFF); @@ -80,13 +107,13 @@ void print_nfs_fh(std::ostream& out, const char* const val, const uint32_t len) } else // truncate binary data to: 00112233...CCDDEEFF { - for(uint32_t i {0}; i < 4; i++) + for (uint32_t i {0}; i < 4; i++) { out << std::setw(2) << ((static_cast<int32_t>(val[i])) & 0xFF); } out << "..."; - for(uint32_t i {len-4}; i < len; i++) + for (uint32_t i {len - 4}; i < len; i++) { out << std::setw(2) << ((static_cast<int32_t>(val[i])) & 0xFF); diff --git a/src/protocols/nfs/nfs_utils.h b/src/protocols/nfs/nfs_utils.h index 402a51b..f4bedf4 100644 --- a/src/protocols/nfs/nfs_utils.h +++ b/src/protocols/nfs/nfs_utils.h @@ -19,16 +19,17 @@ along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. */ //------------------------------------------------------------------------------ -#define NST_PUBLIC __attribute__ ((visibility("default"))) #ifndef NFS_UTILS_H #define NFS_UTILS_H //------------------------------------------------------------------------------ #include <ostream> +#include <iomanip> #include <cstring> -#include "api/nfs3_types_rpcgen.h" #include "utils/out.h" //------------------------------------------------------------------------------ +#define NST_PUBLIC __attribute__ ((visibility("default"))) +//------------------------------------------------------------------------------ namespace NST { namespace protocols @@ -43,6 +44,42 @@ inline bool out_all() return Out::Global::get_level() == Out::Level::All; } +namespace +{ +template <typename T> +struct Helper +{ + static void print_hex(std::ostream& out, T val) + { + out << "0x" << std::setfill('0') << std::setw(sizeof(T)/4) << std::hex << val + << std::dec << std::setfill(' '); + } +}; +template <> +struct Helper<uint8_t> +{ + static void print_hex(std::ostream& out, char val) + { + out << "0x" << std::setfill('0') << std::setw(4) << std::hex << + static_cast<uint16_t>(val) << std::dec << std::setfill(' '); + } +}; +} + +template <typename T> +void print_hex(std::ostream& out, T val) +{ + Helper<T>::print_hex(out, val); +} + +void print_hex64(std::ostream& out, uint64_t val); + +void print_hex32(std::ostream& out, uint32_t val); + +void print_hex16(std::ostream& out, uint16_t val); + +void print_hex8(std::ostream& out, uint8_t val); + void print_hex(std::ostream& out, const uint32_t* const val, const uint32_t len); diff --git a/src/protocols/nfs/nfsv41.x b/src/protocols/nfs/nfsv41.x index b86092e..c2e7f31 100644 --- a/src/protocols/nfs/nfsv41.x +++ b/src/protocols/nfs/nfsv41.x @@ -1,16 +1,53 @@ /* - * This file was machine generated for - * draft-ietf-nfsv4-minorversion1-21 - * Last updated Mon Feb 25 16:16:21 CST 2008 - */ -/* - * Copyright (C) The IETF Trust (2007-2008) - * All Rights Reserved. + * Copyright (c) 2010 IETF Trust and the persons identified + * as the document authors. All rights reserved. + * + * The document authors are identified in RFC 3530 and + * RFC 5661. + * + * Redistribution and use in source and binary forms, with + * or without modification, are permitted provided that the + * following conditions are met: + * + * - Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * + * - Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the + * following disclaimer in the documentation and/or other + * materials provided with the distribution. * - * Copyright (C) The Internet Society (1998-2006). - * All Rights Reserved. + * - Neither the name of Internet Society, IETF or IETF + * Trust, nor the names of specific contributors, may be + * used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS + * AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * This code was derived from RFC 3530. Please + * reproduce this note if possible. + * + * This code was derived from RFC 5661. Please + * reproduce this note if possible. + * + * This file was machine generated from RFC 5662. */ - /* * nfs4_prot.x */ @@ -19,34 +56,18 @@ %#define _AUTH_SYS_DEFINE_FOR_NFSv41 %#include <rpc/auth_sys.h> %typedef struct authsys_parms authsys_parms; -%#endif _AUTH_SYS_DEFINE_FOR_NFSv41 +%#endif /* _AUTH_SYS_DEFINE_FOR_NFSv41 */ /* * Basic typedefs for RFC 1832 data type definitions */ -typedef int int32_t; -typedef unsigned int uint32_t; -typedef hyper int64_t; -typedef unsigned hyper uint64_t; - /* - * FRED - added missing referents + * typedef int int32_t; + * typedef unsigned int uint32_t; + * typedef hyper int64_t; + * typedef unsigned hyper uint64_t; */ -const FALSE = 0; -const TRUE = 1; - -const AUTH_NONE = 0; -const AUTH_SYS = 1; -const RPCSEC_GSS = 6; - -struct authsys_parms { - unsigned int stamp; - string machinename<255>; - unsigned int uid; - unsigned int gid; - unsigned int gids<16>; -}; /* * Sizes @@ -94,7 +115,13 @@ enum nfsstat4 { NFS4ERR_ACCESS = 13, /* access denied */ NFS4ERR_EXIST = 17, /* file already exists */ NFS4ERR_XDEV = 18, /* different filesystems */ - /* Unused/reserved 19 */ + + /* + * Please do not allocate value 19; it was used in NFSv3 + * and we do not want a value in NFSv3 to have a different + * meaning in NFSv4.x. + */ + NFS4ERR_NOTDIR = 20, /* should be a directory */ NFS4ERR_ISDIR = 21, /* should not be directory */ NFS4ERR_INVAL = 22, /* invalid argument */ @@ -173,7 +200,7 @@ enum nfsstat4 { NFS4ERR_NOMATCHING_LAYOUT = 10060, NFS4ERR_RECALLCONFLICT = 10061, NFS4ERR_UNKNOWN_LAYOUTTYPE = 10062, - NFS4ERR_SEQ_MISORDERED = 10063,/* unexpected seq.id in req*/ + NFS4ERR_SEQ_MISORDERED = 10063,/* unexpected seq.ID in req*/ NFS4ERR_SEQUENCE_POS = 10064,/* [CB_]SEQ. op not 1st op */ NFS4ERR_REQ_TOO_BIG = 10065,/* request too big */ NFS4ERR_REP_TOO_BIG = 10066,/* reply too big */ @@ -183,7 +210,7 @@ enum nfsstat4 { NFS4ERR_TOO_MANY_OPS = 10070,/*too many ops in [CB_]COMP*/ NFS4ERR_OP_NOT_IN_SESSION =10071,/* op needs [CB_]SEQ. op */ NFS4ERR_HASH_ALG_UNSUPP = 10072, /* hash alg. not supp. */ - NFS4ERR_CONN_BINDING_NOT_ENFORCED =10073,/* SET_SSV not OK*/ + /* Error 10073 is unused. */ NFS4ERR_CLIENTID_BUSY = 10074,/* clientid has state */ NFS4ERR_PNFS_IO_HOLE = 10075,/* IO to _SPARSE file hole */ NFS4ERR_SEQ_FALSE_RETRY= 10076,/* Retry != original req. */ @@ -194,9 +221,10 @@ enum nfsstat4 { NFS4ERR_NOT_ONLY_OP = 10081,/* addl ops not allowed */ NFS4ERR_WRONG_CRED = 10082,/* op done by wrong cred */ NFS4ERR_WRONG_TYPE = 10083,/* op on wrong type object */ - NFS4ERR_DIRDELEG_UNAVAIL= 10084,/* delegation not avail. */ + NFS4ERR_DIRDELEG_UNAVAIL=10084,/* delegation not avail. */ NFS4ERR_REJECT_DELEG = 10085,/* cb rejected delegation */ - NFS4ERR_RETURNCONFLICT = 10086 /* layout get before return*/ + NFS4ERR_RETURNCONFLICT = 10086,/* layout get before return*/ + NFS4ERR_DELEG_REVOKED = 10087 /* deleg./layout revoked */ }; /* @@ -291,6 +319,9 @@ struct fs_locations4 { * Access Control Entries are supported. * Values for the fattr4_aclsupport attribute. */ + +typedef uint32_t fattr4_aclsupport; + const ACL4_SUPPORT_ALLOW_ACL = 0x00000001; const ACL4_SUPPORT_DENY_ACL = 0x00000002; const ACL4_SUPPORT_AUDIT_ACL = 0x00000004; @@ -426,6 +457,7 @@ struct nfsacl41 { nfsace4 na41_aces<>; }; + /* * Field definitions for the fattr4_mode * and fattr4_mode_set_masked attributes. @@ -514,12 +546,12 @@ struct layout_content4 { %/* -%/* LAYOUT4_OSD2_OBJECTS loc_body description +% * LAYOUT4_OSD2_OBJECTS loc_body description % * is in a separate .x file % */ % %/* -%/* LAYOUT4_BLOCK_VOLUME loc_body description +% * LAYOUT4_BLOCK_VOLUME loc_body description % * is in a separate .x file % */ @@ -643,7 +675,6 @@ typedef uint32_t fs_charset_cap4; * NFSv4.1 attributes */ typedef bitmap4 fattr4_supported_attrs; -typedef bitmap4 fattr4_suppattr_exclcreat; typedef nfs_ftype4 fattr4_type; typedef uint32_t fattr4_fh_expire_type; typedef changeid4 fattr4_change; @@ -656,7 +687,6 @@ typedef bool fattr4_unique_handles; typedef nfs_lease4 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; @@ -703,16 +733,16 @@ typedef settime4 fattr4_time_modify_set; /* * attributes new to NFSv4.1 */ +typedef bitmap4 fattr4_suppattr_exclcreat; typedef nfstime4 fattr4_dir_notif_delay; typedef nfstime4 fattr4_dirent_notif_delay; -typedef bool fattr4_absent; -typedef layouttype4 fattr4_fs_layout_type<>; /* FRED */ +typedef layouttype4 fattr4_fs_layout_types<>; typedef fs4_status fattr4_fs_status; -typedef fs_charset_cap4 fattr4_fs_charset_cap4; +typedef fs_charset_cap4 fattr4_fs_charset_cap; typedef uint32_t fattr4_layout_alignment; typedef uint32_t fattr4_layout_blksize; typedef layouthint4 fattr4_layout_hint; -typedef layouttype4 fattr4_layout_type<>; /* FRED */ +typedef layouttype4 fattr4_layout_types<>; typedef mdsthreshold4 fattr4_mdsthreshold; typedef retention_get4 fattr4_retention_get; typedef retention_set4 fattr4_retention_set; @@ -721,11 +751,11 @@ typedef retention_set4 fattr4_retentevt_set; typedef uint64_t fattr4_retention_hold; typedef nfsacl41 fattr4_dacl; typedef nfsacl41 fattr4_sacl; +typedef change_policy4 fattr4_change_policy; - -/* - * Mandatory Attributes - */ +%/* +% * REQUIRED Attributes +% */ const FATTR4_SUPPORTED_ATTRS = 0; const FATTR4_TYPE = 1; const FATTR4_FH_EXPIRE_TYPE = 2; @@ -739,11 +769,12 @@ const FATTR4_UNIQUE_HANDLES = 9; const FATTR4_LEASE_TIME = 10; const FATTR4_RDATTR_ERROR = 11; const FATTR4_FILEHANDLE = 19; +%/* new to NFSV4.1 */ const FATTR4_SUPPATTR_EXCLCREAT = 75; -/* - * Recommended Attributes - */ +%/* +% * RECOMMENDED Attributes +% */ const FATTR4_ACL = 12; const FATTR4_ACLSUPPORT = 13; const FATTR4_ARCHIVE = 14; @@ -787,15 +818,18 @@ const FATTR4_TIME_METADATA = 52; const FATTR4_TIME_MODIFY = 53; const FATTR4_TIME_MODIFY_SET = 54; const FATTR4_MOUNTED_ON_FILEID = 55; +% +%/* new to NFSV4.1 */ +% const FATTR4_DIR_NOTIF_DELAY = 56; const FATTR4_DIRENT_NOTIF_DELAY = 57; const FATTR4_DACL = 58; const FATTR4_SACL = 59; const FATTR4_CHANGE_POLICY = 60; const FATTR4_FS_STATUS = 61; -const FATTR4_FS_LAYOUT_TYPE = 62; +const FATTR4_FS_LAYOUT_TYPES = 62; const FATTR4_LAYOUT_HINT = 63; -const FATTR4_LAYOUT_TYPE = 64; +const FATTR4_LAYOUT_TYPES = 64; const FATTR4_LAYOUT_BLKSIZE = 65; const FATTR4_LAYOUT_ALIGNMENT = 66; const FATTR4_FS_LOCATIONS_INFO = 67; @@ -844,7 +878,7 @@ struct nfs_client_id4 { }; /* - * NFSv4.1 Client Owner (aka long hand client id) + * NFSv4.1 Client Owner (aka long hand client ID) */ struct client_owner4 { verifier4 co_verifier; @@ -1018,7 +1052,7 @@ enum filelayout_hint_care4 { NFLH4_CARE_STRIPE_COUNT = 0x00000080 }; % -%/* Encoded in the loh_body field of type layouthint4: */ +%/* Encoded in the loh_body field of data type layouthint4: */ % struct nfsv4_1_file_layouthint4 { uint32_t nflh_care; @@ -1031,7 +1065,10 @@ struct nfsv4_1_file_layouthint4 { % typedef netaddr4 multipath_list4<>; % -%/* Encoded in the da_addr_body field of type device_addr4: */ +%/* +% * Encoded in the da_addr_body field of +% * data type device_addr4: +% */ struct nfsv4_1_file_layout_ds_addr4 { uint32_t nflda_stripe_indices<>; multipath_list4 nflda_multipath_ds_list<>; @@ -1040,7 +1077,10 @@ struct nfsv4_1_file_layout_ds_addr4 { % % -%/* Encoded in the loc_body field of type layout_content4: */ +%/* +% * Encoded in the loc_body field of +% * data type layout_content4: +% */ struct nfsv4_1_file_layout4 { deviceid4 nfl_deviceid; nfl_util4 nfl_util; @@ -1052,11 +1092,17 @@ struct nfsv4_1_file_layout4 { % %/* -% * Encoded in the lou_body field of type layoutupdate4: -% * Nothing. lou_body is a zero length array of octets. +% * Encoded in the lou_body field of data type layoutupdate4: +% * Nothing. lou_body is a zero length array of bytes. % */ % +%/* +% * Encoded in the lrf_body field of +% * data type layoutreturn_file4: +% * Nothing. lrf_body is a zero length array of bytes. +% */ +% const ACCESS4_READ = 0x00000001; @@ -1498,8 +1544,8 @@ union open_claim4 switch (open_claim_type4 claim) { component4 file_delegate_prev; /* - * Like CLAIM_NULL. No special rights - * to file. Ordinary OPEN of the + * Like CLAIM_NULL. No special rights + * to file. Ordinary OPEN of the * specified file by current filehandle. */ case CLAIM_FH: /* new to v4.1 */ @@ -1507,7 +1553,7 @@ union open_claim4 switch (open_claim_type4 claim) { void; /* - * Like CLAIM_DELEGATE_PREV. Right to file based on a + * Like CLAIM_DELEGATE_PREV. Right to file based on a * delegation granted to a previous boot * instance of the client. File is identified by * by filehandle. @@ -1517,7 +1563,7 @@ union open_claim4 switch (open_claim_type4 claim) { void; /* - * Like CLAIM_DELEGATE_CUR. Right to file based on + * Like CLAIM_DELEGATE_CUR. Right to file based on * a delegation granted by the server. * File is identified by filehandle. */ @@ -1579,7 +1625,7 @@ enum why_no_delegation4 { /* new to v4.1 */ WND4_WRITE_DELEG_NOT_SUPP_FTYPE = 4, WND4_NOT_SUPP_UPGRADE = 5, WND4_NOT_SUPP_DOWNGRADE = 6, - WND4_CANCELED = 7, + WND4_CANCELLED = 7, WND4_IS_DIR = 8 }; @@ -2455,11 +2501,12 @@ union TEST_STATEID4res switch (nfsstat4 tsr_status) { union deleg_claim4 switch (open_claim_type4 dc_claim) { /* - * No special rights to object. Ordinary delegation - * request of the specified object. Object identified + * No special rights to object. Ordinary delegation + * request of the specified object. Object identified * by filehandle. */ case CLAIM_FH: /* new to v4.1 */ + /* CURRENT_FH: object being delegated */ void; /* @@ -2689,7 +2736,7 @@ union nfs_argop4 switch (nfs_opnum4 argop) { case OP_ILLEGAL: void; }; -union nfs_resop4 switch (nfs_opnum4 resop){ +union nfs_resop4 switch (nfs_opnum4 resop) { case OP_ACCESS: ACCESS4res opaccess; case OP_CLOSE: CLOSE4res opclose; case OP_COMMIT: COMMIT4res opcommit; @@ -2995,10 +3042,9 @@ const RCA4_TYPE_MASK_RDATA_DLG = 0; const RCA4_TYPE_MASK_WDATA_DLG = 1; const RCA4_TYPE_MASK_DIR_DLG = 2; const RCA4_TYPE_MASK_FILE_LAYOUT = 3; -const RCA4_TYPE_MASK_BLK_LAYOUT_MIN = 4; -const RCA4_TYPE_MASK_BLK_LAYOUT_MAX = 7; +const RCA4_TYPE_MASK_BLK_LAYOUT = 4; const RCA4_TYPE_MASK_OBJ_LAYOUT_MIN = 8; -const RCA4_TYPE_MASK_OBJ_LAYOUT_MAX = 11; +const RCA4_TYPE_MASK_OBJ_LAYOUT_MAX = 9; const RCA4_TYPE_MASK_OTHER_LAYOUT_MIN = 12; const RCA4_TYPE_MASK_OTHER_LAYOUT_MAX = 15; @@ -3128,7 +3174,7 @@ enum nfs_cb_opnum4 { OP_CB_ILLEGAL = 10044 }; -union nfs_cb_argop4 switch (nfs_cb_opnum4 argop) { /* FRED */ +union nfs_cb_argop4 switch (unsigned argop) { case OP_CB_GETATTR: CB_GETATTR4args opcbgetattr; case OP_CB_RECALL: @@ -3156,7 +3202,7 @@ union nfs_cb_argop4 switch (nfs_cb_opnum4 argop) { /* FRED */ case OP_CB_ILLEGAL: void; }; -union nfs_cb_resop4 switch (nfs_cb_opnum4 resop){ /* FRED */ +union nfs_cb_resop4 switch (unsigned resop) { case OP_CB_GETATTR: CB_GETATTR4res opcbgetattr; case OP_CB_RECALL: CB_RECALL4res opcbrecall; diff --git a/src/protocols/nfs3/nfs3_rpcgen.cpp b/src/protocols/nfs3/nfs3_rpcgen.cpp deleted file mode 100644 index 8c0d710..0000000 --- a/src/protocols/nfs3/nfs3_rpcgen.cpp +++ /dev/null @@ -1,1808 +0,0 @@ -//------------------------------------------------------------------------------ -// Author: Alexey Costroma -// Description: Definition and fill up NFSv3 procedures. -// Copyright (c) 2014 EPAM Systems -//------------------------------------------------------------------------------ -/* - This file is part of Nfstrace. - - Nfstrace is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, version 2 of the License. - - Nfstrace is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. -*/ -//------------------------------------------------------------------------------ -#include "api/nfs3_types_rpcgen.h" -//------------------------------------------------------------------------------ -namespace rpcgen -{ - -bool_t -xdr_uint64 (XDR *xdrs, uint64 *objp) -{ - - if (!xdr_u_longlong_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_uint32 (XDR *xdrs, uint32 *objp) -{ - - if (!xdr_u_int (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_int64 (XDR *xdrs, int64 *objp) -{ - - if (!xdr_longlong_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_int32 (XDR *xdrs, int32 *objp) -{ - - if (!xdr_int (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_filename3 (XDR *xdrs, filename3 *objp) -{ - - if (!xdr_string (xdrs, objp, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfspath3 (XDR *xdrs, nfspath3 *objp) -{ - - if (!xdr_string (xdrs, objp, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fileid3 (XDR *xdrs, fileid3 *objp) -{ - - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_cookie3 (XDR *xdrs, cookie3 *objp) -{ - - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_cookieverf3 (XDR *xdrs, cookieverf3 objp) -{ - - if (!xdr_opaque (xdrs, objp, NFS3_COOKIEVERFSIZE)) - return FALSE; - return TRUE; -} - -bool_t -xdr_createverf3 (XDR *xdrs, createverf3 objp) -{ - - if (!xdr_opaque (xdrs, objp, NFS3_CREATEVERFSIZE)) - return FALSE; - return TRUE; -} - -bool_t -xdr_writeverf3 (XDR *xdrs, writeverf3 objp) -{ - - if (!xdr_opaque (xdrs, objp, NFS3_WRITEVERFSIZE)) - return FALSE; - return TRUE; -} - -bool_t -xdr_uid3 (XDR *xdrs, uid3 *objp) -{ - - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gid3 (XDR *xdrs, gid3 *objp) -{ - - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_size3 (XDR *xdrs, size3 *objp) -{ - - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_offset3 (XDR *xdrs, offset3 *objp) -{ - - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_mode3 (XDR *xdrs, mode3 *objp) -{ - - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_count3 (XDR *xdrs, count3 *objp) -{ - - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfsstat3 (XDR *xdrs, nfsstat3 *objp) -{ - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ftype3 (XDR *xdrs, ftype3 *objp) -{ - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_specdata3 (XDR *xdrs, specdata3 *objp) -{ - - if (!xdr_uint32 (xdrs, &objp->specdata1)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->specdata2)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_fh3 (XDR *xdrs, nfs_fh3 *objp) -{ - - if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, NFS3_FHSIZE)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfstime3 (XDR *xdrs, nfstime3 *objp) -{ - - if (!xdr_uint32 (xdrs, &objp->seconds)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->nseconds)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr3 (XDR *xdrs, fattr3 *objp) -{ - - if (!xdr_ftype3 (xdrs, &objp->type)) - return FALSE; - if (!xdr_mode3 (xdrs, &objp->mode)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->nlink)) - return FALSE; - if (!xdr_uid3 (xdrs, &objp->uid)) - return FALSE; - if (!xdr_gid3 (xdrs, &objp->gid)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->size)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->used)) - return FALSE; - if (!xdr_specdata3 (xdrs, &objp->rdev)) - return FALSE; - if (!xdr_uint64 (xdrs, &objp->fsid)) - return FALSE; - if (!xdr_fileid3 (xdrs, &objp->fileid)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->atime)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->mtime)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->ctime)) - return FALSE; - return TRUE; -} - -bool_t -xdr_post_op_attr (XDR *xdrs, post_op_attr *objp) -{ - - if (!xdr_bool (xdrs, &objp->attributes_follow)) - return FALSE; - switch (objp->attributes_follow) { - case TRUE: - if (!xdr_fattr3 (xdrs, &objp->post_op_attr_u.attributes)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_wcc_attr (XDR *xdrs, wcc_attr *objp) -{ - - if (!xdr_size3 (xdrs, &objp->size)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->mtime)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->ctime)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pre_op_attr (XDR *xdrs, pre_op_attr *objp) -{ - - if (!xdr_bool (xdrs, &objp->attributes_follow)) - return FALSE; - switch (objp->attributes_follow) { - case TRUE: - if (!xdr_wcc_attr (xdrs, &objp->pre_op_attr_u.attributes)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_wcc_data (XDR *xdrs, wcc_data *objp) -{ - - if (!xdr_pre_op_attr (xdrs, &objp->before)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->after)) - return FALSE; - return TRUE; -} - -bool_t -xdr_post_op_fh3 (XDR *xdrs, post_op_fh3 *objp) -{ - - if (!xdr_bool (xdrs, &objp->handle_follows)) - return FALSE; - switch (objp->handle_follows) { - case TRUE: - if (!xdr_nfs_fh3 (xdrs, &objp->post_op_fh3_u.handle)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_time_how (XDR *xdrs, time_how *objp) -{ - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_set_mode3 (XDR *xdrs, set_mode3 *objp) -{ - - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_mode3 (xdrs, &objp->set_mode3_u.mode)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_set_uid3 (XDR *xdrs, set_uid3 *objp) -{ - - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_uid3 (xdrs, &objp->set_uid3_u.uid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_set_gid3 (XDR *xdrs, set_gid3 *objp) -{ - - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_gid3 (xdrs, &objp->set_gid3_u.gid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_set_size3 (XDR *xdrs, set_size3 *objp) -{ - - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_size3 (xdrs, &objp->set_size3_u.size)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_set_atime (XDR *xdrs, set_atime *objp) -{ - - if (!xdr_time_how (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME: - if (!xdr_nfstime3 (xdrs, &objp->set_atime_u.atime)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_set_mtime (XDR *xdrs, set_mtime *objp) -{ - - if (!xdr_time_how (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME: - if (!xdr_nfstime3 (xdrs, &objp->set_mtime_u.mtime)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_sattr3 (XDR *xdrs, sattr3 *objp) -{ - - if (!xdr_set_mode3 (xdrs, &objp->mode)) - return FALSE; - if (!xdr_set_uid3 (xdrs, &objp->uid)) - return FALSE; - if (!xdr_set_gid3 (xdrs, &objp->gid)) - return FALSE; - if (!xdr_set_size3 (xdrs, &objp->size)) - return FALSE; - if (!xdr_set_atime (xdrs, &objp->atime)) - return FALSE; - if (!xdr_set_mtime (xdrs, &objp->mtime)) - return FALSE; - return TRUE; -} - -bool_t -xdr_diropargs3 (XDR *xdrs, diropargs3 *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->dir)) - return FALSE; - if (!xdr_filename3 (xdrs, &objp->name)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETATTR3args (XDR *xdrs, GETATTR3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETATTR3resok (XDR *xdrs, GETATTR3resok *objp) -{ - - if (!xdr_fattr3 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETATTR3res (XDR *xdrs, GETATTR3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_GETATTR3resok (xdrs, &objp->GETATTR3res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_sattrguard3 (XDR *xdrs, sattrguard3 *objp) -{ - - if (!xdr_bool (xdrs, &objp->check)) - return FALSE; - switch (objp->check) { - case TRUE: - if (!xdr_nfstime3 (xdrs, &objp->sattrguard3_u.obj_ctime)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -// handmade for compatibility -bool_t -xdr_NULL3args (XDR*, NULL3args*) -{ - return TRUE; -} - -// handmade for compatibility -bool_t -xdr_NULL3res (XDR*, NULL3res*) -{ - return TRUE; -} - -bool_t -xdr_SETATTR3args (XDR *xdrs, SETATTR3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - if (!xdr_sattr3 (xdrs, &objp->new_attributes)) - return FALSE; - if (!xdr_sattrguard3 (xdrs, &objp->guard)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETATTR3resok (XDR *xdrs, SETATTR3resok *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETATTR3resfail (XDR *xdrs, SETATTR3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETATTR3res (XDR *xdrs, SETATTR3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_SETATTR3resok (xdrs, &objp->SETATTR3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_SETATTR3resfail (xdrs, &objp->SETATTR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_LOOKUP3args (XDR *xdrs, LOOKUP3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->what)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOOKUP3resok (XDR *xdrs, LOOKUP3resok *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOOKUP3resfail (XDR *xdrs, LOOKUP3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOOKUP3res (XDR *xdrs, LOOKUP3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_LOOKUP3resok (xdrs, &objp->LOOKUP3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_LOOKUP3resfail (xdrs, &objp->LOOKUP3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_ACCESS3args (XDR *xdrs, ACCESS3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->access)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ACCESS3resok (XDR *xdrs, ACCESS3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->access)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ACCESS3resfail (XDR *xdrs, ACCESS3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ACCESS3res (XDR *xdrs, ACCESS3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_ACCESS3resok (xdrs, &objp->ACCESS3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_ACCESS3resfail (xdrs, &objp->ACCESS3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_READLINK3args (XDR *xdrs, READLINK3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->symlink)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READLINK3resok (XDR *xdrs, READLINK3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) - return FALSE; - if (!xdr_nfspath3 (xdrs, &objp->data)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READLINK3resfail (XDR *xdrs, READLINK3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READLINK3res (XDR *xdrs, READLINK3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_READLINK3resok (xdrs, &objp->READLINK3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_READLINK3resfail (xdrs, &objp->READLINK3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_READ3args (XDR *xdrs, READ3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_offset3 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READ3resok (XDR *xdrs, READ3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READ3resfail (XDR *xdrs, READ3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READ3res (XDR *xdrs, READ3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_READ3resok (xdrs, &objp->READ3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_READ3resfail (xdrs, &objp->READ3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_stable_how (XDR *xdrs, stable_how *objp) -{ - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE3args (XDR *xdrs, WRITE3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_offset3 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_stable_how (xdrs, &objp->stable)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE3resok (XDR *xdrs, WRITE3resok *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_stable_how (xdrs, &objp->committed)) - return FALSE; - if (!xdr_writeverf3 (xdrs, objp->verf)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE3resfail (XDR *xdrs, WRITE3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE3res (XDR *xdrs, WRITE3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_WRITE3resok (xdrs, &objp->WRITE3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_WRITE3resfail (xdrs, &objp->WRITE3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_createmode3 (XDR *xdrs, createmode3 *objp) -{ - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_createhow3 (XDR *xdrs, createhow3 *objp) -{ - - if (!xdr_createmode3 (xdrs, &objp->mode)) - return FALSE; - switch (objp->mode) { - case UNCHECKED: - case GUARDED: - if (!xdr_sattr3 (xdrs, &objp->createhow3_u.obj_attributes)) - return FALSE; - break; - case EXCLUSIVE: - if (!xdr_createverf3 (xdrs, objp->createhow3_u.verf)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_CREATE3args (XDR *xdrs, CREATE3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_createhow3 (xdrs, &objp->how)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CREATE3resok (XDR *xdrs, CREATE3resok *objp) -{ - - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CREATE3resfail (XDR *xdrs, CREATE3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CREATE3res (XDR *xdrs, CREATE3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_CREATE3resok (xdrs, &objp->CREATE3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_CREATE3resfail (xdrs, &objp->CREATE3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_MKDIR3args (XDR *xdrs, MKDIR3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_sattr3 (xdrs, &objp->attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_MKDIR3resok (XDR *xdrs, MKDIR3resok *objp) -{ - - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_MKDIR3resfail (XDR *xdrs, MKDIR3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_MKDIR3res (XDR *xdrs, MKDIR3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_MKDIR3resok (xdrs, &objp->MKDIR3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_MKDIR3resfail (xdrs, &objp->MKDIR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_symlinkdata3 (XDR *xdrs, symlinkdata3 *objp) -{ - - if (!xdr_sattr3 (xdrs, &objp->symlink_attributes)) - return FALSE; - if (!xdr_nfspath3 (xdrs, &objp->symlink_data)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SYMLINK3args (XDR *xdrs, SYMLINK3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_symlinkdata3 (xdrs, &objp->symlink)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SYMLINK3resok (XDR *xdrs, SYMLINK3resok *objp) -{ - - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SYMLINK3resfail (XDR *xdrs, SYMLINK3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SYMLINK3res (XDR *xdrs, SYMLINK3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_SYMLINK3resok (xdrs, &objp->SYMLINK3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_SYMLINK3resfail (xdrs, &objp->SYMLINK3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_devicedata3 (XDR *xdrs, devicedata3 *objp) -{ - - if (!xdr_sattr3 (xdrs, &objp->dev_attributes)) - return FALSE; - if (!xdr_specdata3 (xdrs, &objp->spec)) - return FALSE; - return TRUE; -} - -bool_t -xdr_mknoddata3 (XDR *xdrs, mknoddata3 *objp) -{ - - if (!xdr_ftype3 (xdrs, &objp->type)) - return FALSE; - switch (objp->type) { - case NF3CHR: - case NF3BLK: - if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.device)) - return FALSE; - break; - case NF3SOCK: - case NF3FIFO: - if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.pipe_attributes)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_MKNOD3args (XDR *xdrs, MKNOD3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_mknoddata3 (xdrs, &objp->what)) - return FALSE; - return TRUE; -} - -bool_t -xdr_MKNOD3resok (XDR *xdrs, MKNOD3resok *objp) -{ - - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_MKNOD3resfail (XDR *xdrs, MKNOD3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_MKNOD3res (XDR *xdrs, MKNOD3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_MKNOD3resok (xdrs, &objp->MKNOD3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_MKNOD3resfail (xdrs, &objp->MKNOD3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_REMOVE3args (XDR *xdrs, REMOVE3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_REMOVE3resok (XDR *xdrs, REMOVE3resok *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_REMOVE3resfail (XDR *xdrs, REMOVE3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_REMOVE3res (XDR *xdrs, REMOVE3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_REMOVE3resok (xdrs, &objp->REMOVE3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_REMOVE3resfail (xdrs, &objp->REMOVE3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_RMDIR3args (XDR *xdrs, RMDIR3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RMDIR3resok (XDR *xdrs, RMDIR3resok *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RMDIR3resfail (XDR *xdrs, RMDIR3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RMDIR3res (XDR *xdrs, RMDIR3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_RMDIR3resok (xdrs, &objp->RMDIR3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_RMDIR3resfail (xdrs, &objp->RMDIR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_RENAME3args (XDR *xdrs, RENAME3args *objp) -{ - - if (!xdr_diropargs3 (xdrs, &objp->from)) - return FALSE; - if (!xdr_diropargs3 (xdrs, &objp->to)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RENAME3resok (XDR *xdrs, RENAME3resok *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RENAME3resfail (XDR *xdrs, RENAME3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RENAME3res (XDR *xdrs, RENAME3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_RENAME3resok (xdrs, &objp->RENAME3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_RENAME3resfail (xdrs, &objp->RENAME3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_LINK3args (XDR *xdrs, LINK3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_diropargs3 (xdrs, &objp->link)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LINK3resok (XDR *xdrs, LINK3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LINK3resfail (XDR *xdrs, LINK3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LINK3res (XDR *xdrs, LINK3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_LINK3resok (xdrs, &objp->LINK3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_LINK3resfail (xdrs, &objp->LINK3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_READDIR3args (XDR *xdrs, READDIR3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->dir)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - return TRUE; -} - -bool_t -xdr_entry3 (XDR *xdrs, entry3 *objp) -{ - - if (!xdr_fileid3 (xdrs, &objp->fileid)) - return FALSE; - if (!xdr_filename3 (xdrs, &objp->name)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entry3), (xdrproc_t) xdr_entry3)) - return FALSE; - return TRUE; -} - -bool_t -xdr_dirlist3 (XDR *xdrs, dirlist3 *objp) -{ - - if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entry3), (xdrproc_t) xdr_entry3)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIR3resok (XDR *xdrs, READDIR3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_dirlist3 (xdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIR3resfail (XDR *xdrs, READDIR3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIR3res (XDR *xdrs, READDIR3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_READDIR3resok (xdrs, &objp->READDIR3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_READDIR3resfail (xdrs, &objp->READDIR3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_READDIRPLUS3args (XDR *xdrs, READDIRPLUS3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->dir)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->dircount)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->maxcount)) - return FALSE; - return TRUE; -} - -bool_t -xdr_entryplus3 (XDR *xdrs, entryplus3 *objp) -{ - - if (!xdr_fileid3 (xdrs, &objp->fileid)) - return FALSE; - if (!xdr_filename3 (xdrs, &objp->name)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->name_attributes)) - return FALSE; - if (!xdr_post_op_fh3 (xdrs, &objp->name_handle)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entryplus3), (xdrproc_t) xdr_entryplus3)) - return FALSE; - return TRUE; -} - -bool_t -xdr_dirlistplus3 (XDR *xdrs, dirlistplus3 *objp) -{ - - if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entryplus3), (xdrproc_t) xdr_entryplus3)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIRPLUS3resok (XDR *xdrs, READDIRPLUS3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_dirlistplus3 (xdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIRPLUS3resfail (XDR *xdrs, READDIRPLUS3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIRPLUS3res (XDR *xdrs, READDIRPLUS3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_READDIRPLUS3resok (xdrs, &objp->READDIRPLUS3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_READDIRPLUS3resfail (xdrs, &objp->READDIRPLUS3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_FSSTAT3args (XDR *xdrs, FSSTAT3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) - return FALSE; - return TRUE; -} - -bool_t -xdr_FSSTAT3resok (XDR *xdrs, FSSTAT3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->tbytes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->fbytes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->abytes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->tfiles)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->ffiles)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->afiles)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->invarsec)) - return FALSE; - return TRUE; -} - -bool_t -xdr_FSSTAT3resfail (XDR *xdrs, FSSTAT3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_FSSTAT3res (XDR *xdrs, FSSTAT3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_FSSTAT3resok (xdrs, &objp->FSSTAT3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_FSSTAT3resfail (xdrs, &objp->FSSTAT3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_FSINFO3args (XDR *xdrs, FSINFO3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) - return FALSE; - return TRUE; -} - -bool_t -xdr_FSINFO3resok (XDR *xdrs, FSINFO3resok *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->rtmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->rtpref)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->rtmult)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->wtmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->wtpref)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->wtmult)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->dtpref)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->maxfilesize)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->time_delta)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->properties)) - return FALSE; - return TRUE; -} - -bool_t -xdr_FSINFO3resfail (XDR *xdrs, FSINFO3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_FSINFO3res (XDR *xdrs, FSINFO3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_FSINFO3resok (xdrs, &objp->FSINFO3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_FSINFO3resfail (xdrs, &objp->FSINFO3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_PATHCONF3args (XDR *xdrs, PATHCONF3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_PATHCONF3resok (XDR *xdrs, PATHCONF3resok *objp) -{ - int32_t *buf; - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->linkmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->name_max)) - return FALSE; - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_bool (xdrs, &objp->no_trunc)) - return FALSE; - if (!xdr_bool (xdrs, &objp->chown_restricted)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_insensitive)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_preserving)) - return FALSE; - } else { - IXDR_PUT_BOOL(buf, objp->no_trunc); - IXDR_PUT_BOOL(buf, objp->chown_restricted); - IXDR_PUT_BOOL(buf, objp->case_insensitive); - IXDR_PUT_BOOL(buf, objp->case_preserving); - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->linkmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->name_max)) - return FALSE; - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_bool (xdrs, &objp->no_trunc)) - return FALSE; - if (!xdr_bool (xdrs, &objp->chown_restricted)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_insensitive)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_preserving)) - return FALSE; - } else { - objp->no_trunc = IXDR_GET_BOOL(buf); - objp->chown_restricted = IXDR_GET_BOOL(buf); - objp->case_insensitive = IXDR_GET_BOOL(buf); - objp->case_preserving = IXDR_GET_BOOL(buf); - } - return TRUE; - } - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->linkmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->name_max)) - return FALSE; - if (!xdr_bool (xdrs, &objp->no_trunc)) - return FALSE; - if (!xdr_bool (xdrs, &objp->chown_restricted)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_insensitive)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_preserving)) - return FALSE; - return TRUE; -} - -bool_t -xdr_PATHCONF3resfail (XDR *xdrs, PATHCONF3resfail *objp) -{ - - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_PATHCONF3res (XDR *xdrs, PATHCONF3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_PATHCONF3resok (xdrs, &objp->PATHCONF3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_PATHCONF3resfail (xdrs, &objp->PATHCONF3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_COMMIT3args (XDR *xdrs, COMMIT3args *objp) -{ - - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_offset3 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - return TRUE; -} - -bool_t -xdr_COMMIT3resok (XDR *xdrs, COMMIT3resok *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - if (!xdr_writeverf3 (xdrs, objp->verf)) - return FALSE; - return TRUE; -} - -bool_t -xdr_COMMIT3resfail (XDR *xdrs, COMMIT3resfail *objp) -{ - - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_COMMIT3res (XDR *xdrs, COMMIT3res *objp) -{ - - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_COMMIT3resok (xdrs, &objp->COMMIT3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_COMMIT3resfail (xdrs, &objp->COMMIT3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -}// namespace rpcgen diff --git a/src/protocols/nfs3/nfs3_utils.cpp b/src/protocols/nfs3/nfs3_utils.cpp index 7ce8b2c..50a0961 100644 --- a/src/protocols/nfs3/nfs3_utils.cpp +++ b/src/protocols/nfs3/nfs3_utils.cpp @@ -22,6 +22,7 @@ #include "protocols/nfs/nfs_utils.h" #include "protocols/nfs3/nfs3_utils.h" //------------------------------------------------------------------------------ +using namespace NST::API::NFS3; using namespace NST::protocols::NFS; using namespace NST::protocols::xdr; //------------------------------------------------------------------------------ @@ -63,7 +64,7 @@ enum S_IXOTH = 0x00001 // Search in directory }; -void print_mode3(std::ostream& out, const rpcgen::uint32 val) +void print_mode3(std::ostream& out, const uint32 val) { if (val & S_ISUID) out << "USER_ID_EXEC "; if (val & S_ISGID) out << "GROUP_ID_EXEC "; @@ -79,116 +80,116 @@ void print_mode3(std::ostream& out, const rpcgen::uint32 val) if (val & S_IXOTH) out << "OTHER_EXEC"; } -void print_access3(std::ostream& out, const rpcgen::uint32 val) +void print_access3(std::ostream& out, const uint32 val) { - if (val & rpcgen::ACCESS3_READ) out << "READ "; - if (val & rpcgen::ACCESS3_LOOKUP) out << "LOOKUP "; - if (val & rpcgen::ACCESS3_MODIFY) out << "MODIFY "; - if (val & rpcgen::ACCESS3_EXTEND) out << "EXTEND "; - if (val & rpcgen::ACCESS3_DELETE) out << "DELETE "; - if (val & rpcgen::ACCESS3_EXECUTE) out << "EXECUTE "; + if (val & ACCESS3_READ) out << "READ "; + if (val & ACCESS3_LOOKUP) out << "LOOKUP "; + if (val & ACCESS3_MODIFY) out << "MODIFY "; + if (val & ACCESS3_EXTEND) out << "EXTEND "; + if (val & ACCESS3_DELETE) out << "DELETE "; + if (val & ACCESS3_EXECUTE) out << "EXECUTE "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfsstat3& obj) +std::ostream& operator<<(std::ostream& out, const nfsstat3& obj) { switch(obj) { - case rpcgen::nfsstat3::NFS3_OK: + case nfsstat3::NFS3_OK: return out << "OK"; - case rpcgen::nfsstat3::NFS3ERR_PERM: + case nfsstat3::NFS3ERR_PERM: return out << "ERR_PERM"; - case rpcgen::nfsstat3::NFS3ERR_NOENT: + case nfsstat3::NFS3ERR_NOENT: return out << "ERR_NOENT"; - case rpcgen::nfsstat3::NFS3ERR_IO: + case nfsstat3::NFS3ERR_IO: return out << "ERR_IO"; - case rpcgen::nfsstat3::NFS3ERR_NXIO: + case nfsstat3::NFS3ERR_NXIO: return out << "ERR_NXIO"; - case rpcgen::nfsstat3::NFS3ERR_ACCES: + case nfsstat3::NFS3ERR_ACCES: return out << "ERR_ACCES"; - case rpcgen::nfsstat3::NFS3ERR_EXIST: + case nfsstat3::NFS3ERR_EXIST: return out << "ERR_EXIST"; - case rpcgen::nfsstat3::NFS3ERR_XDEV: + case nfsstat3::NFS3ERR_XDEV: return out << "ERR_XDEV"; - case rpcgen::nfsstat3::NFS3ERR_NODEV: + case nfsstat3::NFS3ERR_NODEV: return out << "ERR_NODEV"; - case rpcgen::nfsstat3::NFS3ERR_NOTDIR: + case nfsstat3::NFS3ERR_NOTDIR: return out << "ERR_NOTDIR"; - case rpcgen::nfsstat3::NFS3ERR_ISDIR: + case nfsstat3::NFS3ERR_ISDIR: return out << "ERR_ISDIR"; - case rpcgen::nfsstat3::NFS3ERR_INVAL: + case nfsstat3::NFS3ERR_INVAL: return out << "ERR_INVAL"; - case rpcgen::nfsstat3::NFS3ERR_FBIG: + case nfsstat3::NFS3ERR_FBIG: return out << "ERR_FBIG"; - case rpcgen::nfsstat3::NFS3ERR_NOSPC: + case nfsstat3::NFS3ERR_NOSPC: return out << "ERR_NOSPC"; - case rpcgen::nfsstat3::NFS3ERR_ROFS: + case nfsstat3::NFS3ERR_ROFS: return out << "ERR_ROFS"; - case rpcgen::nfsstat3::NFS3ERR_MLINK: + case nfsstat3::NFS3ERR_MLINK: return out << "ERR_MLINK"; - case rpcgen::nfsstat3::NFS3ERR_NAMETOOLONG: + case nfsstat3::NFS3ERR_NAMETOOLONG: return out << "ERR_NAMETOOLONG"; - case rpcgen::nfsstat3::NFS3ERR_NOTEMPTY: + case nfsstat3::NFS3ERR_NOTEMPTY: return out << "ERR_NOTEMPTY"; - case rpcgen::nfsstat3::NFS3ERR_DQUOT: + case nfsstat3::NFS3ERR_DQUOT: return out << "ERR_DQUOT"; - case rpcgen::nfsstat3::NFS3ERR_STALE: + case nfsstat3::NFS3ERR_STALE: return out << "ERR_STALE"; - case rpcgen::nfsstat3::NFS3ERR_REMOTE: + case nfsstat3::NFS3ERR_REMOTE: return out << "ERR_REMOTE"; - case rpcgen::nfsstat3::NFS3ERR_BADHANDLE: + case nfsstat3::NFS3ERR_BADHANDLE: return out << "ERR_BADHANDLE"; - case rpcgen::nfsstat3::NFS3ERR_NOT_SYNC: + case nfsstat3::NFS3ERR_NOT_SYNC: return out << "ERR_NOT_SYNC"; - case rpcgen::nfsstat3::NFS3ERR_BAD_COOKIE: + case nfsstat3::NFS3ERR_BAD_COOKIE: return out << "ERR_BAD_COOKIE"; - case rpcgen::nfsstat3::NFS3ERR_NOTSUPP: + case nfsstat3::NFS3ERR_NOTSUPP: return out << "ERR_NOTSUPP"; - case rpcgen::nfsstat3::NFS3ERR_TOOSMALL: + case nfsstat3::NFS3ERR_TOOSMALL: return out << "ERR_TOOSMALL"; - case rpcgen::nfsstat3::NFS3ERR_SERVERFAULT: + case nfsstat3::NFS3ERR_SERVERFAULT: return out << "ERR_SERVERFAULT"; - case rpcgen::nfsstat3::NFS3ERR_BADTYPE: + case nfsstat3::NFS3ERR_BADTYPE: return out << "ERR_BADTYPE"; - case rpcgen::nfsstat3::NFS3ERR_JUKEBOX: + case nfsstat3::NFS3ERR_JUKEBOX: return out << "ERR_JUKEBOX"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::ftype3& obj) +std::ostream& operator<<(std::ostream& out, const ftype3& obj) { switch(obj) { - case rpcgen::ftype3::NF3REG: return out << "REG"; - case rpcgen::ftype3::NF3DIR: return out << "DIR"; - case rpcgen::ftype3::NF3BLK: return out << "BLK"; - case rpcgen::ftype3::NF3CHR: return out << "CHR"; - case rpcgen::ftype3::NF3LNK: return out << "LNK"; - case rpcgen::ftype3::NF3SOCK: return out << "SOCK"; - case rpcgen::ftype3::NF3FIFO: return out << "FIFO"; + case ftype3::NF3REG: return out << "REG"; + case ftype3::NF3DIR: return out << "DIR"; + case ftype3::NF3BLK: return out << "BLK"; + case ftype3::NF3CHR: return out << "CHR"; + case ftype3::NF3LNK: return out << "LNK"; + case ftype3::NF3SOCK: return out << "SOCK"; + case ftype3::NF3FIFO: return out << "FIFO"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::specdata3& obj) +std::ostream& operator<<(std::ostream& out, const specdata3& obj) { return out << " specdata1: " << obj.specdata1 << " specdata2: " << obj.specdata2; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_fh3& obj) +std::ostream& operator<<(std::ostream& out, const nfs_fh3& obj) { NFS::print_nfs_fh(out, obj.data.data_val, obj.data.data_len); return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfstime3& obj) +std::ostream& operator<<(std::ostream& out, const nfstime3& obj) { return out << "seconds: " << obj.seconds << " nseconds: " << obj.nseconds << ' '; } -std::ostream& operator<<(std::ostream& out, const rpcgen::fattr3& obj) +std::ostream& operator<<(std::ostream& out, const fattr3& obj) { out << " type: " << obj.type << " mode: "; @@ -209,90 +210,90 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::fattr3& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::post_op_attr& obj) +std::ostream& operator<<(std::ostream& out, const post_op_attr& obj) { if(obj.attributes_follow) return out << obj.post_op_attr_u.attributes; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::wcc_attr& obj) +std::ostream& operator<<(std::ostream& out, const wcc_attr& obj) { return out << " size: " << obj.size << " mtime: " << obj.mtime << " ctime: " << obj.ctime; } -std::ostream& operator<<(std::ostream& out, const rpcgen::pre_op_attr& obj) +std::ostream& operator<<(std::ostream& out, const pre_op_attr& obj) { if(obj.attributes_follow) return out << obj.pre_op_attr_u.attributes; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::wcc_data& obj) +std::ostream& operator<<(std::ostream& out, const wcc_data& obj) { return out << " before: " << obj.before << "after: " << obj.after; } -std::ostream& operator<<(std::ostream& out, const rpcgen::post_op_fh3& obj) +std::ostream& operator<<(std::ostream& out, const post_op_fh3& obj) { if(obj.handle_follows) return out << " handle: " << obj.post_op_fh3_u.handle; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::time_how& obj) +std::ostream& operator<<(std::ostream& out, const time_how& obj) { switch(obj) { - case rpcgen::time_how::DONT_CHANGE: + case time_how::DONT_CHANGE: return out << "DONT_CHANGE"; - case rpcgen::time_how::SET_TO_SERVER_TIME: + case time_how::SET_TO_SERVER_TIME: return out << "SET_TO_SERVER_TIME"; - case rpcgen::time_how::SET_TO_CLIENT_TIME: + case time_how::SET_TO_CLIENT_TIME: return out << "SET_TO_CLIENT_TIME"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::set_mode3& obj) +std::ostream& operator<<(std::ostream& out, const set_mode3& obj) { if(obj.set_it) return out << obj.set_mode3_u.mode; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::set_uid3& obj) +std::ostream& operator<<(std::ostream& out, const set_uid3& obj) { if(obj.set_it) return out << obj.set_uid3_u.uid; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::set_gid3& obj) +std::ostream& operator<<(std::ostream& out, const set_gid3& obj) { if(obj.set_it) return out << obj.set_gid3_u.gid; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::set_size3& obj) +std::ostream& operator<<(std::ostream& out, const set_size3& obj) { if(obj.set_it) return out << obj.set_size3_u.size; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::set_atime& obj) +std::ostream& operator<<(std::ostream& out, const set_atime& obj) { - if(obj.set_it == rpcgen::time_how::SET_TO_CLIENT_TIME) + if(obj.set_it == time_how::SET_TO_CLIENT_TIME) return out << obj.set_it << " " << obj.set_atime_u.atime; else return out << obj.set_it; } -std::ostream& operator<<(std::ostream& out, const rpcgen::set_mtime& obj) +std::ostream& operator<<(std::ostream& out, const set_mtime& obj) { - if(obj.set_it == rpcgen::time_how::SET_TO_CLIENT_TIME) + if(obj.set_it == time_how::SET_TO_CLIENT_TIME) return out << obj.set_it << " " << obj.set_mtime_u.mtime; else return out << obj.set_it; } -std::ostream& operator<<(std::ostream& out, const rpcgen::sattr3& obj) +std::ostream& operator<<(std::ostream& out, const sattr3& obj) { if(obj.mode.set_it) { @@ -303,94 +304,94 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::sattr3& obj) if(obj.uid.set_it) out << " uid: " << obj.uid.set_uid3_u.uid; if(obj.gid.set_it) out << " gid: " << obj.gid.set_gid3_u.gid; if(obj.size.set_it) out << " size: " << obj.size.set_size3_u.size; - if(obj.atime.set_it == rpcgen::time_how::SET_TO_CLIENT_TIME) + if(obj.atime.set_it == time_how::SET_TO_CLIENT_TIME) out << " atime: " << obj.atime.set_atime_u.atime; - if(obj.mtime.set_it == rpcgen::time_how::SET_TO_CLIENT_TIME) + if(obj.mtime.set_it == time_how::SET_TO_CLIENT_TIME) out << " atime: " << obj.mtime.set_mtime_u.mtime; return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::diropargs3& obj) +std::ostream& operator<<(std::ostream& out, const diropargs3& obj) { return out << " dir: " << obj.dir << " name: " << obj.name; } -std::ostream& operator<<(std::ostream& out, const rpcgen::sattrguard3& obj) +std::ostream& operator<<(std::ostream& out, const sattrguard3& obj) { if(obj.check) return out << " obj_ctime: " << obj.sattrguard3_u.obj_ctime; else return out << " void "; } -std::ostream& operator<<(std::ostream& out, const rpcgen::stable_how& obj) +std::ostream& operator<<(std::ostream& out, const stable_how& obj) { switch(obj) { - case rpcgen::stable_how::UNSTABLE: return out << "UNSTABLE"; - case rpcgen::stable_how::DATA_SYNC: return out << "DATA_SYNC"; - case rpcgen::stable_how::FILE_SYNC: return out << "FILE_SYNC"; + case stable_how::UNSTABLE: return out << "UNSTABLE"; + case stable_how::DATA_SYNC: return out << "DATA_SYNC"; + case stable_how::FILE_SYNC: return out << "FILE_SYNC"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::createmode3& obj) +std::ostream& operator<<(std::ostream& out, const createmode3& obj) { switch(obj) { - case rpcgen::createmode3::UNCHECKED: return out << "UNCHECKED"; - case rpcgen::createmode3::GUARDED: return out << "GUARDED"; - case rpcgen::createmode3::EXCLUSIVE: return out << "EXCLUSIVE"; + case createmode3::UNCHECKED: return out << "UNCHECKED"; + case createmode3::GUARDED: return out << "GUARDED"; + case createmode3::EXCLUSIVE: return out << "EXCLUSIVE"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::createhow3& obj) +std::ostream& operator<<(std::ostream& out, const createhow3& obj) { switch(obj.mode) { - case rpcgen::createmode3::UNCHECKED: - case rpcgen::createmode3::GUARDED: + case createmode3::UNCHECKED: + case createmode3::GUARDED: return out << obj.mode << " obj attributes: " << obj.createhow3_u.obj_attributes; - case rpcgen::createmode3::EXCLUSIVE: + case createmode3::EXCLUSIVE: out << obj.mode << " verf: "; - print_hex(out, obj.createhow3_u.verf, rpcgen::NFS3_COOKIEVERFSIZE); + print_hex(out, obj.createhow3_u.verf, NFS3_COOKIEVERFSIZE); break; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::symlinkdata3& obj) +std::ostream& operator<<(std::ostream& out, const symlinkdata3& obj) { return out << " symlink_attributes: " << obj.symlink_attributes << " symlink_data: " << obj.symlink_data; } -std::ostream& operator<<(std::ostream& out, const rpcgen::devicedata3& obj) +std::ostream& operator<<(std::ostream& out, const devicedata3& obj) { return out << " dev_attributes: " << obj.dev_attributes << " spec: " << obj.spec; } -std::ostream& operator<<(std::ostream& out, const rpcgen::mknoddata3& obj) +std::ostream& operator<<(std::ostream& out, const mknoddata3& obj) { out << " type: " << obj.type; switch(obj.type) { - case rpcgen::ftype3::NF3CHR: - case rpcgen::ftype3::NF3BLK: + case ftype3::NF3CHR: + case ftype3::NF3BLK: return out << " device: " << obj.mknoddata3_u.device; - case rpcgen::ftype3::NF3SOCK: - case rpcgen::ftype3::NF3FIFO: + case ftype3::NF3SOCK: + case ftype3::NF3FIFO: return out << " pipe_attributes: " << obj.mknoddata3_u.pipe_attributes; default: break; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::entry3& obj) +std::ostream& operator<<(std::ostream& out, const entry3& obj) { out << " file id: " << obj.fileid << " name: " << obj.name @@ -399,14 +400,14 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::entry3& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::dirlist3& obj) +std::ostream& operator<<(std::ostream& out, const dirlist3& obj) { out << " eof: " << obj.eof; if(obj.entries) out << *obj.entries; return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::entryplus3& obj) +std::ostream& operator<<(std::ostream& out, const entryplus3& obj) { out << " file id: " << obj.fileid << " name: " << obj.name @@ -417,13 +418,2450 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::entryplus3& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::dirlistplus3& obj) +std::ostream& operator<<(std::ostream& out, const dirlistplus3& obj) { out << " eof: " << obj.eof; if(obj.entries) out << *obj.entries; return out; } +bool_t +xdr_uint64 (XDR* xdrs, uint64* objp) +{ + + if (!xdr_u_longlong_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_uint32 (XDR* xdrs, uint32* objp) +{ + + if (!xdr_u_int (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_int64 (XDR* xdrs, int64* objp) +{ + + if (!xdr_longlong_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_int32 (XDR* xdrs, int32* objp) +{ + + if (!xdr_int (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_filename3 (XDR* xdrs, filename3* objp) +{ + + if (!xdr_string (xdrs, objp, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfspath3 (XDR* xdrs, nfspath3* objp) +{ + + if (!xdr_string (xdrs, objp, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fileid3 (XDR* xdrs, fileid3* objp) +{ + + if (!xdr_uint64 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_cookie3 (XDR* xdrs, cookie3* objp) +{ + + if (!xdr_uint64 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_cookieverf3 (XDR* xdrs, cookieverf3 objp) +{ + + if (!xdr_opaque (xdrs, objp, NFS3_COOKIEVERFSIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_createverf3 (XDR* xdrs, createverf3 objp) +{ + + if (!xdr_opaque (xdrs, objp, NFS3_CREATEVERFSIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_writeverf3 (XDR* xdrs, writeverf3 objp) +{ + + if (!xdr_opaque (xdrs, objp, NFS3_WRITEVERFSIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_uid3 (XDR* xdrs, uid3* objp) +{ + + if (!xdr_uint32 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_gid3 (XDR* xdrs, gid3* objp) +{ + + if (!xdr_uint32 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_size3 (XDR* xdrs, size3* objp) +{ + + if (!xdr_uint64 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_offset3 (XDR* xdrs, offset3* objp) +{ + + if (!xdr_uint64 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_mode3 (XDR* xdrs, mode3* objp) +{ + + if (!xdr_uint32 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_count3 (XDR* xdrs, count3* objp) +{ + + if (!xdr_uint32 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfsstat3 (XDR* xdrs, nfsstat3* objp) +{ + + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ftype3 (XDR* xdrs, ftype3* objp) +{ + + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_specdata3 (XDR* xdrs, specdata3* objp) +{ + + if (!xdr_uint32 (xdrs, &objp->specdata1)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->specdata2)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_fh3 (XDR* xdrs, nfs_fh3* objp) +{ + + if (!xdr_bytes (xdrs, (char**)&objp->data.data_val, (u_int*) &objp->data.data_len, NFS3_FHSIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfstime3 (XDR* xdrs, nfstime3* objp) +{ + + if (!xdr_uint32 (xdrs, &objp->seconds)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->nseconds)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr3 (XDR* xdrs, fattr3* objp) +{ + + if (!xdr_ftype3 (xdrs, &objp->type)) + { + return FALSE; + } + if (!xdr_mode3 (xdrs, &objp->mode)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->nlink)) + { + return FALSE; + } + if (!xdr_uid3 (xdrs, &objp->uid)) + { + return FALSE; + } + if (!xdr_gid3 (xdrs, &objp->gid)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->size)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->used)) + { + return FALSE; + } + if (!xdr_specdata3 (xdrs, &objp->rdev)) + { + return FALSE; + } + if (!xdr_uint64 (xdrs, &objp->fsid)) + { + return FALSE; + } + if (!xdr_fileid3 (xdrs, &objp->fileid)) + { + return FALSE; + } + if (!xdr_nfstime3 (xdrs, &objp->atime)) + { + return FALSE; + } + if (!xdr_nfstime3 (xdrs, &objp->mtime)) + { + return FALSE; + } + if (!xdr_nfstime3 (xdrs, &objp->ctime)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_post_op_attr (XDR* xdrs, post_op_attr* objp) +{ + + if (!xdr_bool (xdrs, &objp->attributes_follow)) + { + return FALSE; + } + switch (objp->attributes_follow) + { + case TRUE: + if (!xdr_fattr3 (xdrs, &objp->post_op_attr_u.attributes)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_wcc_attr (XDR* xdrs, wcc_attr* objp) +{ + + if (!xdr_size3 (xdrs, &objp->size)) + { + return FALSE; + } + if (!xdr_nfstime3 (xdrs, &objp->mtime)) + { + return FALSE; + } + if (!xdr_nfstime3 (xdrs, &objp->ctime)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_pre_op_attr (XDR* xdrs, pre_op_attr* objp) +{ + + if (!xdr_bool (xdrs, &objp->attributes_follow)) + { + return FALSE; + } + switch (objp->attributes_follow) + { + case TRUE: + if (!xdr_wcc_attr (xdrs, &objp->pre_op_attr_u.attributes)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_wcc_data (XDR* xdrs, wcc_data* objp) +{ + + if (!xdr_pre_op_attr (xdrs, &objp->before)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->after)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_post_op_fh3 (XDR* xdrs, post_op_fh3* objp) +{ + + if (!xdr_bool (xdrs, &objp->handle_follows)) + { + return FALSE; + } + switch (objp->handle_follows) + { + case TRUE: + if (!xdr_nfs_fh3 (xdrs, &objp->post_op_fh3_u.handle)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_time_how (XDR* xdrs, time_how* objp) +{ + + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_set_mode3 (XDR* xdrs, set_mode3* objp) +{ + + if (!xdr_bool (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case TRUE: + if (!xdr_mode3 (xdrs, &objp->set_mode3_u.mode)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_set_uid3 (XDR* xdrs, set_uid3* objp) +{ + + if (!xdr_bool (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case TRUE: + if (!xdr_uid3 (xdrs, &objp->set_uid3_u.uid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_set_gid3 (XDR* xdrs, set_gid3* objp) +{ + + if (!xdr_bool (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case TRUE: + if (!xdr_gid3 (xdrs, &objp->set_gid3_u.gid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_set_size3 (XDR* xdrs, set_size3* objp) +{ + + if (!xdr_bool (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case TRUE: + if (!xdr_size3 (xdrs, &objp->set_size3_u.size)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_set_atime (XDR* xdrs, set_atime* objp) +{ + + if (!xdr_time_how (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case SET_TO_CLIENT_TIME: + if (!xdr_nfstime3 (xdrs, &objp->set_atime_u.atime)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_set_mtime (XDR* xdrs, set_mtime* objp) +{ + + if (!xdr_time_how (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case SET_TO_CLIENT_TIME: + if (!xdr_nfstime3 (xdrs, &objp->set_mtime_u.mtime)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_sattr3 (XDR* xdrs, sattr3* objp) +{ + + if (!xdr_set_mode3 (xdrs, &objp->mode)) + { + return FALSE; + } + if (!xdr_set_uid3 (xdrs, &objp->uid)) + { + return FALSE; + } + if (!xdr_set_gid3 (xdrs, &objp->gid)) + { + return FALSE; + } + if (!xdr_set_size3 (xdrs, &objp->size)) + { + return FALSE; + } + if (!xdr_set_atime (xdrs, &objp->atime)) + { + return FALSE; + } + if (!xdr_set_mtime (xdrs, &objp->mtime)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_diropargs3 (XDR* xdrs, diropargs3* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->dir)) + { + return FALSE; + } + if (!xdr_filename3 (xdrs, &objp->name)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR3args (XDR* xdrs, GETATTR3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR3resok (XDR* xdrs, GETATTR3resok* objp) +{ + + if (!xdr_fattr3 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR3res (XDR* xdrs, GETATTR3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_GETATTR3resok (xdrs, &objp->GETATTR3res_u.resok)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_sattrguard3 (XDR* xdrs, sattrguard3* objp) +{ + + if (!xdr_bool (xdrs, &objp->check)) + { + return FALSE; + } + switch (objp->check) + { + case TRUE: + if (!xdr_nfstime3 (xdrs, &objp->sattrguard3_u.obj_ctime)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +// handmade for compatibility +bool_t +xdr_NULL3args (XDR*, NULL3args*) +{ + return TRUE; +} + +// handmade for compatibility +bool_t +xdr_NULL3res (XDR*, NULL3res*) +{ + return TRUE; +} + +bool_t +xdr_SETATTR3args (XDR* xdrs, SETATTR3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->object)) + { + return FALSE; + } + if (!xdr_sattr3 (xdrs, &objp->new_attributes)) + { + return FALSE; + } + if (!xdr_sattrguard3 (xdrs, &objp->guard)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETATTR3resok (XDR* xdrs, SETATTR3resok* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETATTR3resfail (XDR* xdrs, SETATTR3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETATTR3res (XDR* xdrs, SETATTR3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_SETATTR3resok (xdrs, &objp->SETATTR3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_SETATTR3resfail (xdrs, &objp->SETATTR3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_LOOKUP3args (XDR* xdrs, LOOKUP3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->what)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUP3resok (XDR* xdrs, LOOKUP3resok* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->object)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUP3resfail (XDR* xdrs, LOOKUP3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUP3res (XDR* xdrs, LOOKUP3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_LOOKUP3resok (xdrs, &objp->LOOKUP3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_LOOKUP3resfail (xdrs, &objp->LOOKUP3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_ACCESS3args (XDR* xdrs, ACCESS3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->object)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->access)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS3resok (XDR* xdrs, ACCESS3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->access)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS3resfail (XDR* xdrs, ACCESS3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS3res (XDR* xdrs, ACCESS3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_ACCESS3resok (xdrs, &objp->ACCESS3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_ACCESS3resfail (xdrs, &objp->ACCESS3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_READLINK3args (XDR* xdrs, READLINK3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->symlink)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READLINK3resok (XDR* xdrs, READLINK3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) + { + return FALSE; + } + if (!xdr_nfspath3 (xdrs, &objp->data)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READLINK3resfail (XDR* xdrs, READLINK3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READLINK3res (XDR* xdrs, READLINK3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_READLINK3resok (xdrs, &objp->READLINK3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_READLINK3resfail (xdrs, &objp->READLINK3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_READ3args (XDR* xdrs, READ3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->file)) + { + return FALSE; + } + if (!xdr_offset3 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ3resok (XDR* xdrs, READ3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->count)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ3resfail (XDR* xdrs, READ3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ3res (XDR* xdrs, READ3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_READ3resok (xdrs, &objp->READ3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_READ3resfail (xdrs, &objp->READ3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_stable_how (XDR* xdrs, stable_how* objp) +{ + + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE3args (XDR* xdrs, WRITE3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->file)) + { + return FALSE; + } + if (!xdr_offset3 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->count)) + { + return FALSE; + } + if (!xdr_stable_how (xdrs, &objp->stable)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE3resok (XDR* xdrs, WRITE3resok* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->file_wcc)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->count)) + { + return FALSE; + } + if (!xdr_stable_how (xdrs, &objp->committed)) + { + return FALSE; + } + if (!xdr_writeverf3 (xdrs, objp->verf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE3resfail (XDR* xdrs, WRITE3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->file_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE3res (XDR* xdrs, WRITE3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_WRITE3resok (xdrs, &objp->WRITE3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_WRITE3resfail (xdrs, &objp->WRITE3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_createmode3 (XDR* xdrs, createmode3* objp) +{ + + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_createhow3 (XDR* xdrs, createhow3* objp) +{ + + if (!xdr_createmode3 (xdrs, &objp->mode)) + { + return FALSE; + } + switch (objp->mode) + { + case UNCHECKED: + case GUARDED: + if (!xdr_sattr3 (xdrs, &objp->createhow3_u.obj_attributes)) + { + return FALSE; + } + break; + case EXCLUSIVE: + if (!xdr_createverf3 (xdrs, objp->createhow3_u.verf)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE3args (XDR* xdrs, CREATE3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->where)) + { + return FALSE; + } + if (!xdr_createhow3 (xdrs, &objp->how)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE3resok (XDR* xdrs, CREATE3resok* objp) +{ + + if (!xdr_post_op_fh3 (xdrs, &objp->obj)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE3resfail (XDR* xdrs, CREATE3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE3res (XDR* xdrs, CREATE3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_CREATE3resok (xdrs, &objp->CREATE3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_CREATE3resfail (xdrs, &objp->CREATE3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_MKDIR3args (XDR* xdrs, MKDIR3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->where)) + { + return FALSE; + } + if (!xdr_sattr3 (xdrs, &objp->attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_MKDIR3resok (XDR* xdrs, MKDIR3resok* objp) +{ + + if (!xdr_post_op_fh3 (xdrs, &objp->obj)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_MKDIR3resfail (XDR* xdrs, MKDIR3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_MKDIR3res (XDR* xdrs, MKDIR3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_MKDIR3resok (xdrs, &objp->MKDIR3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_MKDIR3resfail (xdrs, &objp->MKDIR3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_symlinkdata3 (XDR* xdrs, symlinkdata3* objp) +{ + + if (!xdr_sattr3 (xdrs, &objp->symlink_attributes)) + { + return FALSE; + } + if (!xdr_nfspath3 (xdrs, &objp->symlink_data)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SYMLINK3args (XDR* xdrs, SYMLINK3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->where)) + { + return FALSE; + } + if (!xdr_symlinkdata3 (xdrs, &objp->symlink)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SYMLINK3resok (XDR* xdrs, SYMLINK3resok* objp) +{ + + if (!xdr_post_op_fh3 (xdrs, &objp->obj)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SYMLINK3resfail (XDR* xdrs, SYMLINK3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SYMLINK3res (XDR* xdrs, SYMLINK3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_SYMLINK3resok (xdrs, &objp->SYMLINK3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_SYMLINK3resfail (xdrs, &objp->SYMLINK3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_devicedata3 (XDR* xdrs, devicedata3* objp) +{ + + if (!xdr_sattr3 (xdrs, &objp->dev_attributes)) + { + return FALSE; + } + if (!xdr_specdata3 (xdrs, &objp->spec)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_mknoddata3 (XDR* xdrs, mknoddata3* objp) +{ + + if (!xdr_ftype3 (xdrs, &objp->type)) + { + return FALSE; + } + switch (objp->type) + { + case NF3CHR: + case NF3BLK: + if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.device)) + { + return FALSE; + } + break; + case NF3SOCK: + case NF3FIFO: + if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.pipe_attributes)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_MKNOD3args (XDR* xdrs, MKNOD3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->where)) + { + return FALSE; + } + if (!xdr_mknoddata3 (xdrs, &objp->what)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_MKNOD3resok (XDR* xdrs, MKNOD3resok* objp) +{ + + if (!xdr_post_op_fh3 (xdrs, &objp->obj)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_MKNOD3resfail (XDR* xdrs, MKNOD3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_MKNOD3res (XDR* xdrs, MKNOD3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_MKNOD3resok (xdrs, &objp->MKNOD3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_MKNOD3resfail (xdrs, &objp->MKNOD3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_REMOVE3args (XDR* xdrs, REMOVE3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE3resok (XDR* xdrs, REMOVE3resok* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE3resfail (XDR* xdrs, REMOVE3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE3res (XDR* xdrs, REMOVE3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_REMOVE3resok (xdrs, &objp->REMOVE3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_REMOVE3resfail (xdrs, &objp->REMOVE3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_RMDIR3args (XDR* xdrs, RMDIR3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RMDIR3resok (XDR* xdrs, RMDIR3resok* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RMDIR3resfail (XDR* xdrs, RMDIR3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RMDIR3res (XDR* xdrs, RMDIR3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_RMDIR3resok (xdrs, &objp->RMDIR3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_RMDIR3resfail (xdrs, &objp->RMDIR3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_RENAME3args (XDR* xdrs, RENAME3args* objp) +{ + + if (!xdr_diropargs3 (xdrs, &objp->from)) + { + return FALSE; + } + if (!xdr_diropargs3 (xdrs, &objp->to)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME3resok (XDR* xdrs, RENAME3resok* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME3resfail (XDR* xdrs, RENAME3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME3res (XDR* xdrs, RENAME3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_RENAME3resok (xdrs, &objp->RENAME3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_RENAME3resfail (xdrs, &objp->RENAME3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_LINK3args (XDR* xdrs, LINK3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->file)) + { + return FALSE; + } + if (!xdr_diropargs3 (xdrs, &objp->link)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK3resok (XDR* xdrs, LINK3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK3resfail (XDR* xdrs, LINK3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) + { + return FALSE; + } + if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK3res (XDR* xdrs, LINK3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_LINK3resok (xdrs, &objp->LINK3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_LINK3resfail (xdrs, &objp->LINK3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_READDIR3args (XDR* xdrs, READDIR3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->dir)) + { + return FALSE; + } + if (!xdr_cookie3 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_entry3 (XDR* xdrs, entry3* objp) +{ + + if (!xdr_fileid3 (xdrs, &objp->fileid)) + { + return FALSE; + } + if (!xdr_filename3 (xdrs, &objp->name)) + { + return FALSE; + } + if (!xdr_cookie3 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_pointer (xdrs, (char**)&objp->nextentry, sizeof (entry3), (xdrproc_t) xdr_entry3)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_dirlist3 (XDR* xdrs, dirlist3* objp) +{ + + if (!xdr_pointer (xdrs, (char**)&objp->entries, sizeof (entry3), (xdrproc_t) xdr_entry3)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR3resok (XDR* xdrs, READDIR3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) + { + return FALSE; + } + if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_dirlist3 (xdrs, &objp->reply)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR3resfail (XDR* xdrs, READDIR3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR3res (XDR* xdrs, READDIR3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_READDIR3resok (xdrs, &objp->READDIR3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_READDIR3resfail (xdrs, &objp->READDIR3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_READDIRPLUS3args (XDR* xdrs, READDIRPLUS3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->dir)) + { + return FALSE; + } + if (!xdr_cookie3 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->dircount)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->maxcount)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_entryplus3 (XDR* xdrs, entryplus3* objp) +{ + + if (!xdr_fileid3 (xdrs, &objp->fileid)) + { + return FALSE; + } + if (!xdr_filename3 (xdrs, &objp->name)) + { + return FALSE; + } + if (!xdr_cookie3 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_post_op_attr (xdrs, &objp->name_attributes)) + { + return FALSE; + } + if (!xdr_post_op_fh3 (xdrs, &objp->name_handle)) + { + return FALSE; + } + if (!xdr_pointer (xdrs, (char**)&objp->nextentry, sizeof (entryplus3), (xdrproc_t) xdr_entryplus3)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_dirlistplus3 (XDR* xdrs, dirlistplus3* objp) +{ + + if (!xdr_pointer (xdrs, (char**)&objp->entries, sizeof (entryplus3), (xdrproc_t) xdr_entryplus3)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIRPLUS3resok (XDR* xdrs, READDIRPLUS3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) + { + return FALSE; + } + if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_dirlistplus3 (xdrs, &objp->reply)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIRPLUS3resfail (XDR* xdrs, READDIRPLUS3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIRPLUS3res (XDR* xdrs, READDIRPLUS3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_READDIRPLUS3resok (xdrs, &objp->READDIRPLUS3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_READDIRPLUS3resfail (xdrs, &objp->READDIRPLUS3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_FSSTAT3args (XDR* xdrs, FSSTAT3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FSSTAT3resok (XDR* xdrs, FSSTAT3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->tbytes)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->fbytes)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->abytes)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->tfiles)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->ffiles)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->afiles)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->invarsec)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FSSTAT3resfail (XDR* xdrs, FSSTAT3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FSSTAT3res (XDR* xdrs, FSSTAT3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_FSSTAT3resok (xdrs, &objp->FSSTAT3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_FSSTAT3resfail (xdrs, &objp->FSSTAT3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_FSINFO3args (XDR* xdrs, FSINFO3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FSINFO3resok (XDR* xdrs, FSINFO3resok* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->rtmax)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->rtpref)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->rtmult)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->wtmax)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->wtpref)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->wtmult)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->dtpref)) + { + return FALSE; + } + if (!xdr_size3 (xdrs, &objp->maxfilesize)) + { + return FALSE; + } + if (!xdr_nfstime3 (xdrs, &objp->time_delta)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->properties)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FSINFO3resfail (XDR* xdrs, FSINFO3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FSINFO3res (XDR* xdrs, FSINFO3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_FSINFO3resok (xdrs, &objp->FSINFO3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_FSINFO3resfail (xdrs, &objp->FSINFO3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_PATHCONF3args (XDR* xdrs, PATHCONF3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PATHCONF3resok (XDR* xdrs, PATHCONF3resok* objp) +{ + int32_t* buf; + + if (xdrs->x_op == XDR_ENCODE) + { + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->linkmax)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->name_max)) + { + return FALSE; + } + buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); + if (buf == NULL) + { + if (!xdr_bool (xdrs, &objp->no_trunc)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->chown_restricted)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->case_insensitive)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->case_preserving)) + { + return FALSE; + } + } + else + { + IXDR_PUT_BOOL(buf, objp->no_trunc); + IXDR_PUT_BOOL(buf, objp->chown_restricted); + IXDR_PUT_BOOL(buf, objp->case_insensitive); + IXDR_PUT_BOOL(buf, objp->case_preserving); + } + return TRUE; + } + else if (xdrs->x_op == XDR_DECODE) + { + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->linkmax)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->name_max)) + { + return FALSE; + } + buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); + if (buf == NULL) + { + if (!xdr_bool (xdrs, &objp->no_trunc)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->chown_restricted)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->case_insensitive)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->case_preserving)) + { + return FALSE; + } + } + else + { + objp->no_trunc = IXDR_GET_BOOL(buf); + objp->chown_restricted = IXDR_GET_BOOL(buf); + objp->case_insensitive = IXDR_GET_BOOL(buf); + objp->case_preserving = IXDR_GET_BOOL(buf); + } + return TRUE; + } + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->linkmax)) + { + return FALSE; + } + if (!xdr_uint32 (xdrs, &objp->name_max)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->no_trunc)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->chown_restricted)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->case_insensitive)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->case_preserving)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PATHCONF3resfail (XDR* xdrs, PATHCONF3resfail* objp) +{ + + if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PATHCONF3res (XDR* xdrs, PATHCONF3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_PATHCONF3resok (xdrs, &objp->PATHCONF3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_PATHCONF3resfail (xdrs, &objp->PATHCONF3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + +bool_t +xdr_COMMIT3args (XDR* xdrs, COMMIT3args* objp) +{ + + if (!xdr_nfs_fh3 (xdrs, &objp->file)) + { + return FALSE; + } + if (!xdr_offset3 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count3 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT3resok (XDR* xdrs, COMMIT3resok* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->file_wcc)) + { + return FALSE; + } + if (!xdr_writeverf3 (xdrs, objp->verf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT3resfail (XDR* xdrs, COMMIT3resfail* objp) +{ + + if (!xdr_wcc_data (xdrs, &objp->file_wcc)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT3res (XDR* xdrs, COMMIT3res* objp) +{ + + if (!xdr_nfsstat3 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS3_OK: + if (!xdr_COMMIT3resok (xdrs, &objp->COMMIT3res_u.resok)) + { + return FALSE; + } + break; + default: + if (!xdr_COMMIT3resfail (xdrs, &objp->COMMIT3res_u.resfail)) + { + return FALSE; + } + break; + } + return TRUE; +} + } // namespace NFS3 } // namespace protocols } // namespace NST diff --git a/src/protocols/nfs3/nfs3_utils.h b/src/protocols/nfs3/nfs3_utils.h index 5010d1f..8b16806 100644 --- a/src/protocols/nfs3/nfs3_utils.h +++ b/src/protocols/nfs3/nfs3_utils.h @@ -19,7 +19,6 @@ along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. */ //------------------------------------------------------------------------------ -#define NST_PUBLIC __attribute__ ((visibility("default"))) #ifndef NFS3_UTILS_H #define NFS3_UTILS_H //------------------------------------------------------------------------------ @@ -32,8 +31,7 @@ #include "protocols/xdr/xdr_decoder.h" #include "protocols/rpc/rpc_header.h" //------------------------------------------------------------------------------ -using namespace NST::API; -using namespace NST::protocols::xdr; +#define NST_PUBLIC __attribute__ ((visibility("default"))) //------------------------------------------------------------------------------ namespace NST { @@ -42,6 +40,10 @@ namespace protocols namespace NFS3 { +namespace NFS3 = NST::API::NFS3; + +using ProcEnumNFS3 = API::ProcEnumNFS3; + using Validator = rpc::RPCProgramValidator < 100003, // SunRPC/NFS program @@ -50,246 +52,380 @@ using Validator = rpc::RPCProgramValidator ProcEnumNFS3::COMMIT // NFSPROC3_COMMIT >; +bool_t xdr_uint64 (XDR *, NFS3::uint64*); +bool_t xdr_uint32 (XDR *, NFS3::uint32*); +bool_t xdr_int64 (XDR *, NFS3::int64*); +bool_t xdr_int32 (XDR *, NFS3::int32*); +bool_t xdr_filename3 (XDR *, NFS3::filename3*); +bool_t xdr_nfspath3 (XDR *, NFS3::nfspath3*); +bool_t xdr_fileid3 (XDR *, NFS3::fileid3*); +bool_t xdr_cookie3 (XDR *, NFS3::cookie3*); +bool_t xdr_cookieverf3 (XDR *, NFS3::cookieverf3); +bool_t xdr_createverf3 (XDR *, NFS3::createverf3); +bool_t xdr_writeverf3 (XDR *, NFS3::writeverf3); +bool_t xdr_uid3 (XDR *, NFS3::uid3*); +bool_t xdr_gid3 (XDR *, NFS3::gid3*); +bool_t xdr_size3 (XDR *, NFS3::size3*); +bool_t xdr_offset3 (XDR *, NFS3::offset3*); +bool_t xdr_mode3 (XDR *, NFS3::mode3*); +bool_t xdr_count3 (XDR *, NFS3::count3*); +bool_t xdr_nfsstat3 (XDR *, NFS3::nfsstat3*); +bool_t xdr_ftype3 (XDR *, NFS3::ftype3*); +bool_t xdr_specdata3 (XDR *, NFS3::specdata3*); +bool_t xdr_nfs_fh3 (XDR *, NFS3::nfs_fh3*); +bool_t xdr_nfstime3 (XDR *, NFS3::nfstime3*); +bool_t xdr_fattr3 (XDR *, NFS3::fattr3*); +bool_t xdr_post_op_attr (XDR *, NFS3::post_op_attr*); +bool_t xdr_wcc_attr (XDR *, NFS3::wcc_attr*); +bool_t xdr_pre_op_attr (XDR *, NFS3::pre_op_attr*); +bool_t xdr_wcc_data (XDR *, NFS3::wcc_data*); +bool_t xdr_post_op_fh3 (XDR *, NFS3::post_op_fh3*); +bool_t xdr_time_how (XDR *, NFS3::time_how*); +bool_t xdr_set_mode3 (XDR *, NFS3::set_mode3*); +bool_t xdr_set_uid3 (XDR *, NFS3::set_uid3*); +bool_t xdr_set_gid3 (XDR *, NFS3::set_gid3*); +bool_t xdr_set_size3 (XDR *, NFS3::set_size3*); +bool_t xdr_set_atime (XDR *, NFS3::set_atime*); +bool_t xdr_set_mtime (XDR *, NFS3::set_mtime*); +bool_t xdr_sattr3 (XDR *, NFS3::sattr3*); +bool_t xdr_diropargs3 (XDR *, NFS3::diropargs3*); +bool_t xdr_NULL3args (XDR *, NFS3::NULL3args*); // for compatibility +bool_t xdr_NULL3res (XDR *, NFS3::NULL3res*); // for compatibility +bool_t xdr_GETATTR3args (XDR *, NFS3::GETATTR3args*); +bool_t xdr_GETATTR3resok (XDR *, NFS3::GETATTR3resok*); +bool_t xdr_GETATTR3res (XDR *, NFS3::GETATTR3res*); +bool_t xdr_sattrguard3 (XDR *, NFS3::sattrguard3*); +bool_t xdr_SETATTR3args (XDR *, NFS3::SETATTR3args*); +bool_t xdr_SETATTR3resok (XDR *, NFS3::SETATTR3resok*); +bool_t xdr_SETATTR3resfail (XDR *, NFS3::SETATTR3resfail*); +bool_t xdr_SETATTR3res (XDR *, NFS3::SETATTR3res*); +bool_t xdr_LOOKUP3args (XDR *, NFS3::LOOKUP3args*); +bool_t xdr_LOOKUP3resok (XDR *, NFS3::LOOKUP3resok*); +bool_t xdr_LOOKUP3resfail (XDR *, NFS3::LOOKUP3resfail*); +bool_t xdr_LOOKUP3res (XDR *, NFS3::LOOKUP3res*); +bool_t xdr_ACCESS3args (XDR *, NFS3::ACCESS3args*); +bool_t xdr_ACCESS3resok (XDR *, NFS3::ACCESS3resok*); +bool_t xdr_ACCESS3resfail (XDR *, NFS3::ACCESS3resfail*); +bool_t xdr_ACCESS3res (XDR *, NFS3::ACCESS3res*); +bool_t xdr_READLINK3args (XDR *, NFS3::READLINK3args*); +bool_t xdr_READLINK3resok (XDR *, NFS3::READLINK3resok*); +bool_t xdr_READLINK3resfail (XDR *, NFS3::READLINK3resfail*); +bool_t xdr_READLINK3res (XDR *, NFS3::READLINK3res*); +bool_t xdr_READ3args (XDR *, NFS3::READ3args*); +bool_t xdr_READ3resok (XDR *, NFS3::READ3resok*); +bool_t xdr_READ3resfail (XDR *, NFS3::READ3resfail*); +bool_t xdr_READ3res (XDR *, NFS3::READ3res*); +bool_t xdr_stable_how (XDR *, NFS3::stable_how*); +bool_t xdr_WRITE3args (XDR *, NFS3::WRITE3args*); +bool_t xdr_WRITE3resok (XDR *, NFS3::WRITE3resok*); +bool_t xdr_WRITE3resfail (XDR *, NFS3::WRITE3resfail*); +bool_t xdr_WRITE3res (XDR *, NFS3::WRITE3res*); +bool_t xdr_createmode3 (XDR *, NFS3::createmode3*); +bool_t xdr_createhow3 (XDR *, NFS3::createhow3*); +bool_t xdr_CREATE3args (XDR *, NFS3::CREATE3args*); +bool_t xdr_CREATE3resok (XDR *, NFS3::CREATE3resok*); +bool_t xdr_CREATE3resfail (XDR *, NFS3::CREATE3resfail*); +bool_t xdr_CREATE3res (XDR *, NFS3::CREATE3res*); +bool_t xdr_MKDIR3args (XDR *, NFS3::MKDIR3args*); +bool_t xdr_MKDIR3resok (XDR *, NFS3::MKDIR3resok*); +bool_t xdr_MKDIR3resfail (XDR *, NFS3::MKDIR3resfail*); +bool_t xdr_MKDIR3res (XDR *, NFS3::MKDIR3res*); +bool_t xdr_symlinkdata3 (XDR *, NFS3::symlinkdata3*); +bool_t xdr_SYMLINK3args (XDR *, NFS3::SYMLINK3args*); +bool_t xdr_SYMLINK3resok (XDR *, NFS3::SYMLINK3resok*); +bool_t xdr_SYMLINK3resfail (XDR *, NFS3::SYMLINK3resfail*); +bool_t xdr_SYMLINK3res (XDR *, NFS3::SYMLINK3res*); +bool_t xdr_devicedata3 (XDR *, NFS3::devicedata3*); +bool_t xdr_mknoddata3 (XDR *, NFS3::mknoddata3*); +bool_t xdr_MKNOD3args (XDR *, NFS3::MKNOD3args*); +bool_t xdr_MKNOD3resok (XDR *, NFS3::MKNOD3resok*); +bool_t xdr_MKNOD3resfail (XDR *, NFS3::MKNOD3resfail*); +bool_t xdr_MKNOD3res (XDR *, NFS3::MKNOD3res*); +bool_t xdr_REMOVE3args (XDR *, NFS3::REMOVE3args*); +bool_t xdr_REMOVE3resok (XDR *, NFS3::REMOVE3resok*); +bool_t xdr_REMOVE3resfail (XDR *, NFS3::REMOVE3resfail*); +bool_t xdr_REMOVE3res (XDR *, NFS3::REMOVE3res*); +bool_t xdr_RMDIR3args (XDR *, NFS3::RMDIR3args*); +bool_t xdr_RMDIR3resok (XDR *, NFS3::RMDIR3resok*); +bool_t xdr_RMDIR3resfail (XDR *, NFS3::RMDIR3resfail*); +bool_t xdr_RMDIR3res (XDR *, NFS3::RMDIR3res*); +bool_t xdr_RENAME3args (XDR *, NFS3::RENAME3args*); +bool_t xdr_RENAME3resok (XDR *, NFS3::RENAME3resok*); +bool_t xdr_RENAME3resfail (XDR *, NFS3::RENAME3resfail*); +bool_t xdr_RENAME3res (XDR *, NFS3::RENAME3res*); +bool_t xdr_LINK3args (XDR *, NFS3::LINK3args*); +bool_t xdr_LINK3resok (XDR *, NFS3::LINK3resok*); +bool_t xdr_LINK3resfail (XDR *, NFS3::LINK3resfail*); +bool_t xdr_LINK3res (XDR *, NFS3::LINK3res*); +bool_t xdr_READDIR3args (XDR *, NFS3::READDIR3args*); +bool_t xdr_entry3 (XDR *, NFS3::entry3*); +bool_t xdr_dirlist3 (XDR *, NFS3::dirlist3*); +bool_t xdr_READDIR3resok (XDR *, NFS3::READDIR3resok*); +bool_t xdr_READDIR3resfail (XDR *, NFS3::READDIR3resfail*); +bool_t xdr_READDIR3res (XDR *, NFS3::READDIR3res*); +bool_t xdr_READDIRPLUS3args (XDR *, NFS3::READDIRPLUS3args*); +bool_t xdr_entryplus3 (XDR *, NFS3::entryplus3*); +bool_t xdr_dirlistplus3 (XDR *, NFS3::dirlistplus3*); +bool_t xdr_READDIRPLUS3resok (XDR *, NFS3::READDIRPLUS3resok*); +bool_t xdr_READDIRPLUS3resfail (XDR *, NFS3::READDIRPLUS3resfail*); +bool_t xdr_READDIRPLUS3res (XDR *, NFS3::READDIRPLUS3res*); +bool_t xdr_FSSTAT3args (XDR *, NFS3::FSSTAT3args*); +bool_t xdr_FSSTAT3resok (XDR *, NFS3::FSSTAT3resok*); +bool_t xdr_FSSTAT3resfail (XDR *, NFS3::FSSTAT3resfail*); +bool_t xdr_FSSTAT3res (XDR *, NFS3::FSSTAT3res*); +bool_t xdr_FSINFO3args (XDR *, NFS3::FSINFO3args*); +bool_t xdr_FSINFO3resok (XDR *, NFS3::FSINFO3resok*); +bool_t xdr_FSINFO3resfail (XDR *, NFS3::FSINFO3resfail*); +bool_t xdr_FSINFO3res (XDR *, NFS3::FSINFO3res*); +bool_t xdr_PATHCONF3args (XDR *, NFS3::PATHCONF3args*); +bool_t xdr_PATHCONF3resok (XDR *, NFS3::PATHCONF3resok*); +bool_t xdr_PATHCONF3resfail (XDR *, NFS3::PATHCONF3resfail*); +bool_t xdr_PATHCONF3res (XDR *, NFS3::PATHCONF3res*); +bool_t xdr_COMMIT3args (XDR *, NFS3::COMMIT3args*); +bool_t xdr_COMMIT3resok (XDR *, NFS3::COMMIT3resok*); +bool_t xdr_COMMIT3resfail (XDR *, NFS3::COMMIT3resfail*); +bool_t xdr_COMMIT3res (XDR *, NFS3::COMMIT3res*); + // Procedure 0: NULL - Do nothing -inline auto proc_t_of(rpcgen::NULL3args&)->decltype(&rpcgen::xdr_NULL3args) +inline auto proc_t_of(NFS3::NULL3args&)->decltype(&xdr_NULL3args) { - return &rpcgen::xdr_NULL3args; + return &xdr_NULL3args; } -inline auto proc_t_of(rpcgen::NULL3res&)->decltype(&rpcgen::xdr_NULL3res) +inline auto proc_t_of(NFS3::NULL3res&)->decltype(&xdr_NULL3res) { - return &rpcgen::xdr_NULL3res; + return &xdr_NULL3res; } // Procedure 1: GETATTR - Get file attributes -inline auto proc_t_of(rpcgen::GETATTR3args&)->decltype(&rpcgen::xdr_GETATTR3args) +inline auto proc_t_of(NFS3::GETATTR3args&)->decltype(&xdr_GETATTR3args) { - return &rpcgen::xdr_GETATTR3args; + return &xdr_GETATTR3args; } -inline auto proc_t_of(rpcgen::GETATTR3res&)->decltype(&rpcgen::xdr_GETATTR3res) +inline auto proc_t_of(NFS3::GETATTR3res&)->decltype(&xdr_GETATTR3res) { - return &rpcgen::xdr_GETATTR3res; + return &xdr_GETATTR3res; } // Procedure 2: SETATTR - Set file attributes -inline auto proc_t_of(rpcgen::SETATTR3args&)->decltype(&rpcgen::xdr_SETATTR3args) +inline auto proc_t_of(NFS3::SETATTR3args&)->decltype(&xdr_SETATTR3args) { - return &rpcgen::xdr_SETATTR3args; + return &xdr_SETATTR3args; } -inline auto proc_t_of(rpcgen::SETATTR3res&)->decltype(&rpcgen::xdr_SETATTR3res) +inline auto proc_t_of(NFS3::SETATTR3res&)->decltype(&xdr_SETATTR3res) { - return &rpcgen::xdr_SETATTR3res; + return &xdr_SETATTR3res; } // Procedure 3: LOOKUP - Lookup filename -inline auto proc_t_of(rpcgen::LOOKUP3args&)->decltype(&rpcgen::xdr_LOOKUP3args) +inline auto proc_t_of(NFS3::LOOKUP3args&)->decltype(&xdr_LOOKUP3args) { - return &rpcgen::xdr_LOOKUP3args; + return &xdr_LOOKUP3args; } -inline auto proc_t_of(rpcgen::LOOKUP3res&)->decltype(&rpcgen::xdr_LOOKUP3res) +inline auto proc_t_of(NFS3::LOOKUP3res&)->decltype(&xdr_LOOKUP3res) { - return &rpcgen::xdr_LOOKUP3res; + return &xdr_LOOKUP3res; } // Procedure 4: ACCESS - Check Access Permission -inline auto proc_t_of(rpcgen::ACCESS3args&)->decltype(&rpcgen::xdr_ACCESS3args) +inline auto proc_t_of(NFS3::ACCESS3args&)->decltype(&xdr_ACCESS3args) { - return &rpcgen::xdr_ACCESS3args; + return &xdr_ACCESS3args; } -inline auto proc_t_of(rpcgen::ACCESS3res&)->decltype(&rpcgen::xdr_ACCESS3res) +inline auto proc_t_of(NFS3::ACCESS3res&)->decltype(&xdr_ACCESS3res) { - return &rpcgen::xdr_ACCESS3res; + return &xdr_ACCESS3res; } // Procedure 5: READLINK - Read from symbolic link -inline auto proc_t_of(rpcgen::READLINK3args&)->decltype(&rpcgen::xdr_READLINK3args) +inline auto proc_t_of(NFS3::READLINK3args&)->decltype(&xdr_READLINK3args) { - return &rpcgen::xdr_READLINK3args; + return &xdr_READLINK3args; } -inline auto proc_t_of(rpcgen::READLINK3res&)->decltype(&rpcgen::xdr_READLINK3res) +inline auto proc_t_of(NFS3::READLINK3res&)->decltype(&xdr_READLINK3res) { - return &rpcgen::xdr_READLINK3res; + return &xdr_READLINK3res; } // Procedure 6: READ - Read From file -inline auto proc_t_of(rpcgen::READ3args&)->decltype(&rpcgen::xdr_READ3args) +inline auto proc_t_of(NFS3::READ3args&)->decltype(&xdr_READ3args) { - return &rpcgen::xdr_READ3args; + return &xdr_READ3args; } -inline auto proc_t_of(rpcgen::READ3res&)->decltype(&rpcgen::xdr_READ3res) +inline auto proc_t_of(NFS3::READ3res&)->decltype(&xdr_READ3res) { - return &rpcgen::xdr_READ3res; + return &xdr_READ3res; } // Procedure 7: WRITE - Write to file -inline auto proc_t_of(rpcgen::WRITE3args&)->decltype(&rpcgen::xdr_WRITE3args) +inline auto proc_t_of(NFS3::WRITE3args&)->decltype(&xdr_WRITE3args) { - return &rpcgen::xdr_WRITE3args; + return &xdr_WRITE3args; } -inline auto proc_t_of(rpcgen::WRITE3res&)->decltype(&rpcgen::xdr_WRITE3res) +inline auto proc_t_of(NFS3::WRITE3res&)->decltype(&xdr_WRITE3res) { - return &rpcgen::xdr_WRITE3res; + return &xdr_WRITE3res; } // Procedure 8: CREATE - Create a file -inline auto proc_t_of(rpcgen::CREATE3args&)->decltype(&rpcgen::xdr_CREATE3args) +inline auto proc_t_of(NFS3::CREATE3args&)->decltype(&xdr_CREATE3args) { - return &rpcgen::xdr_CREATE3args; + return &xdr_CREATE3args; } -inline auto proc_t_of(rpcgen::CREATE3res&)->decltype(&rpcgen::xdr_CREATE3res) +inline auto proc_t_of(NFS3::CREATE3res&)->decltype(&xdr_CREATE3res) { - return &rpcgen::xdr_CREATE3res; + return &xdr_CREATE3res; } // Procedure 9: MKDIR - Create a directory -inline auto proc_t_of(rpcgen::MKDIR3args&)->decltype(&rpcgen::xdr_MKDIR3args) +inline auto proc_t_of(NFS3::MKDIR3args&)->decltype(&xdr_MKDIR3args) { - return &rpcgen::xdr_MKDIR3args; + return &xdr_MKDIR3args; } -inline auto proc_t_of(rpcgen::MKDIR3res&)->decltype(&rpcgen::xdr_MKDIR3res) +inline auto proc_t_of(NFS3::MKDIR3res&)->decltype(&xdr_MKDIR3res) { - return &rpcgen::xdr_MKDIR3res; + return &xdr_MKDIR3res; } // Procedure 10: SYMLINK - Create a symbolic link -inline auto proc_t_of(rpcgen::SYMLINK3args&)->decltype(&rpcgen::xdr_SYMLINK3args) +inline auto proc_t_of(NFS3::SYMLINK3args&)->decltype(&xdr_SYMLINK3args) { - return &rpcgen::xdr_SYMLINK3args; + return &xdr_SYMLINK3args; } -inline auto proc_t_of(rpcgen::SYMLINK3res&)->decltype(&rpcgen::xdr_SYMLINK3res) +inline auto proc_t_of(NFS3::SYMLINK3res&)->decltype(&xdr_SYMLINK3res) { - return &rpcgen::xdr_SYMLINK3res; + return &xdr_SYMLINK3res; } // Procedure 11: MKNOD - Create a special device -inline auto proc_t_of(rpcgen::MKNOD3args&)->decltype(&rpcgen::xdr_MKNOD3args) +inline auto proc_t_of(NFS3::MKNOD3args&)->decltype(&xdr_MKNOD3args) { - return &rpcgen::xdr_MKNOD3args; + return &xdr_MKNOD3args; } -inline auto proc_t_of(rpcgen::MKNOD3res&)->decltype(&rpcgen::xdr_MKNOD3res) +inline auto proc_t_of(NFS3::MKNOD3res&)->decltype(&xdr_MKNOD3res) { - return &rpcgen::xdr_MKNOD3res; + return &xdr_MKNOD3res; } // Procedure 12: REMOVE - Remove a File -inline auto proc_t_of(rpcgen::REMOVE3args&)->decltype(&rpcgen::xdr_REMOVE3args) +inline auto proc_t_of(NFS3::REMOVE3args&)->decltype(&xdr_REMOVE3args) { - return &rpcgen::xdr_REMOVE3args; + return &xdr_REMOVE3args; } -inline auto proc_t_of(rpcgen::REMOVE3res&)->decltype(&rpcgen::xdr_REMOVE3res) +inline auto proc_t_of(NFS3::REMOVE3res&)->decltype(&xdr_REMOVE3res) { - return &rpcgen::xdr_REMOVE3res; + return &xdr_REMOVE3res; } // Procedure 13: RMDIR - Remove a Directory -inline auto proc_t_of(rpcgen::RMDIR3args&)->decltype(&rpcgen::xdr_RMDIR3args) +inline auto proc_t_of(NFS3::RMDIR3args&)->decltype(&xdr_RMDIR3args) { - return &rpcgen::xdr_RMDIR3args; + return &xdr_RMDIR3args; } -inline auto proc_t_of(rpcgen::RMDIR3res&)->decltype(&rpcgen::xdr_RMDIR3res) +inline auto proc_t_of(NFS3::RMDIR3res&)->decltype(&xdr_RMDIR3res) { - return &rpcgen::xdr_RMDIR3res; + return &xdr_RMDIR3res; } // Procedure 14: RENAME - Rename a File or Directory -inline auto proc_t_of(rpcgen::RENAME3args&)->decltype(&rpcgen::xdr_RENAME3args) +inline auto proc_t_of(NFS3::RENAME3args&)->decltype(&xdr_RENAME3args) { - return &rpcgen::xdr_RENAME3args; + return &xdr_RENAME3args; } -inline auto proc_t_of(rpcgen::RENAME3res&)->decltype(&rpcgen::xdr_RENAME3res) +inline auto proc_t_of(NFS3::RENAME3res&)->decltype(&xdr_RENAME3res) { - return &rpcgen::xdr_RENAME3res; + return &xdr_RENAME3res; } // Procedure 15: LINK - Create Link to an object -inline auto proc_t_of(rpcgen::LINK3args&)->decltype(&rpcgen::xdr_LINK3args) +inline auto proc_t_of(NFS3::LINK3args&)->decltype(&xdr_LINK3args) { - return &rpcgen::xdr_LINK3args; + return &xdr_LINK3args; } -inline auto proc_t_of(rpcgen::LINK3res&)->decltype(&rpcgen::xdr_LINK3res) +inline auto proc_t_of(NFS3::LINK3res&)->decltype(&xdr_LINK3res) { - return &rpcgen::xdr_LINK3res; + return &xdr_LINK3res; } // Procedure 16: READDIR - Read From Directory -inline auto proc_t_of(rpcgen::READDIR3args&)->decltype(&rpcgen::xdr_READDIR3args) +inline auto proc_t_of(NFS3::READDIR3args&)->decltype(&xdr_READDIR3args) { - return &rpcgen::xdr_READDIR3args; + return &xdr_READDIR3args; } -inline auto proc_t_of(rpcgen::READDIR3res&)->decltype(&rpcgen::xdr_READDIR3res) +inline auto proc_t_of(NFS3::READDIR3res&)->decltype(&xdr_READDIR3res) { - return &rpcgen::xdr_READDIR3res; + return &xdr_READDIR3res; } // Procedure 17: READDIRPLUS - Extended read from directory -inline auto proc_t_of(rpcgen::READDIRPLUS3args&)->decltype(&rpcgen::xdr_READDIRPLUS3args) +inline auto proc_t_of(NFS3::READDIRPLUS3args&)->decltype(&xdr_READDIRPLUS3args) { - return &rpcgen::xdr_READDIRPLUS3args; + return &xdr_READDIRPLUS3args; } -inline auto proc_t_of(rpcgen::READDIRPLUS3res&)->decltype(&rpcgen::xdr_READDIRPLUS3res) +inline auto proc_t_of(NFS3::READDIRPLUS3res&)->decltype(&xdr_READDIRPLUS3res) { - return &rpcgen::xdr_READDIRPLUS3res; + return &xdr_READDIRPLUS3res; } // Procedure 18: FSSTAT - Get dynamic file system information -inline auto proc_t_of(rpcgen::FSSTAT3args&)->decltype(&rpcgen::xdr_FSSTAT3args) +inline auto proc_t_of(NFS3::FSSTAT3args&)->decltype(&xdr_FSSTAT3args) { - return &rpcgen::xdr_FSSTAT3args; + return &xdr_FSSTAT3args; } -inline auto proc_t_of(rpcgen::FSSTAT3res&)->decltype(&rpcgen::xdr_FSSTAT3res) +inline auto proc_t_of(NFS3::FSSTAT3res&)->decltype(&xdr_FSSTAT3res) { - return &rpcgen::xdr_FSSTAT3res; + return &xdr_FSSTAT3res; } // Procedure 19: FSINFO - Get static file system Information -inline auto proc_t_of(rpcgen::FSINFO3args&)->decltype(&rpcgen::xdr_FSINFO3args) +inline auto proc_t_of(NFS3::FSINFO3args&)->decltype(&xdr_FSINFO3args) { - return &rpcgen::xdr_FSINFO3args; + return &xdr_FSINFO3args; } -inline auto proc_t_of(rpcgen::FSINFO3res&)->decltype(&rpcgen::xdr_FSINFO3res) +inline auto proc_t_of(NFS3::FSINFO3res&)->decltype(&xdr_FSINFO3res) { - return &rpcgen::xdr_FSINFO3res; + return &xdr_FSINFO3res; } // Procedure 20: PATHCONF - Retrieve POSIX information -inline auto proc_t_of(rpcgen::PATHCONF3args&)->decltype(&rpcgen::xdr_PATHCONF3args) +inline auto proc_t_of(NFS3::PATHCONF3args&)->decltype(&xdr_PATHCONF3args) { - return &rpcgen::xdr_PATHCONF3args; + return &xdr_PATHCONF3args; } -inline auto proc_t_of(rpcgen::PATHCONF3res&)->decltype(&rpcgen::xdr_PATHCONF3res) +inline auto proc_t_of(NFS3::PATHCONF3res&)->decltype(&xdr_PATHCONF3res) { - return &rpcgen::xdr_PATHCONF3res; + return &xdr_PATHCONF3res; } // Procedure 21: COMMIT - Commit cached data on a server to stable storage -inline auto proc_t_of(rpcgen::COMMIT3args&)->decltype(&rpcgen::xdr_COMMIT3args) +inline auto proc_t_of(NFS3::COMMIT3args&)->decltype(&xdr_COMMIT3args) { - return &rpcgen::xdr_COMMIT3args; + return &xdr_COMMIT3args; } -inline auto proc_t_of(rpcgen::COMMIT3res&)->decltype(&rpcgen::xdr_COMMIT3res) +inline auto proc_t_of(NFS3::COMMIT3res&)->decltype(&xdr_COMMIT3res) { - return &rpcgen::xdr_COMMIT3res; + return &xdr_COMMIT3res; } extern "C" @@ -298,39 +434,39 @@ const char* print_nfs3_procedures(const ProcEnumNFS3::NFSProcedure proc); std::ostream& operator<<(std::ostream& out, const ProcEnumNFS3::NFSProcedure proc); -void print_mode3(std::ostream& out, const rpcgen::uint32 val); -void print_access3(std::ostream& out, const rpcgen::uint32 val); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfsstat3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::ftype3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::specdata3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_fh3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfstime3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::fattr3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::post_op_attr& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::wcc_attr& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::pre_op_attr& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::wcc_data& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::post_op_fh3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::time_how& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::set_mode3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::set_uid3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::set_gid3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::set_size3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::set_atime& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::set_mtime& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::sattr3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::diropargs3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::sattrguard3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::stable_how& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::createmode3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::createhow3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::symlinkdata3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::devicedata3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::mknoddata3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::entry3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::dirlist3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::entryplus3& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::dirlistplus3& obj); +void print_mode3(std::ostream& out, const NFS3::uint32 val); +void print_access3(std::ostream& out, const NFS3::uint32 val); +std::ostream& operator<<(std::ostream& out, const NFS3::nfsstat3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::ftype3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::specdata3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::nfs_fh3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::nfstime3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::fattr3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::post_op_attr& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::wcc_attr& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::pre_op_attr& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::wcc_data& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::post_op_fh3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::time_how& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::set_mode3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::set_uid3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::set_gid3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::set_size3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::set_atime& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::set_mtime& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::sattr3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::diropargs3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::sattrguard3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::stable_how& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::createmode3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::createhow3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::symlinkdata3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::devicedata3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::mknoddata3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::entry3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::dirlist3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::entryplus3& obj); +std::ostream& operator<<(std::ostream& out, const NFS3::dirlistplus3& obj); } // namespace NFS3 } // namespace protocols diff --git a/src/protocols/nfs4/nfs41_utils.cpp b/src/protocols/nfs4/nfs41_utils.cpp new file mode 100644 index 0000000..f90c42f --- /dev/null +++ b/src/protocols/nfs4/nfs41_utils.cpp @@ -0,0 +1,8691 @@ +//------------------------------------------------------------------------------ +// Author: Alexey Costroma +// Description: Helpers for parsing NFS structures. +// Copyright (c) 2014 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#include <iomanip> + +#include "protocols/nfs/nfs_utils.h" +#include "protocols/nfs4/nfs41_utils.h" +//------------------------------------------------------------------------------ +using namespace NST::API::NFS41; +using namespace NST::protocols::NFS; // NFS helpers +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace NFS41 +{ + +std::ostream& operator<<(std::ostream& out, const ProcEnumNFS41::NFSProcedure proc) +{ + return out << print_nfs41_procedures(proc); +} + +const char* print_nfs41_procedures(const ProcEnumNFS41::NFSProcedure proc) +{ + // In all cases we suppose, that NFSv4 operation ILLEGAL(10044) + // has the second position in ProcEnumNFS41 + uint32_t i = proc; + if(proc == ProcEnumNFS41::ILLEGAL) i = 2; + + static const char* const NFS41ProcedureTitles[(ProcEnumNFS41::count+1)] = + { + "NULL","COMPOUND", "ILLEGAL", "ACCESS", "CLOSE", + "COMMIT", "CREATE", "DELEGPURGE", "DELEGRETURN", + "GETATTR", "GETFH", "LINK", "LOCK", + "LOCKT", "LOCKU", "LOOKUP", "LOOKUPP", + "NVERIFY", "OPEN", "OPENATTR", "OPEN_CONFIRM", + "OPEN_DOWNGRADE", "PUTFH", "PUTPUBFH", "PUTROOTFH", + "READ", "READDIR", "READLINK", "REMOVE", + "RENAME", "RENEW", "RESTOREFH", "SAVEFH", + "SECINFO", "SETATTR", "SETCLIENTID", "SETCLIENTID_CONFIRM", + "VERIFY", "WRITE", "RELEASE_LOCKOWNER","BACKCHANNEL_CTL", + "BIND_CONN_TO_SESSION", "EXCHANGE_ID", "CREATE_SESSION", "DESTROY_SESSION", + "FREE_STATEID", "GET_DIR_DELEGATION", "GETDEVICEINFO", "GETDEVICELIST", + "LAYOUTCOMMIT", "LAYOUTGET", "LAYOUTRETURN", "SECINFO_NO_NAME", + "SEQUENCE", "SET_SSV", "TEST_STATEID", "WANT_DELEGATION", + "DESTROY_CLIENTID", "RECLAIM_COMPLETE" + }; + + return NFS41ProcedureTitles[i]; +} + +std::ostream& operator<<(std::ostream& out, const nfs_ftype4& obj) +{ + switch(obj) + { + case nfs_ftype4::NF4REG: return out << "REG"; + case nfs_ftype4::NF4DIR: return out << "DIR"; + case nfs_ftype4::NF4BLK: return out << "BLK"; + case nfs_ftype4::NF4CHR: return out << "CHR"; + case nfs_ftype4::NF4LNK: return out << "LNK"; + case nfs_ftype4::NF4SOCK: return out << "SOCK"; + case nfs_ftype4::NF4FIFO: return out << "FIFO"; + case nfs_ftype4::NF4ATTRDIR: return out << "ATTRDIR"; + case nfs_ftype4::NF4NAMEDATTR: return out << "NAMEDATTR"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfsstat4& obj) +{ + switch(obj) + { + case nfsstat4::NFS4_OK: + return out << "OK"; + case nfsstat4::NFS4ERR_PERM: + return out << "ERROR_PERM"; + case nfsstat4::NFS4ERR_NOENT: + return out << "ERROR_NOENT"; + case nfsstat4::NFS4ERR_IO: + return out << "ERROR_IO"; + case nfsstat4::NFS4ERR_NXIO: + return out << "ERROR_NXIO"; + case nfsstat4::NFS4ERR_ACCESS: + return out << "ERROR_ACCESS"; + case nfsstat4::NFS4ERR_EXIST: + return out << "ERROR_EXIST"; + case nfsstat4::NFS4ERR_XDEV: + return out << "ERROR_XDEV"; + case nfsstat4::NFS4ERR_NOTDIR: + return out << "ERROR_NOTDIR"; + case nfsstat4::NFS4ERR_ISDIR: + return out << "ERROR_ISDIR"; + case nfsstat4::NFS4ERR_INVAL: + return out << "ERROR_INVAL"; + case nfsstat4::NFS4ERR_FBIG: + return out << "ERROR_FBIG"; + case nfsstat4::NFS4ERR_NOSPC: + return out << "ERROR_NOSPC"; + case nfsstat4::NFS4ERR_ROFS: + return out << "ERROR_ROFS"; + case nfsstat4::NFS4ERR_MLINK: + return out << "ERROR_MLINK"; + case nfsstat4::NFS4ERR_NAMETOOLONG: + return out << "ERROR_NAMETOOLONG"; + case nfsstat4::NFS4ERR_NOTEMPTY: + return out << "ERROR_NOTEMPTY"; + case nfsstat4::NFS4ERR_DQUOT: + return out << "ERROR_DQUOT"; + case nfsstat4::NFS4ERR_STALE: + return out << "ERROR_STALE"; + case nfsstat4::NFS4ERR_BADHANDLE: + return out << "ERROR_BADHANDLE"; + case nfsstat4::NFS4ERR_BAD_COOKIE: + return out << "ERROR_BAD_COOKIE"; + case nfsstat4::NFS4ERR_NOTSUPP: + return out << "ERROR_NOTSUPP"; + case nfsstat4::NFS4ERR_TOOSMALL: + return out << "ERROR_TOOSMALL"; + case nfsstat4::NFS4ERR_SERVERFAULT: + return out << "ERROR_SERVERFAULT"; + case nfsstat4::NFS4ERR_BADTYPE: + return out << "ERROR_BADTYPE"; + case nfsstat4::NFS4ERR_DELAY: + return out << "ERROR_DELAY"; + case nfsstat4::NFS4ERR_SAME: + return out << "ERROR_SAME"; + case nfsstat4::NFS4ERR_DENIED: + return out << "ERROR_DENIED"; + case nfsstat4::NFS4ERR_EXPIRED: + return out << "ERROR_EXPIRED"; + case nfsstat4::NFS4ERR_LOCKED: + return out << "ERROR_LOCKED"; + case nfsstat4::NFS4ERR_GRACE: + return out << "ERROR_GRACE"; + case nfsstat4::NFS4ERR_FHEXPIRED: + return out << "ERROR_FHEXPIRED"; + case nfsstat4::NFS4ERR_SHARE_DENIED: + return out << "ERROR_SHARE_DENIED"; + case nfsstat4::NFS4ERR_WRONGSEC: + return out << "ERROR_WRONGSEC"; + case nfsstat4::NFS4ERR_CLID_INUSE: + return out << "ERROR_CLID_INUSE"; + case nfsstat4::NFS4ERR_RESOURCE: + return out << "ERROR_RESOURCE"; + case nfsstat4::NFS4ERR_MOVED: + return out << "ERROR_MOVED"; + case nfsstat4::NFS4ERR_NOFILEHANDLE: + return out << "ERROR_NOFILEHANDLE"; + case nfsstat4::NFS4ERR_MINOR_VERS_MISMATCH: + return out << "ERROR_MINOR_VERS_MISMATCH"; + case nfsstat4::NFS4ERR_STALE_CLIENTID: + return out << "ERROR_STALE_CLIENTID"; + case nfsstat4::NFS4ERR_STALE_STATEID: + return out << "ERROR_STALE_STATEID"; + case nfsstat4::NFS4ERR_OLD_STATEID: + return out << "ERROR_OLD_STATEID"; + case nfsstat4::NFS4ERR_BAD_STATEID: + return out << "ERROR_BAD_STATEID"; + case nfsstat4::NFS4ERR_BAD_SEQID: + return out << "ERROR_BAD_SEQID"; + case nfsstat4::NFS4ERR_NOT_SAME: + return out << "ERROR_NOT_SAME"; + case nfsstat4::NFS4ERR_LOCK_RANGE: + return out << "ERROR_LOCK_RANGE"; + case nfsstat4::NFS4ERR_SYMLINK: + return out << "ERROR_SYMLINK"; + case nfsstat4::NFS4ERR_RESTOREFH: + return out << "ERROR_RESTOREFH"; + case nfsstat4::NFS4ERR_LEASE_MOVED: + return out << "ERROR_LEASE_MOVED"; + case nfsstat4::NFS4ERR_ATTRNOTSUPP: + return out << "ERROR_ATTRNOTSUPP"; + case nfsstat4::NFS4ERR_NO_GRACE: + return out << "ERROR_NO_GRACE"; + case nfsstat4::NFS4ERR_RECLAIM_BAD: + return out << "ERROR_RECLAIM_BAD"; + case nfsstat4::NFS4ERR_RECLAIM_CONFLICT: + return out << "ERROR_RECLAIM_CONFLICT"; + case nfsstat4::NFS4ERR_BADXDR: + return out << "ERROR_BADXDR"; + case nfsstat4::NFS4ERR_LOCKS_HELD: + return out << "ERROR_LOCKS_HELD"; + case nfsstat4::NFS4ERR_OPENMODE: + return out << "ERROR_OPENMODE"; + case nfsstat4::NFS4ERR_BADOWNER: + return out << "ERROR_BADOWNER"; + case nfsstat4::NFS4ERR_BADCHAR: + return out << "ERROR_BADCHAR"; + case nfsstat4::NFS4ERR_BADNAME: + return out << "ERROR_BADNAME"; + case nfsstat4::NFS4ERR_BAD_RANGE: + return out << "ERROR_BAD_RANGE"; + case nfsstat4::NFS4ERR_LOCK_NOTSUPP: + return out << "ERROR_LOCK_NOTSUPP"; + case nfsstat4::NFS4ERR_OP_ILLEGAL: + return out << "ERROR_OP_ILLEGAL"; + case nfsstat4::NFS4ERR_DEADLOCK: + return out << "ERROR_DEADLOCK"; + case nfsstat4::NFS4ERR_FILE_OPEN: + return out << "ERROR_FILE_OPEN"; + case nfsstat4::NFS4ERR_ADMIN_REVOKED: + return out << "ERROR_ADMIN_REVOKED"; + case nfsstat4::NFS4ERR_CB_PATH_DOWN: + return out << "ERROR_CB_PATH_DOWN"; + case nfsstat4::NFS4ERR_BADIOMODE: + return out << "NFS4ERR_BADIOMODE"; + case nfsstat4::NFS4ERR_BADLAYOUT: + return out << "NFS4ERR_BADLAYOUT"; + case nfsstat4::NFS4ERR_BAD_SESSION_DIGEST: + return out << "NFS4ERR_BAD_SESSION_DIGEST"; + case nfsstat4::NFS4ERR_BADSESSION: + return out << "NFS4ERR_BADSESSION"; + case nfsstat4::NFS4ERR_BADSLOT: + return out << "NFS4ERR_BADSLOT"; + case nfsstat4::NFS4ERR_COMPLETE_ALREADY: + return out << "NFS4ERR_COMPLETE_ALREADY"; + case nfsstat4::NFS4ERR_CONN_NOT_BOUND_TO_SESSION: + return out << "NFS4ERR_CONN_NOT_BOUND_TO_SESSION"; + case nfsstat4::NFS4ERR_DELEG_ALREADY_WANTED: + return out << "NFS4ERR_DELEG_ALREADY_WANTED"; + case nfsstat4::NFS4ERR_BACK_CHAN_BUSY: + return out << "NFS4ERR_BACK_CHAN_BUSY"; + case nfsstat4::NFS4ERR_LAYOUTTRYLATER: + return out << "NFS4ERR_LAYOUTTRYLATER"; + case nfsstat4::NFS4ERR_LAYOUTUNAVAILABLE: + return out << "NFS4ERR_LAYOUTUNAVAILABLE"; + case nfsstat4::NFS4ERR_NOMATCHING_LAYOUT: + return out << "NFS4ERR_NOMATCHING_LAYOUT"; + case nfsstat4::NFS4ERR_RECALLCONFLICT: + return out << "NFS4ERR_RECALLCONFLICT"; + case nfsstat4::NFS4ERR_UNKNOWN_LAYOUTTYPE: + return out << "NFS4ERR_UNKNOWN_LAYOUTTYPE"; + case nfsstat4::NFS4ERR_SEQ_MISORDERED: + return out << "NFS4ERR_SEQ_MISORDERED"; + case nfsstat4::NFS4ERR_SEQUENCE_POS: + return out << "NFS4ERR_SEQUENCE_POS"; + case nfsstat4::NFS4ERR_REQ_TOO_BIG: + return out << "NFS4ERR_REQ_TOO_BIG"; + case nfsstat4::NFS4ERR_REP_TOO_BIG: + return out << "NFS4ERR_REP_TOO_BIG"; + case nfsstat4::NFS4ERR_REP_TOO_BIG_TO_CACHE: + return out << "NFS4ERR_REP_TOO_BIG_TO_CACHE"; + case nfsstat4::NFS4ERR_RETRY_UNCACHED_REP: + return out << "NFS4ERR_RETRY_UNCACHED_REP"; + case nfsstat4::NFS4ERR_UNSAFE_COMPOUND: + return out << "NFS4ERR_UNSAFE_COMPOUND"; + case nfsstat4::NFS4ERR_TOO_MANY_OPS: + return out << "NFS4ERR_TOO_MANY_OPS"; + case nfsstat4::NFS4ERR_OP_NOT_IN_SESSION: + return out << "NFS4ERR_OP_NOT_IN_SESSION"; + case nfsstat4::NFS4ERR_HASH_ALG_UNSUPP: + return out << "NFS4ERR_HASH_ALG_UNSUPP"; + case nfsstat4::NFS4ERR_CLIENTID_BUSY: + return out << "NFS4ERR_CLIENTID_BUSY"; + case nfsstat4::NFS4ERR_PNFS_IO_HOLE: + return out << "NFS4ERR_PNFS_IO_HOLE"; + case nfsstat4::NFS4ERR_SEQ_FALSE_RETRY: + return out << "NFS4ERR_SEQ_FALSE_RETRY"; + case nfsstat4::NFS4ERR_BAD_HIGH_SLOT: + return out << "NFS4ERR_BAD_HIGH_SLOT"; + case nfsstat4::NFS4ERR_DEADSESSION: + return out << "NFS4ERR_DEADSESSION"; + case nfsstat4::NFS4ERR_ENCR_ALG_UNSUPP: + return out << "NFS4ERR_ENCR_ALG_UNSUPP"; + case nfsstat4::NFS4ERR_PNFS_NO_LAYOUT: + return out << "NFS4ERR_PNFS_NO_LAYOUT"; + case nfsstat4::NFS4ERR_NOT_ONLY_OP: + return out << "NFS4ERR_NOT_ONLY_OP"; + case nfsstat4::NFS4ERR_WRONG_CRED: + return out << "NFS4ERR_WRONG_CRED"; + case nfsstat4::NFS4ERR_WRONG_TYPE: + return out << "NFS4ERR_WRONG_TYPE"; + case nfsstat4::NFS4ERR_DIRDELEG_UNAVAIL: + return out << "NFS4ERR_DIRDELEG_UNAVAIL"; + case nfsstat4::NFS4ERR_REJECT_DELEG: + return out << "NFS4ERR_REJECT_DELEG"; + case nfsstat4::NFS4ERR_RETURNCONFLICT: + return out << "NFS4ERR_RETURNCONFLICT"; + case nfsstat4::NFS4ERR_DELEG_REVOKED: + return out << "NFS4ERR_DELEG_REVOKED"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const bitmap4& obj) +{ + if(obj.bitmap4_len) + { + out << "mask: "; + print_hex(out, obj.bitmap4_val, obj.bitmap4_len); + const size_t nbits {obj.bitmap4_len << 5}; // obj.bitmap4_len * 32 + + static const char* const FATTR4Attributes[] = + { + "SUPPORTED_ATTRS", "TYPE", "FH_EXPIRE_TYPE", "CHANGE", + "SIZE", "LINK_SUPPORT", "SYMLINK_SUPPORT", "NAMED_ATTR", + "FSID", "UNIQUE_HANDLES", "LEASE_TIME", "RDATTR_ERROR", + "ACL", "ACLSUPPORT", "ARCHIVE", "CANSETTIME", + "CASE_INSENSITIVE","CASE_PRESERVING", "CHOWN_RESTRICTED","FILEHANDLE", + "FILEID", "FILES_AVAIL", "FILES_FREE", "FILES_TOTAL", + "FS_LOCATIONS", "HIDDEN", "HOMOGENEOUS", "MAXFILESIZE", + "MAXLINK", "MAXNAME", "MAXREAD", "MAXWRITE", + "MIMETYPE", "MODE", "NO_TRUNC", "NUMLINKS", + "OWNER", "OWNER_GROUP", "QUOTA_AVAIL_HARD","QUOTA_AVAIL_SOFT", + "QUOTA_USED", "RAWDEV", "SPACE_AVAIL", "SPACE_FREE", + "SPACE_TOTAL", "SPACE_USED", "SYSTEM", "TIME_ACCESS", + "TIME_ACCESS_SET", "TIME_BACKUP", "TIME_CREATE", "TIME_DELTA", + "TIME_METADATA", "TIME_MODIFY", "TIME_MODIFY_SET", "MOUNTED_ON_FILEID", + "DIR_NOTIF_DELAY", "DIRENT_NOTIF_DELAY","DACL", "SACL", + "CHANGE_POLICY", "FS_STATUS", "FS_LAYOUT_TYPES", "LAYOUT_HINT", + "LAYOUT_TYPES", "LAYOUT_BLKSIZE", "LAYOUT_ALIGNMENT","FS_LOCATIONS_INFO", + "MDSTHRESHOLD", "RETENTION_GET", "RETENTION_SET", "RETENTEVT_GET", + "RETENTEVT_SET", "RETENTION_HOLD", "MODE_SET_MASKED", "SUPPATTR_EXCLCREAT", + "FS_CHARSET_CAP" + }; + for(size_t i {0}; i<nbits; i++) + { + //obj.bitmap4_val[i / 32] >> (i % 32)) & 0x1; + const int bit = (obj.bitmap4_val[i >> 5] >> (i & 31)) & 0x1; + if( bit !=0 && i < ( sizeof(FATTR4Attributes)/ + sizeof(FATTR4Attributes[0]) ) ) + out << ' ' << FATTR4Attributes[i]; + } + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfs_fh4& obj) +{ + NFS::print_nfs_fh(out, + obj.nfs_fh4_val, + obj.nfs_fh4_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const sec_oid4& obj) +{ + print_hex(out, + obj.sec_oid4_val, + obj.sec_oid4_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const utf8string& obj) +{ + if(obj.utf8string_len) + { + out.write(obj.utf8string_val, + obj.utf8string_len); + } + else + { + out << "void"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const pathname4& obj) +{ + component4 *current_el = obj.pathname4_val; + for(size_t i {0}; i<obj.pathname4_len; i++,current_el++) + { + out.write(current_el->utf8string_val, + current_el->utf8string_len); + out << ' '; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfstime4& obj) +{ + return out << "sec: " << obj.seconds + << " nsec: " << obj.nseconds; +} + +std::ostream& operator<<(std::ostream& out, const time_how4& obj) +{ + switch(obj) + { + case time_how4::SET_TO_SERVER_TIME4: + return out << "server time"; + case time_how4::SET_TO_CLIENT_TIME4: + return out << "client time"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const settime4& obj) +{ + return out << obj.set_it << ": " << obj.settime4_u.time; +} + +std::ostream& operator<<(std::ostream& out, const fsid4& obj) +{ + return out << "major: " << obj.major + << " minor: " << obj.minor; +} + +std::ostream& operator<<(std::ostream& out, const fs_location4& obj) +{ + out << "root path: " << obj.rootpath; + utf8str_cis *current_el {obj.server.server_val}; + for(size_t i {0}; i<obj.server.server_len; i++,current_el++) + { + out.write(current_el->utf8string_val, + current_el->utf8string_len); + out << ' '; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const fs_locations4& obj) +{ + out << "root: " << obj.fs_root; + if(obj.locations.locations_len) + { + fs_location4* current_el {obj.locations.locations_val}; + for(u_int i {0}; i<obj.locations.locations_len; i++,current_el++) + { + out << current_el; + } + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfsace4& obj) +{ + return out << "type: " << obj.type + << " flag: " << obj.flag + << " access mask: " << obj.access_mask + << " who: " << obj.who; +} + +std::ostream& operator<<(std::ostream& out, const change_policy4& obj) +{ + return out << "major: " << obj.cp_major + << " minor: " << obj.cp_minor; +} + +std::ostream& operator<<(std::ostream& out, const nfsacl41& obj) +{ + out << "flag: " << obj.na41_flag; + if(obj.na41_aces.na41_aces_len) + { + nfsace4* current_el {obj.na41_aces.na41_aces_val}; + for(u_int i {0}; i<obj.na41_aces.na41_aces_len; i++,current_el++) + { + out << ' ' << current_el; + } + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const mode_masked4& obj) +{ + return out << "value to set: " << obj.mm_value_to_set + << " mask bits: " << obj.mm_mask_bits; +} + +std::ostream& operator<<(std::ostream& out, const specdata4& obj) +{ + return out << "specdata 1: " << obj.specdata1 + << " specdata 2: " << obj.specdata2; +} + +std::ostream& operator<<(std::ostream& out, const netaddr4& obj) +{ + return out << "netid: " << obj.na_r_netid + << " addr: " << obj.na_r_addr; +} + +std::ostream& operator<<(std::ostream& out, const nfs_impl_id4& obj) +{ + out << "domain: "; + out.write(obj.nii_domain.utf8string_val, + obj.nii_domain.utf8string_len); + + out << " name: "; + out.write(obj.nii_name.utf8string_val, + obj.nii_name.utf8string_len); + + out << " date: " << obj.nii_date; + + return out; +} + +std::ostream& operator<<(std::ostream& out, const stateid4& obj) +{ + out << " seqid: " << std::hex << obj.seqid << " data: "; + print_hex(out, + obj.other, + 12); + return out; +} + +std::ostream& operator<<(std::ostream& out, const layouttype4& obj) +{ + switch(obj) + { + case layouttype4::LAYOUT4_NFSV4_1_FILES: return out << "NFSV4_1_FILES"; + case layouttype4::LAYOUT4_OSD2_OBJECTS: return out << "OSD2_OBJECTS"; + case layouttype4::LAYOUT4_BLOCK_VOLUME: return out << "BLOCK_VOLUME"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const layout_content4& obj) +{ + out << "type: " << obj.loc_type; + out.write(obj.loc_body.loc_body_val, + obj.loc_body.loc_body_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const layouthint4& obj) +{ + out << "type: " << obj.loh_type; + out.write(obj.loh_body.loh_body_val, + obj.loh_body.loh_body_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutiomode4& obj) +{ + switch(obj) + { + case layoutiomode4::LAYOUTIOMODE4_READ: return out << "READ"; + case layoutiomode4::LAYOUTIOMODE4_RW: return out << "RW"; + case layoutiomode4::LAYOUTIOMODE4_ANY: return out << "ANYE"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const layout4& obj) +{ + out << "offset: " << obj.lo_offset + << " length: " << obj.lo_length + << " iomode: " << obj.lo_iomode + << " content: " << obj.lo_content; + return out; +} + +std::ostream& operator<<(std::ostream& out, const device_addr4& obj) +{ + out << "layout type: " << obj.da_layout_type; + out.write(obj.da_addr_body.da_addr_body_val, + obj.da_addr_body.da_addr_body_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutupdate4& obj) +{ + out << "type: " << obj.lou_type; + out.write(obj.lou_body.lou_body_val, + obj.lou_body.lou_body_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutreturn_type4& obj) +{ + switch(obj) + { + case layoutreturn_type4::LAYOUTRETURN4_FILE: return out << "FILE"; + case layoutreturn_type4::LAYOUTRETURN4_FSID: return out << "FSID"; + case layoutreturn_type4::LAYOUTRETURN4_ALL: return out << "ALL"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutreturn_file4& obj) +{ + out << "offset: " << obj.lrf_offset + << " length: " << obj.lrf_length + << " stateid: " << obj.lrf_stateid + << " content: "; + out.write(obj.lrf_body.lrf_body_val, + obj.lrf_body.lrf_body_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutreturn4& obj) +{ + out << "type: " << obj.lr_returntype; + if(obj.lr_returntype == layoutreturn_type4::LAYOUTRETURN4_FILE) + out << " layout: " << obj.layoutreturn4_u.lr_layout; + return out; +} + +std::ostream& operator<<(std::ostream& out, const fs4_status_type& obj) +{ + switch(obj) + { + case fs4_status_type::STATUS4_FIXED: return out << "FIXED"; + case fs4_status_type::STATUS4_UPDATED: return out << "UPDATED"; + case fs4_status_type::STATUS4_VERSIONED: return out << "VERSIONED"; + case fs4_status_type::STATUS4_WRITABLE: return out << "WRITABLE"; + case fs4_status_type::STATUS4_REFERRAL: return out << "REFERRAL"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const fs4_status& obj) +{ + out << "absent: " << obj.fss_absent + << " status: " << obj.fss_type + << " source: " << obj.fss_source + << " current: " << obj.fss_current + << " age: " << obj.fss_age + << " version: " << obj.fss_version; + return out; +} + +std::ostream& operator<<(std::ostream& out, const threshold_item4& obj) +{ + out << "layout type: " << obj.thi_layout_type + << " hint set: " << obj.thi_hintset + << " content: "; + out.write(obj.thi_hintlist.thi_hintlist_val, + obj.thi_hintlist.thi_hintlist_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const mdsthreshold4& obj) +{ + threshold_item4 *current_el = obj.mth_hints.mth_hints_val; + for(size_t i {0}; i<obj.mth_hints.mth_hints_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const retention_get4& obj) +{ + out << "duration: " << obj.rg_duration; + nfstime4 *current_el = obj.rg_begin_time.rg_begin_time_val; + for(size_t i {0}; i<obj.rg_begin_time.rg_begin_time_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const retention_set4& obj) +{ + out << "enable: " << obj.rs_enable; + uint64_t *current_el = obj.rs_duration.rs_duration_val; + for(size_t i {0}; i<obj.rs_duration.rs_duration_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const fattr4_acl& obj) +{ + if(obj.fattr4_acl_len) return out << *obj.fattr4_acl_val; + else return out << "void"; +} + +std::ostream& operator<<(std::ostream& out, const fattr4_fs_layout_types& obj) +{ + layouttype4 *current_el = obj.fattr4_fs_layout_types_val; + for(size_t i {0}; i<obj.fattr4_fs_layout_types_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const fattr4_layout_types& obj) +{ + layouttype4 *current_el = obj.fattr4_layout_types_val; + for(size_t i {0}; i<obj.fattr4_layout_types_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const fattr4& obj) +{ + return out << obj.attrmask; +} + +std::ostream& operator<<(std::ostream& out, const change_info4& obj) +{ + out << " atomic: "; + if(obj.atomic) out << "YES"; + else out << "NO"; + + return out << " change id before: " << obj.before + << " change id after: " << obj.after; +} + +std::ostream& operator<<(std::ostream& out, const cb_client4& obj) +{ + return out << "program: " << std::hex << obj.cb_program + << " location: " << obj.cb_location; +} + +std::ostream& operator<<(std::ostream& out, const nfs_client_id4& obj) +{ + out << "verifier: "; + print_hex(out, + obj.verifier, + NFS4_VERIFIER_SIZE); + out << " client id: "; + if(obj.id.id_len) out.write(obj.id.id_val, + obj.id.id_len); + else out << " void"; + + return out; +} + +std::ostream& operator<<(std::ostream& out, const client_owner4& obj) +{ + out << "verifier: "; + print_hex(out, + obj.co_verifier, + NFS4_VERIFIER_SIZE); + out << " client id: "; + if(obj.co_ownerid.co_ownerid_len) + out.write(obj.co_ownerid.co_ownerid_val, + obj.co_ownerid.co_ownerid_len); + else out << " void"; + + return out; +} + +std::ostream& operator<<(std::ostream& out, const server_owner4& obj) +{ + out << "minor id: " << obj.so_minor_id; + out << " major id: "; + if(obj.so_major_id.so_major_id_len) + out.write(obj.so_major_id.so_major_id_val, + obj.so_major_id.so_major_id_len); + else out << " void"; + + return out; +} + +std::ostream& operator<<(std::ostream& out, const state_owner4& obj) +{ + out << "client id: 0x" << std::hex << obj.clientid << " owner: 0x"; + print_hex(out, + obj.owner.owner_val, + obj.owner.owner_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfs_lock_type4& obj) +{ + switch(obj) + { + case nfs_lock_type4::READ_LT: return out << "READ_LOCK_TYPE"; + case nfs_lock_type4::WRITE_LT: return out << "WRITE_LOCK_TYPE"; + case nfs_lock_type4::READW_LT: return out << "READW_LOCK_TYPE"; + case nfs_lock_type4::WRITEW_LT: return out << "WRITEW_LOCK_TYPE"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_subkey4& obj) +{ + out << "SSV4_SUBKEY_"; + switch(obj) + { + case ssv_subkey4::SSV4_SUBKEY_MIC_I2T: return out << "MIC_I2T"; + case ssv_subkey4::SSV4_SUBKEY_MIC_T2I: return out << "MIC_T2I"; + case ssv_subkey4::SSV4_SUBKEY_SEAL_I2T: return out << "MIC_I2T"; + case ssv_subkey4::SSV4_SUBKEY_SEAL_T2I: return out << "MIC_T2I"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_mic_plain_tkn4& obj) +{ + out << "ssv seq: " << obj.smpt_ssv_seq << ' '; + out.write(obj.smpt_orig_plain.smpt_orig_plain_val, + obj.smpt_orig_plain.smpt_orig_plain_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_mic_tkn4& obj) +{ + out << "ssv seq: " << obj.smt_ssv_seq << ' '; + out.write(obj.smt_hmac.smt_hmac_val, + obj.smt_hmac.smt_hmac_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_seal_plain_tkn4& obj) +{ + out << "confounder: "; + out.write(obj.sspt_confounder.sspt_confounder_val, + obj.sspt_confounder.sspt_confounder_len); + out << " ssv seq: " << obj.sspt_ssv_seq + << " orig plain: "; + out.write(obj.sspt_orig_plain.sspt_orig_plain_val, + obj.sspt_orig_plain.sspt_orig_plain_len); + out << " pad: "; + out.write(obj.sspt_pad.sspt_pad_val, + obj.sspt_pad.sspt_pad_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_seal_cipher_tkn4& obj) +{ + out << "ssv seq: " << obj.ssct_ssv_seq + << " iv: "; + out.write(obj.ssct_iv.ssct_iv_val, + obj.ssct_iv.ssct_iv_len); + out << " encrypted data: "; + out.write(obj.ssct_encr_data.ssct_encr_data_val, + obj.ssct_encr_data.ssct_encr_data_len); + out << " hmac: "; + out.write(obj.ssct_hmac.ssct_hmac_val, + obj.ssct_hmac.ssct_hmac_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const fs_locations_server4& obj) +{ + out << "currency: " << obj.fls_currency + << " info: "; + out.write(obj.fls_info.fls_info_val, + obj.fls_info.fls_info_len); + out << " server: " << obj.fls_server; + return out; +} + +std::ostream& operator<<(std::ostream& out, const fs_locations_item4& obj) +{ + fs_locations_server4 *current_el = obj.fli_entries.fli_entries_val; + for(size_t i {0}; i<obj.fli_entries.fli_entries_len; i++,current_el++) + { + out << ' ' << current_el; + } + out << " rootpath: " << obj.fli_rootpath; + return out; +} + +std::ostream& operator<<(std::ostream& out, const fs_locations_info4& obj) +{ + out << "flags: " << obj.fli_flags + << " valid for: " << obj.fli_valid_for + << " fs root: " << obj.fli_fs_root + << " items:"; + fs_locations_item4 *current_el = obj.fli_items.fli_items_val; + for(size_t i {0}; i<obj.fli_items.fli_items_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const filelayout_hint_care4& obj) +{ + switch(obj) + { + case filelayout_hint_care4::NFLH4_CARE_DENSE: + return out << "DENSE"; + case filelayout_hint_care4::NFLH4_CARE_COMMIT_THRU_MDS: + return out << "COMMIT_THRU_MDS"; + case filelayout_hint_care4::NFLH4_CARE_STRIPE_UNIT_SIZE: + return out << "STRIPE_UNIT_SIZE"; + case filelayout_hint_care4::NFLH4_CARE_STRIPE_COUNT: + return out << "STRIPE_COUNT"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfsv4_1_file_layouthint4& obj) +{ + out << "nflh care: " << obj.nflh_care + << " nflh util: " << obj.nflh_util + << " stripe count: " << obj.nflh_stripe_count; + return out; +} + +std::ostream& operator<<(std::ostream& out, const multipath_list4& obj) +{ + netaddr4 *current_el = obj.multipath_list4_val; + for(size_t i {0}; i<obj.multipath_list4_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfsv4_1_file_layout_ds_addr4& obj) +{ + out << "stripe indices: "; + print_hex(out, + obj.nflda_stripe_indices.nflda_stripe_indices_val, + obj.nflda_stripe_indices.nflda_stripe_indices_len); + out << " multipath ds list: "; + multipath_list4 *current_el = obj.nflda_multipath_ds_list.nflda_multipath_ds_list_val; + for(size_t i {0}; i<obj.nflda_multipath_ds_list.nflda_multipath_ds_list_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfsv4_1_file_layout4& obj) +{ + out << "device id: " << obj.nfl_deviceid + << " nfl util: " << obj.nfl_util + << " 1st stripe index: " << obj.nfl_first_stripe_index + << " pattern offset: " << obj.nfl_pattern_offset + << " fh list:"; + nfs_fh4 *current_el = obj.nfl_fh_list.nfl_fh_list_val; + for(size_t i {0}; i<obj.nfl_fh_list.nfl_fh_list_len; i++,current_el++) + { + out << ' '; + print_nfs_fh(out, + current_el->nfs_fh4_val, + current_el->nfs_fh4_len); + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const createtype4& obj) +{ + out << "type: " << obj.type; + switch(obj.type) + { + case nfs_ftype4::NF4BLK: + case nfs_ftype4::NF4CHR: + return out << " dev data: " << obj.createtype4_u.devdata; + case nfs_ftype4::NF4LNK: + return out << " link data: " << obj.createtype4_u.linkdata; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const open_to_lock_owner4& obj) +{ + return out << "open seqid: " << obj.open_seqid + << " open state id: " << obj.open_stateid + << " lock seqid: " << obj.lock_seqid + << " lock owner: " << obj.lock_owner; +} + +std::ostream& operator<<(std::ostream& out, const exist_lock_owner4& obj) +{ + return out << "lock state id: " << obj.lock_stateid + << " lock seqid: " << obj.lock_seqid; +} + +std::ostream& operator<<(std::ostream& out, const locker4& obj) +{ + out << "new lock owner: " << obj.new_lock_owner; + if(obj.new_lock_owner) + return out << " open owner: " << obj.locker4_u.open_owner; + else + return out << " lock owner: " << obj.locker4_u.lock_owner; +} + +std::ostream& operator<<(std::ostream& out, const createmode4& obj) +{ + switch(obj) + { + case createmode4::UNCHECKED4: return out << "UNCHECKED"; + case createmode4::GUARDED4: return out << "GUARDED"; + case createmode4::EXCLUSIVE4: return out << "EXCLUSIVE4"; + case createmode4::EXCLUSIVE4_1: return out << "EXCLUSIVE4_1"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const creatverfattr& obj) +{ + out << "verf: "; + print_hex(out, obj.cva_verf, NFS4_VERIFIER_SIZE); + out << " attrs: " << obj.cva_attrs; + return out; +} + +std::ostream& operator<<(std::ostream& out, const createhow4& obj) +{ + out << " mode: " << obj.mode; + switch(obj.mode) + { + case createmode4::UNCHECKED4: + case createmode4::GUARDED4: + return out << " attributes: " << obj.createhow4_u.createattrs; + case createmode4::EXCLUSIVE4: + out << " verifier: "; + print_hex(out, obj.createhow4_u.createverf, NFS4_VERIFIER_SIZE); + case createmode4::EXCLUSIVE4_1: + out << " verifier: "; + print_hex(out, obj.createhow4_u.ch_createboth.cva_verf, NFS4_VERIFIER_SIZE); + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const opentype4& obj) +{ + switch(obj) + { + case opentype4::OPEN4_NOCREATE: return out << "NO CREATE"; + case opentype4::OPEN4_CREATE: return out << "CREATE"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const openflag4& obj) +{ + out << "open type: " << obj.opentype; + if(obj.opentype == opentype4::OPEN4_CREATE) + return out << obj.openflag4_u.how; + else + return out; +} + +std::ostream& operator<<(std::ostream& out, const limit_by4& obj) +{ + switch(obj) + { + case limit_by4::NFS_LIMIT_SIZE: return out << "SIZE"; + case limit_by4::NFS_LIMIT_BLOCKS: return out << "BLOCKS"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const nfs_modified_limit4& obj) +{ + return out << "blocks number: " << obj.num_blocks + << " bytes per block: " << obj.bytes_per_block; +} + +std::ostream& operator<<(std::ostream& out, const nfs_space_limit4& obj) +{ + out << "limit by: " << obj.limitby; + switch(obj.limitby) + { + case limit_by4::NFS_LIMIT_SIZE: + return out << " filesize: " + << obj.nfs_space_limit4_u.filesize; + case limit_by4::NFS_LIMIT_BLOCKS: + return out << " modified blocks: " + << obj.nfs_space_limit4_u.mod_blocks; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const open_delegation_type4& obj) +{ + switch(obj) + { + case open_delegation_type4::OPEN_DELEGATE_NONE: + return out << "NONE"; + case open_delegation_type4::OPEN_DELEGATE_READ: + return out << "READ"; + case open_delegation_type4::OPEN_DELEGATE_WRITE: + return out << "WRITE"; + case open_delegation_type4::OPEN_DELEGATE_NONE_EXT: + return out << "NONE_EXT"; + } + return out; +} + + +std::ostream& operator<<(std::ostream& out, const open_claim_type4& obj) +{ + switch(obj) + { + case open_claim_type4::CLAIM_NULL: + return out << "NULL"; + case open_claim_type4::CLAIM_PREVIOUS: + return out << "PREVIOUS"; + case open_claim_type4::CLAIM_DELEGATE_CUR: + return out << "DELEGATE CURRENT"; + case open_claim_type4::CLAIM_DELEGATE_PREV: + return out << "DELEGATE PREVIOUS"; + case open_claim_type4::CLAIM_FH: + return out << "FH"; + case open_claim_type4::CLAIM_DELEG_CUR_FH: + return out << "DELEGATE CURRENT FH"; + case open_claim_type4::CLAIM_DELEG_PREV_FH: + return out << "DELEGATE PREVIOUS FH"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const open_claim_delegate_cur4& obj) +{ + return out << "delegate state id: " << obj.delegate_stateid + << " file: " << obj.file; +} + +std::ostream& operator<<(std::ostream& out, const open_claim4& obj) +{ + out << "claim: " << obj.claim; + switch(obj.claim) + { + case open_claim_type4::CLAIM_NULL: + out << " file: "; + return out.write(obj.open_claim4_u.file.utf8string_val, + obj.open_claim4_u.file.utf8string_len); + case open_claim_type4::CLAIM_PREVIOUS: + return out << " delegate type: " + << obj.open_claim4_u.delegate_type; + case open_claim_type4::CLAIM_DELEGATE_CUR: + return out << " delegate current info: " + << obj.open_claim4_u.delegate_cur_info; + case open_claim_type4::CLAIM_DELEGATE_PREV: + return out << " file delegate previous: " + << obj.open_claim4_u.file_delegate_prev; + case open_claim_type4::CLAIM_FH: + case open_claim_type4::CLAIM_DELEG_PREV_FH: + break; + case open_claim_type4::CLAIM_DELEG_CUR_FH: + return out << " oc delegate stateid: " + << obj.open_claim4_u.oc_delegate_stateid; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const open_read_delegation4& obj) +{ + return out << "stateid: " << obj.stateid + << " recall: " << obj.recall + << " permissions: " << obj.permissions; +} + +std::ostream& operator<<(std::ostream& out, const open_write_delegation4& obj) +{ + return out << "stateid: " << obj.stateid + << " recall: " << obj.recall + << " space limit: " << obj.space_limit + << " permissions: " << obj.permissions; +} + +std::ostream& operator<<(std::ostream& out, const why_no_delegation4& obj) +{ + switch(obj) + { + case why_no_delegation4::WND4_NOT_WANTED: + return out << "NOT WANTED"; + case why_no_delegation4::WND4_CONTENTION: + return out << "CONTENTION"; + case why_no_delegation4::WND4_RESOURCE: + return out << "RESOURCE"; + case why_no_delegation4::WND4_NOT_SUPP_FTYPE: + return out << "NOT_SUPP_FTYPE"; + case why_no_delegation4::WND4_WRITE_DELEG_NOT_SUPP_FTYPE: + return out << "WRITE_DELEG_NOT_SUPP_FTYPE"; + case why_no_delegation4::WND4_NOT_SUPP_UPGRADE: + return out << "NOT_SUPP_UPGRADE"; + case why_no_delegation4::WND4_NOT_SUPP_DOWNGRADE: + return out << "NOT_SUPP_DOWNGRADE"; + case why_no_delegation4::WND4_CANCELLED: + return out << "CANCELLED"; + case why_no_delegation4::WND4_IS_DIR: + return out << "IS_DIR"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const open_none_delegation4& obj) +{ + out << "why: " << obj.ond_why; + switch(obj.ond_why) + { + case why_no_delegation4::WND4_CONTENTION: + out << " server will push deleg: " + << obj.open_none_delegation4_u.ond_server_will_push_deleg; + case why_no_delegation4::WND4_RESOURCE: + out << " server will signal available: " + << obj.open_none_delegation4_u.ond_server_will_signal_avail; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const open_delegation4& obj) +{ + out << "delegation type: " << obj.delegation_type; + switch(obj.delegation_type) + { + case open_delegation_type4::OPEN_DELEGATE_NONE: + break; + case open_delegation_type4::OPEN_DELEGATE_READ: + return out << ": " << obj.open_delegation4_u.read; + case open_delegation_type4::OPEN_DELEGATE_WRITE: + return out << ": " << obj.open_delegation4_u.write; + case open_delegation_type4::OPEN_DELEGATE_NONE_EXT: + return out << ": " << obj.open_delegation4_u.od_whynone; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const entry4& obj) +{ + out << "cookie: " << obj.cookie + << " name: " << obj.name + << " attributes: " << obj.attrs << '\n'; + if(obj.nextentry) return out << ' ' << *obj.nextentry; + else return out; +} + +std::ostream& operator<<(std::ostream& out, const dirlist4& obj) +{ + out << "eof: " << obj.eof; + if(obj.entries) return out << " entries:\n" + << *obj.entries; + else return out; +} + +std::ostream& operator<<(std::ostream& out, const rpc_gss_svc_t& obj) +{ + switch(obj) + { + case rpc_gss_svc_t::RPC_GSS_SVC_NONE: + return out << "NONE"; + case rpc_gss_svc_t::RPC_GSS_SVC_INTEGRITY: + return out << "INTEGRITY"; + case rpc_gss_svc_t::RPC_GSS_SVC_PRIVACY: + return out << "PRIVACY"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const rpcsec_gss_info& obj) +{ + return out << "oid: " << obj.oid + << " qop: " << obj.qop + << " service: " << obj.service; +} + +std::ostream& operator<<(std::ostream& out, const secinfo4& obj) +{ + out << " flavor: " << obj.flavor; + if(obj.flavor == RPCSEC_GSS) return out << " info: " + << obj.secinfo4_u.flavor_info; + else return out; +} + +std::ostream& operator<<(std::ostream& out, const stable_how4& obj) +{ + switch(obj) + { + case stable_how4::UNSTABLE4: return out << "UNSTABLE"; + case stable_how4::DATA_SYNC4: return out << "DATA SYNC"; + case stable_how4::FILE_SYNC4: return out << "FILE SYNC"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const gsshandle4_t& obj) +{ + print_hex(out, + obj.gsshandle4_t_val, + obj.gsshandle4_t_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const gss_cb_handles4& obj) +{ + out << "service: " << obj.gcbp_service + << " server: " << obj.gcbp_handle_from_server + << " client: " << obj.gcbp_handle_from_client; + return out; +} + +std::ostream& operator<<(std::ostream& out, const authunix_parms& obj) +{ + out << "time: " << obj.aup_time + << " machine name: " << obj.aup_machname + << " uid: " << obj.aup_uid + << " gid: " << obj.aup_gid; + __gid_t *current_el = obj.aup_gids; + for(size_t i {0}; i<obj.aup_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} +/* +std::ostream& operator<<(std::ostream& out, const authsys_parms& obj) +{ + out << "timestamp: " << obj.stamp + << " machine name: " << obj.machinename + << " uid: " << obj.uid + << " gid: " << obj.gid; + u_int *current_el = obj.gids.gids_val; + for(size_t i {0}; i<obj.gids.gids_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} +*/ +std::ostream& operator<<(std::ostream& out, const callback_sec_parms4& obj) +{ + out << " sec flavor: " << obj.cb_secflavor; + switch(obj.cb_secflavor) + { + case AUTH_NONE: + break; + case AUTH_SYS: + out << obj.callback_sec_parms4_u.cbsp_sys_cred; + case RPCSEC_GSS: + out << obj.callback_sec_parms4_u.cbsp_gss_handles; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const channel_dir_from_client4& obj) +{ + switch(obj) + { + case channel_dir_from_client4::CDFC4_FORE: return out << "FORE"; + case channel_dir_from_client4::CDFC4_BACK: return out << "BACK"; + case channel_dir_from_client4::CDFC4_FORE_OR_BOTH: return out << "FORE_OR_BOTH"; + case channel_dir_from_client4::CDFC4_BACK_OR_BOTH: return out << "BACK_OR_BOTH"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const channel_dir_from_server4& obj) +{ + switch(obj) + { + case channel_dir_from_server4::CDFS4_FORE: return out << "FORE"; + case channel_dir_from_server4::CDFS4_BACK: return out << "BACK"; + case channel_dir_from_server4::CDFS4_BOTH: return out << "BOTH"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const state_protect_ops4& obj) +{ + out << "must enforce: " << obj.spo_must_enforce + << " must allow: " << obj.spo_must_allow; + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_sp_parms4& obj) +{ + out << "ops: " << obj.ssp_ops; + sec_oid4 *current_el = obj.ssp_hash_algs.ssp_hash_algs_val; + for(size_t i {0}; i<obj.ssp_hash_algs.ssp_hash_algs_len; i++,current_el++) + { + out << ' ' << current_el; + } + out << " encr algs: "; + current_el = obj.ssp_encr_algs.ssp_encr_algs_val; + for(size_t i {0}; i<obj.ssp_encr_algs.ssp_encr_algs_len; i++,current_el++) + { + out << ' ' << current_el; + } + out << " window: " << obj.ssp_window + << " num_gss_handles: " << obj.ssp_num_gss_handles; + return out; +} + +std::ostream& operator<<(std::ostream& out, const state_protect_how4& obj) +{ + switch(obj) + { + case state_protect_how4::SP4_NONE: return out << "NONE"; + case state_protect_how4::SP4_MACH_CRED: return out << "MACH_CRED"; + case state_protect_how4::SP4_SSV: return out << "SSV"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const state_protect4_a& obj) +{ + out << "how: " << obj.spa_how; + switch(obj.spa_how) + { + case state_protect_how4::SP4_NONE: break; + case state_protect_how4::SP4_MACH_CRED: + return out << " mach ops: " << obj.state_protect4_a_u.spa_mach_ops; + case state_protect_how4::SP4_SSV: + return out << " ssv ops: " << obj.state_protect4_a_u.spa_ssv_parms; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssv_prot_info4& obj) +{ + out << "ops: " << obj.spi_ops + << " hash alg: " << obj.spi_hash_alg + << " encr alg: " << obj.spi_encr_alg + << " ssv len: " << obj.spi_ssv_len + << " window: " << obj.spi_window + << " handles:"; + gsshandle4_t *current_el = obj.spi_handles.spi_handles_val; + for(size_t i {0}; i<obj.spi_handles.spi_handles_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const state_protect4_r& obj) +{ + out << "how: " << obj.spr_how; + switch(obj.spr_how) + { + case state_protect_how4::SP4_NONE: break; + case state_protect_how4::SP4_MACH_CRED: + return out << " mach ops: " << obj.state_protect4_r_u.spr_mach_ops; + case state_protect_how4::SP4_SSV: + return out << " ssv ops: " << obj.state_protect4_r_u.spr_ssv_info; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const channel_attrs4& obj) +{ + out << "header pad size: " << obj.ca_headerpadsize + << "; max request size: " << obj.ca_maxrequestsize + << "; max response size: " << obj.ca_maxresponsesize + << "; max response size cached: " << obj.ca_maxresponsesize_cached + << "; max operations: " << obj.ca_maxoperations + << "; max requests: " << obj.ca_maxrequests + << "; rdma ird: "; + print_hex(out, + obj.ca_rdma_ird.ca_rdma_ird_val, + obj.ca_rdma_ird.ca_rdma_ird_len); + return out; +} + +std::ostream& operator<<(std::ostream& out, const gddrnf4_status& obj) +{ + switch(obj) + { + case gddrnf4_status::GDD4_OK: return out << "OK"; + case gddrnf4_status::GDD4_UNAVAIL: return out << "UNAVAIL"; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const newtime4& obj) +{ + out << "time changed: " << obj.nt_timechanged; + switch(obj.nt_timechanged) + { + case TRUE: return out << " time: " << obj.newtime4_u.nt_time; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const newoffset4& obj) +{ + out << "no new offset: " << obj.no_newoffset; + switch(obj.no_newoffset) + { + case TRUE: return out << " offset: " << obj.newoffset4_u.no_offset; + default: break; + } + return out; +} + + +std::ostream& operator<<(std::ostream& out, const newsize4& obj) +{ + out << "size changed: " << obj.ns_sizechanged; + switch(obj.ns_sizechanged) + { + case TRUE: return out << " size: " << obj.newsize4_u.ns_size; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutreturn_stateid& obj) +{ + out << "present: " << obj.lrs_present; + switch(obj.lrs_present) + { + case TRUE: return out << " stateid: " << obj.layoutreturn_stateid_u.lrs_stateid; + default: break; + } + return out; +} + + +std::ostream& operator<<(std::ostream& out, const secinfo_style4& obj) +{ + switch(obj) + { + case secinfo_style4::SECINFO_STYLE4_CURRENT_FH: + return out << "CURRENT_FH"; + case secinfo_style4::SECINFO_STYLE4_PARENT: + return out << "PARENT"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const SEQUENCE4args& obj) +{ + out << "sessionid: " << obj.sa_sessionid + << " sequenceid: 0x" << obj.sa_sequenceid + << " slotid: " << obj.sa_slotid + << " cache this: " << obj.sa_cachethis; + return out; +} + +std::ostream& operator<<(std::ostream& out, const SEQUENCE4resok& obj) +{ + out << "session: " << obj.sr_sessionid + << " sequenceid: 0x" << obj.sr_sequenceid + << " slotid: " << obj.sr_slotid + << " highest slotid: " << obj.sr_highest_slotid + << " target highest slotid: " << obj.sr_target_highest_slotid + << " status flags: " << obj.sr_status_flags; + return out; +} + +std::ostream& operator<<(std::ostream& out, const SEQUENCE4res& obj) +{ + out << "status: " << obj.sr_status; + if(obj.sr_status == nfsstat4::NFS4_OK) + { + out << obj.SEQUENCE4res_u.sr_resok4; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const ssa_digest_input4& obj) +{ + return out << obj.sdi_seqargs; +} + +std::ostream& operator<<(std::ostream& out, const ssr_digest_input4& obj) +{ + return out << obj.sdi_seqres; +} + +std::ostream& operator<<(std::ostream& out, const deleg_claim4& obj) +{ + out << "claim: " << obj.dc_claim; + switch(obj.dc_claim) + { + case open_claim_type4::CLAIM_PREVIOUS: + return out << " delegate type: " << obj.deleg_claim4_u.dc_delegate_type; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutrecall_type4& obj) +{ + switch(obj) + { + case layoutrecall_type4::LAYOUTRECALL4_FILE: + return out << "FILE"; + case layoutrecall_type4::LAYOUTRECALL4_FSID: + return out << "FSID"; + case layoutrecall_type4::LAYOUTRECALL4_ALL: + return out << "ALL"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutrecall_file4& obj) +{ + out << "fh: "; + print_nfs_fh(out, + obj.lor_fh.nfs_fh4_val, + obj.lor_fh.nfs_fh4_len); + out << " offset: " << obj.lor_offset; + out << " length: " << obj.lor_length; + out << " stateid: " << obj.lor_stateid; + return out; +} + +std::ostream& operator<<(std::ostream& out, const layoutrecall4& obj) +{ + out << "type: "; + switch(obj.lor_recalltype) + { + case layoutrecall_type4::LAYOUTRECALL4_FILE: + return out << " layout: " << obj.layoutrecall4_u.lor_layout; + case layoutrecall_type4::LAYOUTRECALL4_FSID: + return out << " fsid: " << obj.layoutrecall4_u.lor_fsid; + default: break; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_type4& obj) +{ + switch(obj) + { + case notify_type4::NOTIFY4_CHANGE_CHILD_ATTRS: + return out << "CHANGE_CHILD_ATTRS"; + case notify_type4::NOTIFY4_CHANGE_DIR_ATTRS: + return out << "CHANGE_DIR_ATTRS"; + case notify_type4::NOTIFY4_REMOVE_ENTRY: + return out << "REMOVE_ENTRY"; + case notify_type4::NOTIFY4_ADD_ENTRY: + return out << "ADD_ENTRY"; + case notify_type4::NOTIFY4_RENAME_ENTRY: + return out << "RENAME_ENTRY"; + case notify_type4::NOTIFY4_CHANGE_COOKIE_VERIFIER: + return out << "CHANGE_COOKIE_VERIFIER"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_entry4& obj) +{ + out << "file: " << obj.ne_file + << " attrs: " << obj.ne_attrs; + return out; +} + +std::ostream& operator<<(std::ostream& out, const prev_entry4& obj) +{ + out << "prev entry: " << obj.pe_prev_entry + << " prev entry cookie: " << obj.pe_prev_entry_cookie; + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_remove4& obj) +{ + out << "old entry: " << obj.nrm_old_entry + << " old entry cookie: " << obj.nrm_old_entry_cookie; + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_add4& obj) +{ + out << "old entries: "; + notify_remove4 *current_el = obj.nad_old_entry.nad_old_entry_val; + for(size_t i {0}; i<obj.nad_old_entry.nad_old_entry_len; i++,current_el++) + { + out << ' ' << current_el; + } + out << " new entry: " << obj.nad_new_entry + << " new entry cookie:"; + nfs_cookie4 *current_el2 = obj.nad_new_entry_cookie.nad_new_entry_cookie_val; + for(size_t i {0}; i<obj.nad_new_entry_cookie.nad_new_entry_cookie_len; i++,current_el2++) + { + out << ' ' << current_el2; + } + out << " prev entry:"; + prev_entry4 *current_el3 = obj.nad_prev_entry.nad_prev_entry_val; + for(size_t i {0}; i<obj.nad_prev_entry.nad_prev_entry_len; i++,current_el3++) + { + out << ' ' << current_el3; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_attr4& obj) +{ + return out << "changed entry: " << obj.na_changed_entry; +} + +std::ostream& operator<<(std::ostream& out, const notify_rename4& obj) +{ + return out << "old entry: " << obj.nrn_old_entry + << " new entry: " << obj.nrn_new_entry; +} + +std::ostream& operator<<(std::ostream& out, const notify_verifier4& obj) +{ + return out << "old cookieverf: " << obj.nv_old_cookieverf + << " new cookieverf: " << obj.nv_new_cookieverf; +} + +std::ostream& operator<<(std::ostream& out, const notifylist4& obj) +{ + return out.write(obj.notifylist4_val, + obj.notifylist4_len); +} + +std::ostream& operator<<(std::ostream& out, const notify4& obj) +{ + return out << "mask: " << obj.notify_mask + << " vals: " << obj.notify_vals; +} + +std::ostream& operator<<(std::ostream& out, const referring_call4& obj) +{ + return out << "sequenceid: 0x" << std::hex << obj.rc_sequenceid << std::dec + << " slotid: " << obj.rc_slotid; +} + +std::ostream& operator<<(std::ostream& out, const referring_call_list4& obj) +{ + out << "sessionid: "; + print_hex(out, + obj.rcl_sessionid, + NFS4_SESSIONID_SIZE); + out << " referring calls:"; + referring_call4 *current_el = obj.rcl_referring_calls.rcl_referring_calls_val; + for(size_t i {0}; i<obj.rcl_referring_calls.rcl_referring_calls_len; i++,current_el++) + { + out << ' ' << current_el; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_deviceid_type4& obj) +{ + switch(obj) + { + case notify_deviceid_type4::NOTIFY_DEVICEID4_CHANGE: + return out << "CHANGE"; + case notify_deviceid_type4::NOTIFY_DEVICEID4_DELETE: + return out << "DELETE"; + } + return out; +} + +std::ostream& operator<<(std::ostream& out, const notify_deviceid_delete4& obj) +{ + return out << "layout type: " << obj.ndd_layouttype + << " deviceid: " << obj.ndd_deviceid; +} + +std::ostream& operator<<(std::ostream& out, const notify_deviceid_change4& obj) +{ + return out << "layout type: " << obj.ndc_layouttype + << " deviceid: " << obj.ndc_deviceid + << " immediate: " << obj.ndc_immediate; +} + +bool_t +xdr_nfs_ftype4 (XDR* xdrs, nfs_ftype4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfsstat4 (XDR* xdrs, nfsstat4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_attrlist4 (XDR* xdrs, attrlist4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->attrlist4_val, (u_int*) &objp->attrlist4_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_bitmap4 (XDR* xdrs, bitmap4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->bitmap4_val, (u_int*) &objp->bitmap4_len, ~0, + sizeof (uint32_t), (xdrproc_t) xdr_uint32_t)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_changeid4 (XDR* xdrs, changeid4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_clientid4 (XDR* xdrs, clientid4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_count4 (XDR* xdrs, count4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_length4 (XDR* xdrs, length4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_mode4 (XDR* xdrs, mode4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cookie4 (XDR* xdrs, nfs_cookie4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_fh4 (XDR* xdrs, nfs_fh4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->nfs_fh4_val, (u_int*) &objp->nfs_fh4_len, NFS4_FHSIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_offset4 (XDR* xdrs, offset4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_qop4 (XDR* xdrs, qop4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_sec_oid4 (XDR* xdrs, sec_oid4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->sec_oid4_val, (u_int*) &objp->sec_oid4_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_sequenceid4 (XDR* xdrs, sequenceid4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_seqid4 (XDR* xdrs, seqid4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_sessionid4 (XDR* xdrs, sessionid4 objp) +{ + if (!xdr_opaque (xdrs, objp, NFS4_SESSIONID_SIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_slotid4 (XDR* xdrs, slotid4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8string (XDR* xdrs, utf8string* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->utf8string_val, (u_int*) &objp->utf8string_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8str_cis (XDR* xdrs, utf8str_cis* objp) +{ + if (!xdr_utf8string (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8str_cs (XDR* xdrs, utf8str_cs* objp) +{ + if (!xdr_utf8string (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8str_mixed (XDR* xdrs, utf8str_mixed* objp) +{ + if (!xdr_utf8string (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_component4 (XDR* xdrs, component4* objp) +{ + if (!xdr_utf8str_cs (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_linktext4 (XDR* xdrs, linktext4* objp) +{ + if (!xdr_utf8str_cs (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_pathname4 (XDR* xdrs, pathname4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->pathname4_val, (u_int*) &objp->pathname4_len, ~0, + sizeof (component4), (xdrproc_t) xdr_component4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_verifier4 (XDR* xdrs, verifier4 objp) +{ + if (!xdr_opaque (xdrs, objp, NFS4_VERIFIER_SIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfstime4 (XDR* xdrs, nfstime4* objp) +{ + if (!xdr_int64_t (xdrs, &objp->seconds)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->nseconds)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_time_how4 (XDR* xdrs, time_how4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_settime4 (XDR* xdrs, settime4* objp) +{ + if (!xdr_time_how4 (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case SET_TO_CLIENT_TIME4: + if (!xdr_nfstime4 (xdrs, &objp->settime4_u.time)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_nfs_lease4 (XDR* xdrs, nfs_lease4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fsid4 (XDR* xdrs, fsid4* objp) +{ + if (!xdr_uint64_t (xdrs, &objp->major)) + { + return FALSE; + } + if (!xdr_uint64_t (xdrs, &objp->minor)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_change_policy4 (XDR* xdrs, change_policy4* objp) +{ + if (!xdr_uint64_t (xdrs, &objp->cp_major)) + { + return FALSE; + } + if (!xdr_uint64_t (xdrs, &objp->cp_minor)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_location4 (XDR* xdrs, fs_location4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->server.server_val, (u_int*) &objp->server.server_len, ~0, + sizeof (utf8str_cis), (xdrproc_t) xdr_utf8str_cis)) + { + return FALSE; + } + if (!xdr_pathname4 (xdrs, &objp->rootpath)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_locations4 (XDR* xdrs, fs_locations4* objp) +{ + if (!xdr_pathname4 (xdrs, &objp->fs_root)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->locations.locations_val, (u_int*) &objp->locations.locations_len, ~0, + sizeof (fs_location4), (xdrproc_t) xdr_fs_location4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_acetype4 (XDR* xdrs, acetype4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_aceflag4 (XDR* xdrs, aceflag4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_acemask4 (XDR* xdrs, acemask4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfsace4 (XDR* xdrs, nfsace4* objp) +{ + if (!xdr_acetype4 (xdrs, &objp->type)) + { + return FALSE; + } + if (!xdr_aceflag4 (xdrs, &objp->flag)) + { + return FALSE; + } + if (!xdr_acemask4 (xdrs, &objp->access_mask)) + { + return FALSE; + } + if (!xdr_utf8str_mixed (xdrs, &objp->who)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_aclflag4 (XDR* xdrs, aclflag4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfsacl41 (XDR* xdrs, nfsacl41* objp) +{ + if (!xdr_aclflag4 (xdrs, &objp->na41_flag)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->na41_aces.na41_aces_val, (u_int*) &objp->na41_aces.na41_aces_len, ~0, + sizeof (nfsace4), (xdrproc_t) xdr_nfsace4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_mode_masked4 (XDR* xdrs, mode_masked4* objp) +{ + if (!xdr_mode4 (xdrs, &objp->mm_value_to_set)) + { + return FALSE; + } + if (!xdr_mode4 (xdrs, &objp->mm_mask_bits)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_specdata4 (XDR* xdrs, specdata4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->specdata1)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->specdata2)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_netaddr4 (XDR* xdrs, netaddr4* objp) +{ + if (!xdr_string (xdrs, &objp->na_r_netid, ~0)) + { + return FALSE; + } + if (!xdr_string (xdrs, &objp->na_r_addr, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_impl_id4 (XDR* xdrs, nfs_impl_id4* objp) +{ + if (!xdr_utf8str_cis (xdrs, &objp->nii_domain)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->nii_name)) + { + return FALSE; + } + if (!xdr_nfstime4 (xdrs, &objp->nii_date)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_stateid4 (XDR* xdrs, stateid4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_opaque (xdrs, objp->other, 12)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layouttype4 (XDR* xdrs, layouttype4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layout_content4 (XDR* xdrs, layout_content4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->loc_type)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->loc_body.loc_body_val, (u_int*) &objp->loc_body.loc_body_len, ~0)) + { + return FALSE; + } + return TRUE; +} +/* + * LAYOUT4_OSD2_OBJECTS loc_body description + * is in a separate .x file + */ + +/* + * LAYOUT4_BLOCK_VOLUME loc_body description + * is in a separate .x file + */ + +bool_t +xdr_layouthint4 (XDR* xdrs, layouthint4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->loh_type)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->loh_body.loh_body_val, (u_int*) &objp->loh_body.loh_body_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutiomode4 (XDR* xdrs, layoutiomode4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layout4 (XDR* xdrs, layout4* objp) +{ + if (!xdr_offset4 (xdrs, &objp->lo_offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->lo_length)) + { + return FALSE; + } + if (!xdr_layoutiomode4 (xdrs, &objp->lo_iomode)) + { + return FALSE; + } + if (!xdr_layout_content4 (xdrs, &objp->lo_content)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_deviceid4 (XDR* xdrs, deviceid4 objp) +{ + if (!xdr_opaque (xdrs, objp, NFS4_DEVICEID4_SIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_device_addr4 (XDR* xdrs, device_addr4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->da_layout_type)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->da_addr_body.da_addr_body_val, (u_int*) &objp->da_addr_body.da_addr_body_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutupdate4 (XDR* xdrs, layoutupdate4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->lou_type)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->lou_body.lou_body_val, (u_int*) &objp->lou_body.lou_body_len, ~0)) + { + return FALSE; + } + return TRUE; +} + + + +bool_t +xdr_layoutreturn_type4 (XDR* xdrs, layoutreturn_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} +/* layouttype4 specific data */ + +bool_t +xdr_layoutreturn_file4 (XDR* xdrs, layoutreturn_file4* objp) +{ + if (!xdr_offset4 (xdrs, &objp->lrf_offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->lrf_length)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->lrf_stateid)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->lrf_body.lrf_body_val, (u_int*) &objp->lrf_body.lrf_body_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutreturn4 (XDR* xdrs, layoutreturn4* objp) +{ + if (!xdr_layoutreturn_type4 (xdrs, &objp->lr_returntype)) + { + return FALSE; + } + switch (objp->lr_returntype) + { + case LAYOUTRETURN4_FILE: + if (!xdr_layoutreturn_file4 (xdrs, &objp->layoutreturn4_u.lr_layout)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + + +bool_t +xdr_fs4_status_type (XDR* xdrs, fs4_status_type* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs4_status (XDR* xdrs, fs4_status* objp) +{ + if (!xdr_bool (xdrs, &objp->fss_absent)) + { + return FALSE; + } + if (!xdr_fs4_status_type (xdrs, &objp->fss_type)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->fss_source)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->fss_current)) + { + return FALSE; + } + if (!xdr_int32_t (xdrs, &objp->fss_age)) + { + return FALSE; + } + if (!xdr_nfstime4 (xdrs, &objp->fss_version)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_threshold4_read_size (XDR* xdrs, threshold4_read_size* objp) +{ + if (!xdr_length4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_threshold4_write_size (XDR* xdrs, threshold4_write_size* objp) +{ + if (!xdr_length4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_threshold4_read_iosize (XDR* xdrs, threshold4_read_iosize* objp) +{ + if (!xdr_length4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_threshold4_write_iosize (XDR* xdrs, threshold4_write_iosize* objp) +{ + if (!xdr_length4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_threshold_item4 (XDR* xdrs, threshold_item4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->thi_layout_type)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->thi_hintset)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->thi_hintlist.thi_hintlist_val, (u_int*) &objp->thi_hintlist.thi_hintlist_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_mdsthreshold4 (XDR* xdrs, mdsthreshold4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->mth_hints.mth_hints_val, (u_int*) &objp->mth_hints.mth_hints_len, ~0, + sizeof (threshold_item4), (xdrproc_t) xdr_threshold_item4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_retention_get4 (XDR* xdrs, retention_get4* objp) +{ + if (!xdr_uint64_t (xdrs, &objp->rg_duration)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->rg_begin_time.rg_begin_time_val, (u_int*) &objp->rg_begin_time.rg_begin_time_len, 1, + sizeof (nfstime4), (xdrproc_t) xdr_nfstime4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_retention_set4 (XDR* xdrs, retention_set4* objp) +{ + if (!xdr_bool (xdrs, &objp->rs_enable)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->rs_duration.rs_duration_val, (u_int*) &objp->rs_duration.rs_duration_len, 1, + sizeof (uint64_t), (xdrproc_t) xdr_uint64_t)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_charset_cap4 (XDR* xdrs, fs_charset_cap4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_supported_attrs (XDR* xdrs, fattr4_supported_attrs* objp) +{ + if (!xdr_bitmap4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_type (XDR* xdrs, fattr4_type* objp) +{ + if (!xdr_nfs_ftype4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fh_expire_type (XDR* xdrs, fattr4_fh_expire_type* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_change (XDR* xdrs, fattr4_change* objp) +{ + if (!xdr_changeid4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_size (XDR* xdrs, fattr4_size* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_link_support (XDR* xdrs, fattr4_link_support* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_symlink_support (XDR* xdrs, fattr4_symlink_support* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_named_attr (XDR* xdrs, fattr4_named_attr* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fsid (XDR* xdrs, fattr4_fsid* objp) +{ + if (!xdr_fsid4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_unique_handles (XDR* xdrs, fattr4_unique_handles* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_lease_time (XDR* xdrs, fattr4_lease_time* objp) +{ + if (!xdr_nfs_lease4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_rdattr_error (XDR* xdrs, fattr4_rdattr_error* objp) +{ + if (!xdr_nfsstat4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_acl (XDR* xdrs, fattr4_acl* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->fattr4_acl_val, (u_int*) &objp->fattr4_acl_len, ~0, + sizeof (nfsace4), (xdrproc_t) xdr_nfsace4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_aclsupport (XDR* xdrs, fattr4_aclsupport* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_archive (XDR* xdrs, fattr4_archive* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_cansettime (XDR* xdrs, fattr4_cansettime* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_case_insensitive (XDR* xdrs, fattr4_case_insensitive* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_case_preserving (XDR* xdrs, fattr4_case_preserving* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_chown_restricted (XDR* xdrs, fattr4_chown_restricted* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fileid (XDR* xdrs, fattr4_fileid* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_files_avail (XDR* xdrs, fattr4_files_avail* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_filehandle (XDR* xdrs, fattr4_filehandle* objp) +{ + if (!xdr_nfs_fh4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_files_free (XDR* xdrs, fattr4_files_free* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_files_total (XDR* xdrs, fattr4_files_total* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fs_locations (XDR* xdrs, fattr4_fs_locations* objp) +{ + if (!xdr_fs_locations4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_hidden (XDR* xdrs, fattr4_hidden* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_homogeneous (XDR* xdrs, fattr4_homogeneous* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxfilesize (XDR* xdrs, fattr4_maxfilesize* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxlink (XDR* xdrs, fattr4_maxlink* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxname (XDR* xdrs, fattr4_maxname* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxread (XDR* xdrs, fattr4_maxread* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxwrite (XDR* xdrs, fattr4_maxwrite* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mimetype (XDR* xdrs, fattr4_mimetype* objp) +{ + if (!xdr_utf8str_cs (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mode (XDR* xdrs, fattr4_mode* objp) +{ + if (!xdr_mode4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mode_set_masked (XDR* xdrs, fattr4_mode_set_masked* objp) +{ + if (!xdr_mode_masked4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mounted_on_fileid (XDR* xdrs, fattr4_mounted_on_fileid* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_no_trunc (XDR* xdrs, fattr4_no_trunc* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_numlinks (XDR* xdrs, fattr4_numlinks* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_owner (XDR* xdrs, fattr4_owner* objp) +{ + if (!xdr_utf8str_mixed (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_owner_group (XDR* xdrs, fattr4_owner_group* objp) +{ + if (!xdr_utf8str_mixed (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_quota_avail_hard (XDR* xdrs, fattr4_quota_avail_hard* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_quota_avail_soft (XDR* xdrs, fattr4_quota_avail_soft* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_quota_used (XDR* xdrs, fattr4_quota_used* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_rawdev (XDR* xdrs, fattr4_rawdev* objp) +{ + if (!xdr_specdata4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_avail (XDR* xdrs, fattr4_space_avail* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_free (XDR* xdrs, fattr4_space_free* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_total (XDR* xdrs, fattr4_space_total* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_used (XDR* xdrs, fattr4_space_used* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_system (XDR* xdrs, fattr4_system* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_access (XDR* xdrs, fattr4_time_access* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_access_set (XDR* xdrs, fattr4_time_access_set* objp) +{ + if (!xdr_settime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_backup (XDR* xdrs, fattr4_time_backup* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_create (XDR* xdrs, fattr4_time_create* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_delta (XDR* xdrs, fattr4_time_delta* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_metadata (XDR* xdrs, fattr4_time_metadata* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_modify (XDR* xdrs, fattr4_time_modify* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_modify_set (XDR* xdrs, fattr4_time_modify_set* objp) +{ + if (!xdr_settime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_suppattr_exclcreat (XDR* xdrs, fattr4_suppattr_exclcreat* objp) +{ + if (!xdr_bitmap4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_dir_notif_delay (XDR* xdrs, fattr4_dir_notif_delay* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_dirent_notif_delay (XDR* xdrs, fattr4_dirent_notif_delay* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fs_layout_types (XDR* xdrs, fattr4_fs_layout_types* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->fattr4_fs_layout_types_val, (u_int*) &objp->fattr4_fs_layout_types_len, ~0, + sizeof (layouttype4), (xdrproc_t) xdr_layouttype4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fs_status (XDR* xdrs, fattr4_fs_status* objp) +{ + if (!xdr_fs4_status (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fs_charset_cap (XDR* xdrs, fattr4_fs_charset_cap* objp) +{ + if (!xdr_fs_charset_cap4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_layout_alignment (XDR* xdrs, fattr4_layout_alignment* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_layout_blksize (XDR* xdrs, fattr4_layout_blksize* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_layout_hint (XDR* xdrs, fattr4_layout_hint* objp) +{ + if (!xdr_layouthint4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_layout_types (XDR* xdrs, fattr4_layout_types* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->fattr4_layout_types_val, (u_int*) &objp->fattr4_layout_types_len, ~0, + sizeof (layouttype4), (xdrproc_t) xdr_layouttype4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mdsthreshold (XDR* xdrs, fattr4_mdsthreshold* objp) +{ + if (!xdr_mdsthreshold4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_retention_get (XDR* xdrs, fattr4_retention_get* objp) +{ + if (!xdr_retention_get4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_retention_set (XDR* xdrs, fattr4_retention_set* objp) +{ + if (!xdr_retention_set4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_retentevt_get (XDR* xdrs, fattr4_retentevt_get* objp) +{ + if (!xdr_retention_get4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_retentevt_set (XDR* xdrs, fattr4_retentevt_set* objp) +{ + if (!xdr_retention_set4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_retention_hold (XDR* xdrs, fattr4_retention_hold* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_dacl (XDR* xdrs, fattr4_dacl* objp) +{ + if (!xdr_nfsacl41 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_sacl (XDR* xdrs, fattr4_sacl* objp) +{ + if (!xdr_nfsacl41 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_change_policy (XDR* xdrs, fattr4_change_policy* objp) +{ + if (!xdr_change_policy4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} +/* + * REQUIRED Attributes + */ +/* new to NFSV4.1 */ +/* + * RECOMMENDED Attributes + */ + +/* new to NFSV4.1 */ + + +bool_t +xdr_fattr4 (XDR* xdrs, fattr4* objp) +{ + if (!xdr_bitmap4 (xdrs, &objp->attrmask)) + { + return FALSE; + } + if (!xdr_attrlist4 (xdrs, &objp->attr_vals)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_change_info4 (XDR* xdrs, change_info4* objp) +{ + if (!xdr_bool (xdrs, &objp->atomic)) + { + return FALSE; + } + if (!xdr_changeid4 (xdrs, &objp->before)) + { + return FALSE; + } + if (!xdr_changeid4 (xdrs, &objp->after)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_clientaddr4 (XDR* xdrs, clientaddr4* objp) +{ + if (!xdr_netaddr4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_cb_client4 (XDR* xdrs, cb_client4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->cb_program)) + { + return FALSE; + } + if (!xdr_netaddr4 (xdrs, &objp->cb_location)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_client_id4 (XDR* xdrs, nfs_client_id4* objp) +{ + if (!xdr_verifier4 (xdrs, objp->verifier)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->id.id_val, (u_int*) &objp->id.id_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_client_owner4 (XDR* xdrs, client_owner4* objp) +{ + if (!xdr_verifier4 (xdrs, objp->co_verifier)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->co_ownerid.co_ownerid_val, (u_int*) &objp->co_ownerid.co_ownerid_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_server_owner4 (XDR* xdrs, server_owner4* objp) +{ + if (!xdr_uint64_t (xdrs, &objp->so_minor_id)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->so_major_id.so_major_id_val, (u_int*) &objp->so_major_id.so_major_id_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_state_owner4 (XDR* xdrs, state_owner4* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->owner.owner_val, (u_int*) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_owner4 (XDR* xdrs, open_owner4* objp) +{ + if (!xdr_state_owner4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_lock_owner4 (XDR* xdrs, lock_owner4* objp) +{ + if (!xdr_state_owner4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_lock_type4 (XDR* xdrs, nfs_lock_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +/* Input for computing subkeys */ + +bool_t +xdr_ssv_subkey4 (XDR* xdrs, ssv_subkey4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + + +/* Input for computing smt_hmac */ + +bool_t +xdr_ssv_mic_plain_tkn4 (XDR* xdrs, ssv_mic_plain_tkn4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->smpt_ssv_seq)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->smpt_orig_plain.smpt_orig_plain_val, (u_int*) &objp->smpt_orig_plain.smpt_orig_plain_len, ~0)) + { + return FALSE; + } + return TRUE; +} + + +/* SSV GSS PerMsgToken token */ + +bool_t +xdr_ssv_mic_tkn4 (XDR* xdrs, ssv_mic_tkn4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->smt_ssv_seq)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->smt_hmac.smt_hmac_val, (u_int*) &objp->smt_hmac.smt_hmac_len, ~0)) + { + return FALSE; + } + return TRUE; +} + + +/* Input for computing ssct_encr_data and ssct_hmac */ + +bool_t +xdr_ssv_seal_plain_tkn4 (XDR* xdrs, ssv_seal_plain_tkn4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->sspt_confounder.sspt_confounder_val, (u_int*) &objp->sspt_confounder.sspt_confounder_len, ~0)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->sspt_ssv_seq)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->sspt_orig_plain.sspt_orig_plain_val, (u_int*) &objp->sspt_orig_plain.sspt_orig_plain_len, ~0)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->sspt_pad.sspt_pad_val, (u_int*) &objp->sspt_pad.sspt_pad_len, ~0)) + { + return FALSE; + } + return TRUE; +} + + +/* SSV GSS SealedMessage token */ + +bool_t +xdr_ssv_seal_cipher_tkn4 (XDR* xdrs, ssv_seal_cipher_tkn4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->ssct_ssv_seq)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->ssct_iv.ssct_iv_val, (u_int*) &objp->ssct_iv.ssct_iv_len, ~0)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->ssct_encr_data.ssct_encr_data_val, (u_int*) &objp->ssct_encr_data.ssct_encr_data_len, ~0)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->ssct_hmac.ssct_hmac_val, (u_int*) &objp->ssct_hmac.ssct_hmac_len, ~0)) + { + return FALSE; + } + return TRUE; +} + + +bool_t +xdr_fs_locations_server4 (XDR* xdrs, fs_locations_server4* objp) +{ + if (!xdr_int32_t (xdrs, &objp->fls_currency)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->fls_info.fls_info_val, (u_int*) &objp->fls_info.fls_info_len, ~0)) + { + return FALSE; + } + if (!xdr_utf8str_cis (xdrs, &objp->fls_server)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_locations_item4 (XDR* xdrs, fs_locations_item4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->fli_entries.fli_entries_val, (u_int*) &objp->fli_entries.fli_entries_len, ~0, + sizeof (fs_locations_server4), (xdrproc_t) xdr_fs_locations_server4)) + { + return FALSE; + } + if (!xdr_pathname4 (xdrs, &objp->fli_rootpath)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_locations_info4 (XDR* xdrs, fs_locations_info4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->fli_flags)) + { + return FALSE; + } + if (!xdr_int32_t (xdrs, &objp->fli_valid_for)) + { + return FALSE; + } + if (!xdr_pathname4 (xdrs, &objp->fli_fs_root)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->fli_items.fli_items_val, (u_int*) &objp->fli_items.fli_items_len, ~0, + sizeof (fs_locations_item4), (xdrproc_t) xdr_fs_locations_item4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fs_locations_info (XDR* xdrs, fattr4_fs_locations_info* objp) +{ + if (!xdr_fs_locations_info4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfl_util4 (XDR* xdrs, nfl_util4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + + +bool_t +xdr_filelayout_hint_care4 (XDR* xdrs, filelayout_hint_care4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +/* Encoded in the loh_body field of data type layouthint4: */ + + +bool_t +xdr_nfsv4_1_file_layouthint4 (XDR* xdrs, nfsv4_1_file_layouthint4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->nflh_care)) + { + return FALSE; + } + if (!xdr_nfl_util4 (xdrs, &objp->nflh_util)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->nflh_stripe_count)) + { + return FALSE; + } + return TRUE; +} + + + +bool_t +xdr_multipath_list4 (XDR* xdrs, multipath_list4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->multipath_list4_val, (u_int*) &objp->multipath_list4_len, ~0, + sizeof (netaddr4), (xdrproc_t) xdr_netaddr4)) + { + return FALSE; + } + return TRUE; +} + +/* + * Encoded in the da_addr_body field of + * data type device_addr4: + */ + +bool_t +xdr_nfsv4_1_file_layout_ds_addr4 (XDR* xdrs, nfsv4_1_file_layout_ds_addr4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->nflda_stripe_indices.nflda_stripe_indices_val, (u_int*) &objp->nflda_stripe_indices.nflda_stripe_indices_len, ~0, + sizeof (uint32_t), (xdrproc_t) xdr_uint32_t)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->nflda_multipath_ds_list.nflda_multipath_ds_list_val, (u_int*) &objp->nflda_multipath_ds_list.nflda_multipath_ds_list_len, ~0, + sizeof (multipath_list4), (xdrproc_t) xdr_multipath_list4)) + { + return FALSE; + } + return TRUE; +} + + +/* + * Encoded in the loc_body field of + * data type layout_content4: + */ + +bool_t +xdr_nfsv4_1_file_layout4 (XDR* xdrs, nfsv4_1_file_layout4* objp) +{ + if (!xdr_deviceid4 (xdrs, objp->nfl_deviceid)) + { + return FALSE; + } + if (!xdr_nfl_util4 (xdrs, &objp->nfl_util)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->nfl_first_stripe_index)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->nfl_pattern_offset)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->nfl_fh_list.nfl_fh_list_val, (u_int*) &objp->nfl_fh_list.nfl_fh_list_len, ~0, + sizeof (nfs_fh4), (xdrproc_t) xdr_nfs_fh4)) + { + return FALSE; + } + return TRUE; +} + +/* + * Encoded in the lou_body field of data type layoutupdate4: + * Nothing. lou_body is a zero length array of bytes. + */ + +/* + * Encoded in the lrf_body field of + * data type layoutreturn_file4: + * Nothing. lrf_body is a zero length array of bytes. + */ + +//for compatibility +bool_t +xdr_NULL4args(XDR*, NULL4args*) +{ + return TRUE; +} + +bool_t +xdr_NULL4res(XDR*, NULL4res*) +{ + return TRUE; +} + +bool_t +xdr_ACCESS4args (XDR* xdrs, ACCESS4args* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->access)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS4resok (XDR* xdrs, ACCESS4resok* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->supported)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->access)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS4res (XDR* xdrs, ACCESS4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_ACCESS4resok (xdrs, &objp->ACCESS4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CLOSE4args (XDR* xdrs, CLOSE4args* objp) +{ + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CLOSE4res (XDR* xdrs, CLOSE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_stateid4 (xdrs, &objp->CLOSE4res_u.open_stateid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_COMMIT4args (XDR* xdrs, COMMIT4args* objp) +{ + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT4resok (XDR* xdrs, COMMIT4resok* objp) +{ + if (!xdr_verifier4 (xdrs, objp->writeverf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT4res (XDR* xdrs, COMMIT4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_COMMIT4resok (xdrs, &objp->COMMIT4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_createtype4 (XDR* xdrs, createtype4* objp) +{ + if (!xdr_nfs_ftype4 (xdrs, &objp->type)) + { + return FALSE; + } + switch (objp->type) + { + case NF4LNK: + if (!xdr_linktext4 (xdrs, &objp->createtype4_u.linkdata)) + { + return FALSE; + } + break; + case NF4BLK: + case NF4CHR: + if (!xdr_specdata4 (xdrs, &objp->createtype4_u.devdata)) + { + return FALSE; + } + break; + case NF4SOCK: + case NF4FIFO: + case NF4DIR: + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CREATE4args (XDR* xdrs, CREATE4args* objp) +{ + if (!xdr_createtype4 (xdrs, &objp->objtype)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->objname)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->createattrs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE4resok (XDR* xdrs, CREATE4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attrset)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE4res (XDR* xdrs, CREATE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_CREATE4resok (xdrs, &objp->CREATE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_DELEGPURGE4args (XDR* xdrs, DELEGPURGE4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DELEGPURGE4res (XDR* xdrs, DELEGPURGE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DELEGRETURN4args (XDR* xdrs, DELEGRETURN4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->deleg_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DELEGRETURN4res (XDR* xdrs, DELEGRETURN4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR4args (XDR* xdrs, GETATTR4args* objp) +{ + if (!xdr_bitmap4 (xdrs, &objp->attr_request)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR4resok (XDR* xdrs, GETATTR4resok* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR4res (XDR* xdrs, GETATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_GETATTR4resok (xdrs, &objp->GETATTR4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_GETFH4resok (XDR* xdrs, GETFH4resok* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETFH4res (XDR* xdrs, GETFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_GETFH4resok (xdrs, &objp->GETFH4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LINK4args (XDR* xdrs, LINK4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->newname)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK4resok (XDR* xdrs, LINK4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK4res (XDR* xdrs, LINK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_LINK4resok (xdrs, &objp->LINK4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_open_to_lock_owner4 (XDR* xdrs, open_to_lock_owner4* objp) +{ + if (!xdr_seqid4 (xdrs, &objp->open_seqid)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->lock_seqid)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->lock_owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_exist_lock_owner4 (XDR* xdrs, exist_lock_owner4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->lock_seqid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_locker4 (XDR* xdrs, locker4* objp) +{ + if (!xdr_bool (xdrs, &objp->new_lock_owner)) + { + return FALSE; + } + switch (objp->new_lock_owner) + { + case TRUE: + if (!xdr_open_to_lock_owner4 (xdrs, &objp->locker4_u.open_owner)) + { + return FALSE; + } + break; + case FALSE: + if (!xdr_exist_lock_owner4 (xdrs, &objp->locker4_u.lock_owner)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4args (XDR* xdrs, LOCK4args* objp) +{ + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->reclaim)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + if (!xdr_locker4 (xdrs, &objp->locker)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4denied (XDR* xdrs, LOCK4denied* objp) +{ + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4resok (XDR* xdrs, LOCK4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4res (XDR* xdrs, LOCK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_LOCK4resok (xdrs, &objp->LOCK4res_u.resok4)) + { + return FALSE; + } + break; + case NFS4ERR_DENIED: + if (!xdr_LOCK4denied (xdrs, &objp->LOCK4res_u.denied)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LOCKT4args (XDR* xdrs, LOCKT4args* objp) +{ + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCKT4res (XDR* xdrs, LOCKT4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4ERR_DENIED: + if (!xdr_LOCK4denied (xdrs, &objp->LOCKT4res_u.denied)) + { + return FALSE; + } + break; + case NFS4_OK: + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LOCKU4args (XDR* xdrs, LOCKU4args* objp) +{ + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCKU4res (XDR* xdrs, LOCKU4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_stateid4 (xdrs, &objp->LOCKU4res_u.lock_stateid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LOOKUP4args (XDR* xdrs, LOOKUP4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->objname)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUP4res (XDR* xdrs, LOOKUP4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUPP4res (XDR* xdrs, LOOKUPP4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_NVERIFY4args (XDR* xdrs, NVERIFY4args* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_NVERIFY4res (XDR* xdrs, NVERIFY4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_createmode4 (XDR* xdrs, createmode4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_creatverfattr (XDR* xdrs, creatverfattr* objp) +{ + if (!xdr_verifier4 (xdrs, objp->cva_verf)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->cva_attrs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_createhow4 (XDR* xdrs, createhow4* objp) +{ + if (!xdr_createmode4 (xdrs, &objp->mode)) + { + return FALSE; + } + switch (objp->mode) + { + case UNCHECKED4: + case GUARDED4: + if (!xdr_fattr4 (xdrs, &objp->createhow4_u.createattrs)) + { + return FALSE; + } + break; + case EXCLUSIVE4: + if (!xdr_verifier4 (xdrs, objp->createhow4_u.createverf)) + { + return FALSE; + } + break; + case EXCLUSIVE4_1: + if (!xdr_creatverfattr (xdrs, &objp->createhow4_u.ch_createboth)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_opentype4 (XDR* xdrs, opentype4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_openflag4 (XDR* xdrs, openflag4* objp) +{ + if (!xdr_opentype4 (xdrs, &objp->opentype)) + { + return FALSE; + } + switch (objp->opentype) + { + case OPEN4_CREATE: + if (!xdr_createhow4 (xdrs, &objp->openflag4_u.how)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_limit_by4 (XDR* xdrs, limit_by4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_modified_limit4 (XDR* xdrs, nfs_modified_limit4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->num_blocks)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->bytes_per_block)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_space_limit4 (XDR* xdrs, nfs_space_limit4* objp) +{ + if (!xdr_limit_by4 (xdrs, &objp->limitby)) + { + return FALSE; + } + switch (objp->limitby) + { + case NFS_LIMIT_SIZE: + if (!xdr_uint64_t (xdrs, &objp->nfs_space_limit4_u.filesize)) + { + return FALSE; + } + break; + case NFS_LIMIT_BLOCKS: + if (!xdr_nfs_modified_limit4 (xdrs, &objp->nfs_space_limit4_u.mod_blocks)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_delegation_type4 (XDR* xdrs, open_delegation_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_claim_type4 (XDR* xdrs, open_claim_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_claim_delegate_cur4 (XDR* xdrs, open_claim_delegate_cur4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->delegate_stateid)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->file)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_claim4 (XDR* xdrs, open_claim4* objp) +{ + if (!xdr_open_claim_type4 (xdrs, &objp->claim)) + { + return FALSE; + } + switch (objp->claim) + { + case CLAIM_NULL: + if (!xdr_component4 (xdrs, &objp->open_claim4_u.file)) + { + return FALSE; + } + break; + case CLAIM_PREVIOUS: + if (!xdr_open_delegation_type4 (xdrs, &objp->open_claim4_u.delegate_type)) + { + return FALSE; + } + break; + case CLAIM_DELEGATE_CUR: + if (!xdr_open_claim_delegate_cur4 (xdrs, &objp->open_claim4_u.delegate_cur_info)) + { + return FALSE; + } + break; + case CLAIM_DELEGATE_PREV: + if (!xdr_component4 (xdrs, &objp->open_claim4_u.file_delegate_prev)) + { + return FALSE; + } + break; + case CLAIM_FH: + break; + case CLAIM_DELEG_PREV_FH: + break; + case CLAIM_DELEG_CUR_FH: + if (!xdr_stateid4 (xdrs, &objp->open_claim4_u.oc_delegate_stateid)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN4args (XDR* xdrs, OPEN4args* objp) +{ + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_access)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_deny)) + { + return FALSE; + } + if (!xdr_open_owner4 (xdrs, &objp->owner)) + { + return FALSE; + } + if (!xdr_openflag4 (xdrs, &objp->openhow)) + { + return FALSE; + } + if (!xdr_open_claim4 (xdrs, &objp->claim)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_read_delegation4 (XDR* xdrs, open_read_delegation4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->recall)) + { + return FALSE; + } + if (!xdr_nfsace4 (xdrs, &objp->permissions)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_write_delegation4 (XDR* xdrs, open_write_delegation4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->recall)) + { + return FALSE; + } + if (!xdr_nfs_space_limit4 (xdrs, &objp->space_limit)) + { + return FALSE; + } + if (!xdr_nfsace4 (xdrs, &objp->permissions)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_why_no_delegation4 (XDR* xdrs, why_no_delegation4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_none_delegation4 (XDR* xdrs, open_none_delegation4* objp) +{ + if (!xdr_why_no_delegation4 (xdrs, &objp->ond_why)) + { + return FALSE; + } + switch (objp->ond_why) + { + case WND4_CONTENTION: + if (!xdr_bool (xdrs, &objp->open_none_delegation4_u.ond_server_will_push_deleg)) + { + return FALSE; + } + break; + case WND4_RESOURCE: + if (!xdr_bool (xdrs, &objp->open_none_delegation4_u.ond_server_will_signal_avail)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_open_delegation4 (XDR* xdrs, open_delegation4* objp) +{ + if (!xdr_open_delegation_type4 (xdrs, &objp->delegation_type)) + { + return FALSE; + } + switch (objp->delegation_type) + { + case OPEN_DELEGATE_NONE: + break; + case OPEN_DELEGATE_READ: + if (!xdr_open_read_delegation4 (xdrs, &objp->open_delegation4_u.read)) + { + return FALSE; + } + break; + case OPEN_DELEGATE_WRITE: + if (!xdr_open_write_delegation4 (xdrs, &objp->open_delegation4_u.write)) + { + return FALSE; + } + break; + case OPEN_DELEGATE_NONE_EXT: + if (!xdr_open_none_delegation4 (xdrs, &objp->open_delegation4_u.od_whynone)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN4resok (XDR* xdrs, OPEN4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->rflags)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attrset)) + { + return FALSE; + } + if (!xdr_open_delegation4 (xdrs, &objp->delegation)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN4res (XDR* xdrs, OPEN4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_OPEN4resok (xdrs, &objp->OPEN4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_OPENATTR4args (XDR* xdrs, OPENATTR4args* objp) +{ + if (!xdr_bool (xdrs, &objp->createdir)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPENATTR4res (XDR* xdrs, OPENATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_CONFIRM4args (XDR* xdrs, OPEN_CONFIRM4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_CONFIRM4resok (XDR* xdrs, OPEN_CONFIRM4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_CONFIRM4res (XDR* xdrs, OPEN_CONFIRM4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_OPEN_CONFIRM4resok (xdrs, &objp->OPEN_CONFIRM4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_OPEN_DOWNGRADE4args (XDR* xdrs, OPEN_DOWNGRADE4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_access)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_deny)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_DOWNGRADE4resok (XDR* xdrs, OPEN_DOWNGRADE4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_DOWNGRADE4res (XDR* xdrs, OPEN_DOWNGRADE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_OPEN_DOWNGRADE4resok (xdrs, &objp->OPEN_DOWNGRADE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_PUTFH4args (XDR* xdrs, PUTFH4args* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PUTFH4res (XDR* xdrs, PUTFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PUTPUBFH4res (XDR* xdrs, PUTPUBFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PUTROOTFH4res (XDR* xdrs, PUTROOTFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ4args (XDR* xdrs, READ4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ4resok (XDR* xdrs, READ4resok* objp) +{ + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->data.data_val, (u_int*) &objp->data.data_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ4res (XDR* xdrs, READ4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_READ4resok (xdrs, &objp->READ4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_READDIR4args (XDR* xdrs, READDIR4args* objp) +{ + if (!xdr_nfs_cookie4 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->dircount)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->maxcount)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attr_request)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_entry4 (XDR* xdrs, entry4* objp) +{ + if (!xdr_nfs_cookie4 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->name)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->attrs)) + { + return FALSE; + } + if (!xdr_pointer (xdrs, (char**)&objp->nextentry, sizeof (entry4), (xdrproc_t) xdr_entry4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_dirlist4 (XDR* xdrs, dirlist4* objp) +{ + if (!xdr_pointer (xdrs, (char**)&objp->entries, sizeof (entry4), (xdrproc_t) xdr_entry4)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR4resok (XDR* xdrs, READDIR4resok* objp) +{ + if (!xdr_verifier4 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_dirlist4 (xdrs, &objp->reply)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR4res (XDR* xdrs, READDIR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_READDIR4resok (xdrs, &objp->READDIR4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_READLINK4resok (XDR* xdrs, READLINK4resok* objp) +{ + if (!xdr_linktext4 (xdrs, &objp->link)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READLINK4res (XDR* xdrs, READLINK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_READLINK4resok (xdrs, &objp->READLINK4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_REMOVE4args (XDR* xdrs, REMOVE4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->target)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE4resok (XDR* xdrs, REMOVE4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE4res (XDR* xdrs, REMOVE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_REMOVE4resok (xdrs, &objp->REMOVE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_RENAME4args (XDR* xdrs, RENAME4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->oldname)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->newname)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME4resok (XDR* xdrs, RENAME4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->source_cinfo)) + { + return FALSE; + } + if (!xdr_change_info4 (xdrs, &objp->target_cinfo)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME4res (XDR* xdrs, RENAME4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_RENAME4resok (xdrs, &objp->RENAME4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_RENEW4args (XDR* xdrs, RENEW4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENEW4res (XDR* xdrs, RENEW4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RESTOREFH4res (XDR* xdrs, RESTOREFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SAVEFH4res (XDR* xdrs, SAVEFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SECINFO4args (XDR* xdrs, SECINFO4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->name)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_rpc_gss_svc_t (XDR* xdrs, rpc_gss_svc_t* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_rpcsec_gss_info (XDR* xdrs, rpcsec_gss_info* objp) +{ + if (!xdr_sec_oid4 (xdrs, &objp->oid)) + { + return FALSE; + } + if (!xdr_qop4 (xdrs, &objp->qop)) + { + return FALSE; + } + if (!xdr_rpc_gss_svc_t (xdrs, &objp->service)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_secinfo4 (XDR* xdrs, secinfo4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->flavor)) + { + return FALSE; + } + switch (objp->flavor) + { + case RPCSEC_GSS: + if (!xdr_rpcsec_gss_info (xdrs, &objp->secinfo4_u.flavor_info)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_SECINFO4resok (XDR* xdrs, SECINFO4resok* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->SECINFO4resok_val, (u_int*) &objp->SECINFO4resok_len, ~0, + sizeof (secinfo4), (xdrproc_t) xdr_secinfo4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SECINFO4res (XDR* xdrs, SECINFO4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_SECINFO4resok (xdrs, &objp->SECINFO4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_SETATTR4args (XDR* xdrs, SETATTR4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETATTR4res (XDR* xdrs, SETATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attrsset)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID4args (XDR* xdrs, SETCLIENTID4args* objp) +{ + if (!xdr_nfs_client_id4 (xdrs, &objp->client)) + { + return FALSE; + } + if (!xdr_cb_client4 (xdrs, &objp->callback)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->callback_ident)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID4resok (XDR* xdrs, SETCLIENTID4resok* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->setclientid_confirm)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID4res (XDR* xdrs, SETCLIENTID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_SETCLIENTID4resok (xdrs, &objp->SETCLIENTID4res_u.resok4)) + { + return FALSE; + } + break; + case NFS4ERR_CLID_INUSE: + if (!xdr_clientaddr4 (xdrs, &objp->SETCLIENTID4res_u.client_using)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID_CONFIRM4args (XDR* xdrs, SETCLIENTID_CONFIRM4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->setclientid_confirm)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID_CONFIRM4res (XDR* xdrs, SETCLIENTID_CONFIRM4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_VERIFY4args (XDR* xdrs, VERIFY4args* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_VERIFY4res (XDR* xdrs, VERIFY4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_stable_how4 (XDR* xdrs, stable_how4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE4args (XDR* xdrs, WRITE4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_stable_how4 (xdrs, &objp->stable)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->data.data_val, (u_int*) &objp->data.data_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE4resok (XDR* xdrs, WRITE4resok* objp) +{ + if (!xdr_count4 (xdrs, &objp->count)) + { + return FALSE; + } + if (!xdr_stable_how4 (xdrs, &objp->committed)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->writeverf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE4res (XDR* xdrs, WRITE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_WRITE4resok (xdrs, &objp->WRITE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_RELEASE_LOCKOWNER4args (XDR* xdrs, RELEASE_LOCKOWNER4args* objp) +{ + if (!xdr_lock_owner4 (xdrs, &objp->lock_owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RELEASE_LOCKOWNER4res (XDR* xdrs, RELEASE_LOCKOWNER4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ILLEGAL4res (XDR* xdrs, ILLEGAL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_gsshandle4_t (XDR* xdrs, gsshandle4_t* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->gsshandle4_t_val, (u_int*) &objp->gsshandle4_t_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_gss_cb_handles4 (XDR* xdrs, gss_cb_handles4* objp) +{ + if (!xdr_rpc_gss_svc_t (xdrs, &objp->gcbp_service)) + { + return FALSE; + } + if (!xdr_gsshandle4_t (xdrs, &objp->gcbp_handle_from_server)) + { + return FALSE; + } + if (!xdr_gsshandle4_t (xdrs, &objp->gcbp_handle_from_client)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_callback_sec_parms4 (XDR* xdrs, callback_sec_parms4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->cb_secflavor)) + { + return FALSE; + } + switch (objp->cb_secflavor) + { + case AUTH_NONE: + break; + case AUTH_SYS: + if (!xdr_authunix_parms (xdrs, &objp->callback_sec_parms4_u.cbsp_sys_cred)) + { + return FALSE; + } + break; + case RPCSEC_GSS: + if (!xdr_gss_cb_handles4 (xdrs, &objp->callback_sec_parms4_u.cbsp_gss_handles)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_BACKCHANNEL_CTL4args (XDR* xdrs, BACKCHANNEL_CTL4args* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->bca_cb_program)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->bca_sec_parms.bca_sec_parms_val, (u_int*) &objp->bca_sec_parms.bca_sec_parms_len, ~0, + sizeof (callback_sec_parms4), (xdrproc_t) xdr_callback_sec_parms4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_BACKCHANNEL_CTL4res (XDR* xdrs, BACKCHANNEL_CTL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->bcr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_channel_dir_from_client4 (XDR* xdrs, channel_dir_from_client4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_BIND_CONN_TO_SESSION4args (XDR* xdrs, BIND_CONN_TO_SESSION4args* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->bctsa_sessid)) + { + return FALSE; + } + if (!xdr_channel_dir_from_client4 (xdrs, &objp->bctsa_dir)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->bctsa_use_conn_in_rdma_mode)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_channel_dir_from_server4 (XDR* xdrs, channel_dir_from_server4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_BIND_CONN_TO_SESSION4resok (XDR* xdrs, BIND_CONN_TO_SESSION4resok* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->bctsr_sessid)) + { + return FALSE; + } + if (!xdr_channel_dir_from_server4 (xdrs, &objp->bctsr_dir)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->bctsr_use_conn_in_rdma_mode)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_BIND_CONN_TO_SESSION4res (XDR* xdrs, BIND_CONN_TO_SESSION4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->bctsr_status)) + { + return FALSE; + } + switch (objp->bctsr_status) + { + case NFS4_OK: + if (!xdr_BIND_CONN_TO_SESSION4resok (xdrs, &objp->BIND_CONN_TO_SESSION4res_u.bctsr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_state_protect_ops4 (XDR* xdrs, state_protect_ops4* objp) +{ + if (!xdr_bitmap4 (xdrs, &objp->spo_must_enforce)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->spo_must_allow)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ssv_sp_parms4 (XDR* xdrs, ssv_sp_parms4* objp) +{ + if (!xdr_state_protect_ops4 (xdrs, &objp->ssp_ops)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->ssp_hash_algs.ssp_hash_algs_val, (u_int*) &objp->ssp_hash_algs.ssp_hash_algs_len, ~0, + sizeof (sec_oid4), (xdrproc_t) xdr_sec_oid4)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->ssp_encr_algs.ssp_encr_algs_val, (u_int*) &objp->ssp_encr_algs.ssp_encr_algs_len, ~0, + sizeof (sec_oid4), (xdrproc_t) xdr_sec_oid4)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->ssp_window)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->ssp_num_gss_handles)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_state_protect_how4 (XDR* xdrs, state_protect_how4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_state_protect4_a (XDR* xdrs, state_protect4_a* objp) +{ + if (!xdr_state_protect_how4 (xdrs, &objp->spa_how)) + { + return FALSE; + } + switch (objp->spa_how) + { + case SP4_NONE: + break; + case SP4_MACH_CRED: + if (!xdr_state_protect_ops4 (xdrs, &objp->state_protect4_a_u.spa_mach_ops)) + { + return FALSE; + } + break; + case SP4_SSV: + if (!xdr_ssv_sp_parms4 (xdrs, &objp->state_protect4_a_u.spa_ssv_parms)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_EXCHANGE_ID4args (XDR* xdrs, EXCHANGE_ID4args* objp) +{ + if (!xdr_client_owner4 (xdrs, &objp->eia_clientowner)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->eia_flags)) + { + return FALSE; + } + if (!xdr_state_protect4_a (xdrs, &objp->eia_state_protect)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->eia_client_impl_id.eia_client_impl_id_val, (u_int*) &objp->eia_client_impl_id.eia_client_impl_id_len, 1, + sizeof (nfs_impl_id4), (xdrproc_t) xdr_nfs_impl_id4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ssv_prot_info4 (XDR* xdrs, ssv_prot_info4* objp) +{ + if (!xdr_state_protect_ops4 (xdrs, &objp->spi_ops)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->spi_hash_alg)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->spi_encr_alg)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->spi_ssv_len)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->spi_window)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->spi_handles.spi_handles_val, (u_int*) &objp->spi_handles.spi_handles_len, ~0, + sizeof (gsshandle4_t), (xdrproc_t) xdr_gsshandle4_t)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_state_protect4_r (XDR* xdrs, state_protect4_r* objp) +{ + if (!xdr_state_protect_how4 (xdrs, &objp->spr_how)) + { + return FALSE; + } + switch (objp->spr_how) + { + case SP4_NONE: + break; + case SP4_MACH_CRED: + if (!xdr_state_protect_ops4 (xdrs, &objp->state_protect4_r_u.spr_mach_ops)) + { + return FALSE; + } + break; + case SP4_SSV: + if (!xdr_ssv_prot_info4 (xdrs, &objp->state_protect4_r_u.spr_ssv_info)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_EXCHANGE_ID4resok (XDR* xdrs, EXCHANGE_ID4resok* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->eir_clientid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->eir_sequenceid)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->eir_flags)) + { + return FALSE; + } + if (!xdr_state_protect4_r (xdrs, &objp->eir_state_protect)) + { + return FALSE; + } + if (!xdr_server_owner4 (xdrs, &objp->eir_server_owner)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->eir_server_scope.eir_server_scope_val, (u_int*) &objp->eir_server_scope.eir_server_scope_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->eir_server_impl_id.eir_server_impl_id_val, (u_int*) &objp->eir_server_impl_id.eir_server_impl_id_len, 1, + sizeof (nfs_impl_id4), (xdrproc_t) xdr_nfs_impl_id4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_EXCHANGE_ID4res (XDR* xdrs, EXCHANGE_ID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->eir_status)) + { + return FALSE; + } + switch (objp->eir_status) + { + case NFS4_OK: + if (!xdr_EXCHANGE_ID4resok (xdrs, &objp->EXCHANGE_ID4res_u.eir_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_channel_attrs4 (XDR* xdrs, channel_attrs4* objp) +{ + if (!xdr_count4 (xdrs, &objp->ca_headerpadsize)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->ca_maxrequestsize)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->ca_maxresponsesize)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->ca_maxresponsesize_cached)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->ca_maxoperations)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->ca_maxrequests)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->ca_rdma_ird.ca_rdma_ird_val, (u_int*) &objp->ca_rdma_ird.ca_rdma_ird_len, 1, + sizeof (uint32_t), (xdrproc_t) xdr_uint32_t)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE_SESSION4args (XDR* xdrs, CREATE_SESSION4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->csa_clientid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->csa_sequence)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->csa_flags)) + { + return FALSE; + } + if (!xdr_channel_attrs4 (xdrs, &objp->csa_fore_chan_attrs)) + { + return FALSE; + } + if (!xdr_channel_attrs4 (xdrs, &objp->csa_back_chan_attrs)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->csa_cb_program)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->csa_sec_parms.csa_sec_parms_val, (u_int*) &objp->csa_sec_parms.csa_sec_parms_len, ~0, + sizeof (callback_sec_parms4), (xdrproc_t) xdr_callback_sec_parms4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE_SESSION4resok (XDR* xdrs, CREATE_SESSION4resok* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->csr_sessionid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->csr_sequence)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->csr_flags)) + { + return FALSE; + } + if (!xdr_channel_attrs4 (xdrs, &objp->csr_fore_chan_attrs)) + { + return FALSE; + } + if (!xdr_channel_attrs4 (xdrs, &objp->csr_back_chan_attrs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE_SESSION4res (XDR* xdrs, CREATE_SESSION4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->csr_status)) + { + return FALSE; + } + switch (objp->csr_status) + { + case NFS4_OK: + if (!xdr_CREATE_SESSION4resok (xdrs, &objp->CREATE_SESSION4res_u.csr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_DESTROY_SESSION4args (XDR* xdrs, DESTROY_SESSION4args* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->dsa_sessionid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DESTROY_SESSION4res (XDR* xdrs, DESTROY_SESSION4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->dsr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FREE_STATEID4args (XDR* xdrs, FREE_STATEID4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->fsa_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_FREE_STATEID4res (XDR* xdrs, FREE_STATEID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->fsr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_attr_notice4 (XDR* xdrs, attr_notice4* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4args (XDR* xdrs, GET_DIR_DELEGATION4args* objp) +{ + if (!xdr_bool (xdrs, &objp->gdda_signal_deleg_avail)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gdda_notification_types)) + { + return FALSE; + } + if (!xdr_attr_notice4 (xdrs, &objp->gdda_child_attr_delay)) + { + return FALSE; + } + if (!xdr_attr_notice4 (xdrs, &objp->gdda_dir_attr_delay)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gdda_child_attributes)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gdda_dir_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4resok (XDR* xdrs, GET_DIR_DELEGATION4resok* objp) +{ + if (!xdr_verifier4 (xdrs, objp->gddr_cookieverf)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->gddr_stateid)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gddr_notification)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gddr_child_attributes)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gddr_dir_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_gddrnf4_status (XDR* xdrs, gddrnf4_status* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4res_non_fatal (XDR* xdrs, GET_DIR_DELEGATION4res_non_fatal* objp) +{ + if (!xdr_gddrnf4_status (xdrs, &objp->gddrnf_status)) + { + return FALSE; + } + switch (objp->gddrnf_status) + { + case GDD4_OK: + if (!xdr_GET_DIR_DELEGATION4resok (xdrs, &objp->GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_resok4)) + { + return FALSE; + } + break; + case GDD4_UNAVAIL: + if (!xdr_bool (xdrs, &objp->GET_DIR_DELEGATION4res_non_fatal_u.gddrnf_will_signal_deleg_avail)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4res (XDR* xdrs, GET_DIR_DELEGATION4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->gddr_status)) + { + return FALSE; + } + switch (objp->gddr_status) + { + case NFS4_OK: + if (!xdr_GET_DIR_DELEGATION4res_non_fatal (xdrs, &objp->GET_DIR_DELEGATION4res_u.gddr_res_non_fatal4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_GETDEVICEINFO4args (XDR* xdrs, GETDEVICEINFO4args* objp) +{ + if (!xdr_deviceid4 (xdrs, objp->gdia_device_id)) + { + return FALSE; + } + if (!xdr_layouttype4 (xdrs, &objp->gdia_layout_type)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->gdia_maxcount)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gdia_notify_types)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETDEVICEINFO4resok (XDR* xdrs, GETDEVICEINFO4resok* objp) +{ + if (!xdr_device_addr4 (xdrs, &objp->gdir_device_addr)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->gdir_notification)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETDEVICEINFO4res (XDR* xdrs, GETDEVICEINFO4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->gdir_status)) + { + return FALSE; + } + switch (objp->gdir_status) + { + case NFS4_OK: + if (!xdr_GETDEVICEINFO4resok (xdrs, &objp->GETDEVICEINFO4res_u.gdir_resok4)) + { + return FALSE; + } + break; + case NFS4ERR_TOOSMALL: + if (!xdr_count4 (xdrs, &objp->GETDEVICEINFO4res_u.gdir_mincount)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_GETDEVICELIST4args (XDR* xdrs, GETDEVICELIST4args* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->gdla_layout_type)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->gdla_maxdevices)) + { + return FALSE; + } + if (!xdr_nfs_cookie4 (xdrs, &objp->gdla_cookie)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->gdla_cookieverf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETDEVICELIST4resok (XDR* xdrs, GETDEVICELIST4resok* objp) +{ + if (!xdr_nfs_cookie4 (xdrs, &objp->gdlr_cookie)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->gdlr_cookieverf)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->gdlr_deviceid_list.gdlr_deviceid_list_val, (u_int*) &objp->gdlr_deviceid_list.gdlr_deviceid_list_len, ~0, + sizeof (deviceid4), (xdrproc_t) xdr_deviceid4)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->gdlr_eof)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETDEVICELIST4res (XDR* xdrs, GETDEVICELIST4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->gdlr_status)) + { + return FALSE; + } + switch (objp->gdlr_status) + { + case NFS4_OK: + if (!xdr_GETDEVICELIST4resok (xdrs, &objp->GETDEVICELIST4res_u.gdlr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_newtime4 (XDR* xdrs, newtime4* objp) +{ + if (!xdr_bool (xdrs, &objp->nt_timechanged)) + { + return FALSE; + } + switch (objp->nt_timechanged) + { + case TRUE: + if (!xdr_nfstime4 (xdrs, &objp->newtime4_u.nt_time)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_newoffset4 (XDR* xdrs, newoffset4* objp) +{ + if (!xdr_bool (xdrs, &objp->no_newoffset)) + { + return FALSE; + } + switch (objp->no_newoffset) + { + case TRUE: + if (!xdr_offset4 (xdrs, &objp->newoffset4_u.no_offset)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LAYOUTCOMMIT4args (XDR* xdrs, LAYOUTCOMMIT4args* objp) +{ + if (!xdr_offset4 (xdrs, &objp->loca_offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->loca_length)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->loca_reclaim)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->loca_stateid)) + { + return FALSE; + } + if (!xdr_newoffset4 (xdrs, &objp->loca_last_write_offset)) + { + return FALSE; + } + if (!xdr_newtime4 (xdrs, &objp->loca_time_modify)) + { + return FALSE; + } + if (!xdr_layoutupdate4 (xdrs, &objp->loca_layoutupdate)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_newsize4 (XDR* xdrs, newsize4* objp) +{ + if (!xdr_bool (xdrs, &objp->ns_sizechanged)) + { + return FALSE; + } + switch (objp->ns_sizechanged) + { + case TRUE: + if (!xdr_length4 (xdrs, &objp->newsize4_u.ns_size)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LAYOUTCOMMIT4resok (XDR* xdrs, LAYOUTCOMMIT4resok* objp) +{ + if (!xdr_newsize4 (xdrs, &objp->locr_newsize)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LAYOUTCOMMIT4res (XDR* xdrs, LAYOUTCOMMIT4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->locr_status)) + { + return FALSE; + } + switch (objp->locr_status) + { + case NFS4_OK: + if (!xdr_LAYOUTCOMMIT4resok (xdrs, &objp->LAYOUTCOMMIT4res_u.locr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LAYOUTGET4args (XDR* xdrs, LAYOUTGET4args* objp) +{ + if (!xdr_bool (xdrs, &objp->loga_signal_layout_avail)) + { + return FALSE; + } + if (!xdr_layouttype4 (xdrs, &objp->loga_layout_type)) + { + return FALSE; + } + if (!xdr_layoutiomode4 (xdrs, &objp->loga_iomode)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->loga_offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->loga_length)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->loga_minlength)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->loga_stateid)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->loga_maxcount)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LAYOUTGET4resok (XDR* xdrs, LAYOUTGET4resok* objp) +{ + if (!xdr_bool (xdrs, &objp->logr_return_on_close)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->logr_stateid)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->logr_layout.logr_layout_val, (u_int*) &objp->logr_layout.logr_layout_len, ~0, + sizeof (layout4), (xdrproc_t) xdr_layout4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LAYOUTGET4res (XDR* xdrs, LAYOUTGET4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->logr_status)) + { + return FALSE; + } + switch (objp->logr_status) + { + case NFS4_OK: + if (!xdr_LAYOUTGET4resok (xdrs, &objp->LAYOUTGET4res_u.logr_resok4)) + { + return FALSE; + } + break; + case NFS4ERR_LAYOUTTRYLATER: + if (!xdr_bool (xdrs, &objp->LAYOUTGET4res_u.logr_will_signal_layout_avail)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LAYOUTRETURN4args (XDR* xdrs, LAYOUTRETURN4args* objp) +{ + if (!xdr_bool (xdrs, &objp->lora_reclaim)) + { + return FALSE; + } + if (!xdr_layouttype4 (xdrs, &objp->lora_layout_type)) + { + return FALSE; + } + if (!xdr_layoutiomode4 (xdrs, &objp->lora_iomode)) + { + return FALSE; + } + if (!xdr_layoutreturn4 (xdrs, &objp->lora_layoutreturn)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutreturn_stateid (XDR* xdrs, layoutreturn_stateid* objp) +{ + if (!xdr_bool (xdrs, &objp->lrs_present)) + { + return FALSE; + } + switch (objp->lrs_present) + { + case TRUE: + if (!xdr_stateid4 (xdrs, &objp->layoutreturn_stateid_u.lrs_stateid)) + { + return FALSE; + } + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LAYOUTRETURN4res (XDR* xdrs, LAYOUTRETURN4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->lorr_status)) + { + return FALSE; + } + switch (objp->lorr_status) + { + case NFS4_OK: + if (!xdr_layoutreturn_stateid (xdrs, &objp->LAYOUTRETURN4res_u.lorr_stateid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_secinfo_style4 (XDR* xdrs, secinfo_style4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SECINFO_NO_NAME4args (XDR* xdrs, SECINFO_NO_NAME4args* objp) +{ + if (!xdr_secinfo_style4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SECINFO_NO_NAME4res (XDR* xdrs, SECINFO_NO_NAME4res* objp) +{ + if (!xdr_SECINFO4res (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SEQUENCE4args (XDR* xdrs, SEQUENCE4args* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->sa_sessionid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->sa_sequenceid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->sa_slotid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->sa_highest_slotid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->sa_cachethis)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SEQUENCE4resok (XDR* xdrs, SEQUENCE4resok* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->sr_sessionid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->sr_sequenceid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->sr_slotid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->sr_highest_slotid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->sr_target_highest_slotid)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->sr_status_flags)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SEQUENCE4res (XDR* xdrs, SEQUENCE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->sr_status)) + { + return FALSE; + } + switch (objp->sr_status) + { + case NFS4_OK: + if (!xdr_SEQUENCE4resok (xdrs, &objp->SEQUENCE4res_u.sr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_ssa_digest_input4 (XDR* xdrs, ssa_digest_input4* objp) +{ + if (!xdr_SEQUENCE4args (xdrs, &objp->sdi_seqargs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SET_SSV4args (XDR* xdrs, SET_SSV4args* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->ssa_ssv.ssa_ssv_val, (u_int*) &objp->ssa_ssv.ssa_ssv_len, ~0)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->ssa_digest.ssa_digest_val, (u_int*) &objp->ssa_digest.ssa_digest_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ssr_digest_input4 (XDR* xdrs, ssr_digest_input4* objp) +{ + if (!xdr_SEQUENCE4res (xdrs, &objp->sdi_seqres)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SET_SSV4resok (XDR* xdrs, SET_SSV4resok* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->ssr_digest.ssr_digest_val, (u_int*) &objp->ssr_digest.ssr_digest_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SET_SSV4res (XDR* xdrs, SET_SSV4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->ssr_status)) + { + return FALSE; + } + switch (objp->ssr_status) + { + case NFS4_OK: + if (!xdr_SET_SSV4resok (xdrs, &objp->SET_SSV4res_u.ssr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_TEST_STATEID4args (XDR* xdrs, TEST_STATEID4args* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->ts_stateids.ts_stateids_val, (u_int*) &objp->ts_stateids.ts_stateids_len, ~0, + sizeof (stateid4), (xdrproc_t) xdr_stateid4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_TEST_STATEID4resok (XDR* xdrs, TEST_STATEID4resok* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->tsr_status_codes.tsr_status_codes_val, (u_int*) &objp->tsr_status_codes.tsr_status_codes_len, ~0, + sizeof (nfsstat4), (xdrproc_t) xdr_nfsstat4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_TEST_STATEID4res (XDR* xdrs, TEST_STATEID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->tsr_status)) + { + return FALSE; + } + switch (objp->tsr_status) + { + case NFS4_OK: + if (!xdr_TEST_STATEID4resok (xdrs, &objp->TEST_STATEID4res_u.tsr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_deleg_claim4 (XDR* xdrs, deleg_claim4* objp) +{ + if (!xdr_open_claim_type4 (xdrs, &objp->dc_claim)) + { + return FALSE; + } + switch (objp->dc_claim) + { + case CLAIM_FH: + break; + case CLAIM_DELEG_PREV_FH: + break; + case CLAIM_PREVIOUS: + if (!xdr_open_delegation_type4 (xdrs, &objp->deleg_claim4_u.dc_delegate_type)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WANT_DELEGATION4args (XDR* xdrs, WANT_DELEGATION4args* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->wda_want)) + { + return FALSE; + } + if (!xdr_deleg_claim4 (xdrs, &objp->wda_claim)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WANT_DELEGATION4res (XDR* xdrs, WANT_DELEGATION4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->wdr_status)) + { + return FALSE; + } + switch (objp->wdr_status) + { + case NFS4_OK: + if (!xdr_open_delegation4 (xdrs, &objp->WANT_DELEGATION4res_u.wdr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_DESTROY_CLIENTID4args (XDR* xdrs, DESTROY_CLIENTID4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->dca_clientid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DESTROY_CLIENTID4res (XDR* xdrs, DESTROY_CLIENTID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->dcr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RECLAIM_COMPLETE4args (XDR* xdrs, RECLAIM_COMPLETE4args* objp) +{ + if (!xdr_bool (xdrs, &objp->rca_one_fs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RECLAIM_COMPLETE4res (XDR* xdrs, RECLAIM_COMPLETE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->rcr_status)) + { + return FALSE; + } + return TRUE; +} + +/* new operations for NFSv4.1 */ + + +bool_t +xdr_nfs_opnum4 (XDR* xdrs, nfs_opnum4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_argop4 (XDR* xdrs, nfs_argop4* objp) +{ + if (!xdr_nfs_opnum4 (xdrs, &objp->argop)) + { + return FALSE; + } + switch (objp->argop) + { + case OP_ACCESS: + if (!xdr_ACCESS4args (xdrs, &objp->nfs_argop4_u.opaccess)) + { + return FALSE; + } + break; + case OP_CLOSE: + if (!xdr_CLOSE4args (xdrs, &objp->nfs_argop4_u.opclose)) + { + return FALSE; + } + break; + case OP_COMMIT: + if (!xdr_COMMIT4args (xdrs, &objp->nfs_argop4_u.opcommit)) + { + return FALSE; + } + break; + case OP_CREATE: + if (!xdr_CREATE4args (xdrs, &objp->nfs_argop4_u.opcreate)) + { + return FALSE; + } + break; + case OP_DELEGPURGE: + if (!xdr_DELEGPURGE4args (xdrs, &objp->nfs_argop4_u.opdelegpurge)) + { + return FALSE; + } + break; + case OP_DELEGRETURN: + if (!xdr_DELEGRETURN4args (xdrs, &objp->nfs_argop4_u.opdelegreturn)) + { + return FALSE; + } + break; + case OP_GETATTR: + if (!xdr_GETATTR4args (xdrs, &objp->nfs_argop4_u.opgetattr)) + { + return FALSE; + } + break; + case OP_GETFH: + break; + case OP_LINK: + if (!xdr_LINK4args (xdrs, &objp->nfs_argop4_u.oplink)) + { + return FALSE; + } + break; + case OP_LOCK: + if (!xdr_LOCK4args (xdrs, &objp->nfs_argop4_u.oplock)) + { + return FALSE; + } + break; + case OP_LOCKT: + if (!xdr_LOCKT4args (xdrs, &objp->nfs_argop4_u.oplockt)) + { + return FALSE; + } + break; + case OP_LOCKU: + if (!xdr_LOCKU4args (xdrs, &objp->nfs_argop4_u.oplocku)) + { + return FALSE; + } + break; + case OP_LOOKUP: + if (!xdr_LOOKUP4args (xdrs, &objp->nfs_argop4_u.oplookup)) + { + return FALSE; + } + break; + case OP_LOOKUPP: + break; + case OP_NVERIFY: + if (!xdr_NVERIFY4args (xdrs, &objp->nfs_argop4_u.opnverify)) + { + return FALSE; + } + break; + case OP_OPEN: + if (!xdr_OPEN4args (xdrs, &objp->nfs_argop4_u.opopen)) + { + return FALSE; + } + break; + case OP_OPENATTR: + if (!xdr_OPENATTR4args (xdrs, &objp->nfs_argop4_u.opopenattr)) + { + return FALSE; + } + break; + case OP_OPEN_CONFIRM: + if (!xdr_OPEN_CONFIRM4args (xdrs, &objp->nfs_argop4_u.opopen_confirm)) + { + return FALSE; + } + break; + case OP_OPEN_DOWNGRADE: + if (!xdr_OPEN_DOWNGRADE4args (xdrs, &objp->nfs_argop4_u.opopen_downgrade)) + { + return FALSE; + } + break; + case OP_PUTFH: + if (!xdr_PUTFH4args (xdrs, &objp->nfs_argop4_u.opputfh)) + { + return FALSE; + } + break; + case OP_PUTPUBFH: + break; + case OP_PUTROOTFH: + break; + case OP_READ: + if (!xdr_READ4args (xdrs, &objp->nfs_argop4_u.opread)) + { + return FALSE; + } + break; + case OP_READDIR: + if (!xdr_READDIR4args (xdrs, &objp->nfs_argop4_u.opreaddir)) + { + return FALSE; + } + break; + case OP_READLINK: + break; + case OP_REMOVE: + if (!xdr_REMOVE4args (xdrs, &objp->nfs_argop4_u.opremove)) + { + return FALSE; + } + break; + case OP_RENAME: + if (!xdr_RENAME4args (xdrs, &objp->nfs_argop4_u.oprename)) + { + return FALSE; + } + break; + case OP_RENEW: + if (!xdr_RENEW4args (xdrs, &objp->nfs_argop4_u.oprenew)) + { + return FALSE; + } + break; + case OP_RESTOREFH: + break; + case OP_SAVEFH: + break; + case OP_SECINFO: + if (!xdr_SECINFO4args (xdrs, &objp->nfs_argop4_u.opsecinfo)) + { + return FALSE; + } + break; + case OP_SETATTR: + if (!xdr_SETATTR4args (xdrs, &objp->nfs_argop4_u.opsetattr)) + { + return FALSE; + } + break; + case OP_SETCLIENTID: + if (!xdr_SETCLIENTID4args (xdrs, &objp->nfs_argop4_u.opsetclientid)) + { + return FALSE; + } + break; + case OP_SETCLIENTID_CONFIRM: + if (!xdr_SETCLIENTID_CONFIRM4args (xdrs, &objp->nfs_argop4_u.opsetclientid_confirm)) + { + return FALSE; + } + break; + case OP_VERIFY: + if (!xdr_VERIFY4args (xdrs, &objp->nfs_argop4_u.opverify)) + { + return FALSE; + } + break; + case OP_WRITE: + if (!xdr_WRITE4args (xdrs, &objp->nfs_argop4_u.opwrite)) + { + return FALSE; + } + break; + case OP_RELEASE_LOCKOWNER: + if (!xdr_RELEASE_LOCKOWNER4args (xdrs, &objp->nfs_argop4_u.oprelease_lockowner)) + { + return FALSE; + } + break; + case OP_BACKCHANNEL_CTL: + if (!xdr_BACKCHANNEL_CTL4args (xdrs, &objp->nfs_argop4_u.opbackchannel_ctl)) + { + return FALSE; + } + break; + case OP_BIND_CONN_TO_SESSION: + if (!xdr_BIND_CONN_TO_SESSION4args (xdrs, &objp->nfs_argop4_u.opbind_conn_to_session)) + { + return FALSE; + } + break; + case OP_EXCHANGE_ID: + if (!xdr_EXCHANGE_ID4args (xdrs, &objp->nfs_argop4_u.opexchange_id)) + { + return FALSE; + } + break; + case OP_CREATE_SESSION: + if (!xdr_CREATE_SESSION4args (xdrs, &objp->nfs_argop4_u.opcreate_session)) + { + return FALSE; + } + break; + case OP_DESTROY_SESSION: + if (!xdr_DESTROY_SESSION4args (xdrs, &objp->nfs_argop4_u.opdestroy_session)) + { + return FALSE; + } + break; + case OP_FREE_STATEID: + if (!xdr_FREE_STATEID4args (xdrs, &objp->nfs_argop4_u.opfree_stateid)) + { + return FALSE; + } + break; + case OP_GET_DIR_DELEGATION: + if (!xdr_GET_DIR_DELEGATION4args (xdrs, &objp->nfs_argop4_u.opget_dir_delegation)) + { + return FALSE; + } + break; + case OP_GETDEVICEINFO: + if (!xdr_GETDEVICEINFO4args (xdrs, &objp->nfs_argop4_u.opgetdeviceinfo)) + { + return FALSE; + } + break; + case OP_GETDEVICELIST: + if (!xdr_GETDEVICELIST4args (xdrs, &objp->nfs_argop4_u.opgetdevicelist)) + { + return FALSE; + } + break; + case OP_LAYOUTCOMMIT: + if (!xdr_LAYOUTCOMMIT4args (xdrs, &objp->nfs_argop4_u.oplayoutcommit)) + { + return FALSE; + } + break; + case OP_LAYOUTGET: + if (!xdr_LAYOUTGET4args (xdrs, &objp->nfs_argop4_u.oplayoutget)) + { + return FALSE; + } + break; + case OP_LAYOUTRETURN: + if (!xdr_LAYOUTRETURN4args (xdrs, &objp->nfs_argop4_u.oplayoutreturn)) + { + return FALSE; + } + break; + case OP_SECINFO_NO_NAME: + if (!xdr_SECINFO_NO_NAME4args (xdrs, &objp->nfs_argop4_u.opsecinfo_no_name)) + { + return FALSE; + } + break; + case OP_SEQUENCE: + if (!xdr_SEQUENCE4args (xdrs, &objp->nfs_argop4_u.opsequence)) + { + return FALSE; + } + break; + case OP_SET_SSV: + if (!xdr_SET_SSV4args (xdrs, &objp->nfs_argop4_u.opset_ssv)) + { + return FALSE; + } + break; + case OP_TEST_STATEID: + if (!xdr_TEST_STATEID4args (xdrs, &objp->nfs_argop4_u.optest_stateid)) + { + return FALSE; + } + break; + case OP_WANT_DELEGATION: + if (!xdr_WANT_DELEGATION4args (xdrs, &objp->nfs_argop4_u.opwant_delegation)) + { + return FALSE; + } + break; + case OP_DESTROY_CLIENTID: + if (!xdr_DESTROY_CLIENTID4args (xdrs, &objp->nfs_argop4_u.opdestroy_clientid)) + { + return FALSE; + } + break; + case OP_RECLAIM_COMPLETE: + if (!xdr_RECLAIM_COMPLETE4args (xdrs, &objp->nfs_argop4_u.opreclaim_complete)) + { + return FALSE; + } + break; + case OP_ILLEGAL: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_resop4 (XDR* xdrs, nfs_resop4* objp) +{ + if (!xdr_nfs_opnum4 (xdrs, &objp->resop)) + { + return FALSE; + } + switch (objp->resop) + { + case OP_ACCESS: + if (!xdr_ACCESS4res (xdrs, &objp->nfs_resop4_u.opaccess)) + { + return FALSE; + } + break; + case OP_CLOSE: + if (!xdr_CLOSE4res (xdrs, &objp->nfs_resop4_u.opclose)) + { + return FALSE; + } + break; + case OP_COMMIT: + if (!xdr_COMMIT4res (xdrs, &objp->nfs_resop4_u.opcommit)) + { + return FALSE; + } + break; + case OP_CREATE: + if (!xdr_CREATE4res (xdrs, &objp->nfs_resop4_u.opcreate)) + { + return FALSE; + } + break; + case OP_DELEGPURGE: + if (!xdr_DELEGPURGE4res (xdrs, &objp->nfs_resop4_u.opdelegpurge)) + { + return FALSE; + } + break; + case OP_DELEGRETURN: + if (!xdr_DELEGRETURN4res (xdrs, &objp->nfs_resop4_u.opdelegreturn)) + { + return FALSE; + } + break; + case OP_GETATTR: + if (!xdr_GETATTR4res (xdrs, &objp->nfs_resop4_u.opgetattr)) + { + return FALSE; + } + break; + case OP_GETFH: + if (!xdr_GETFH4res (xdrs, &objp->nfs_resop4_u.opgetfh)) + { + return FALSE; + } + break; + case OP_LINK: + if (!xdr_LINK4res (xdrs, &objp->nfs_resop4_u.oplink)) + { + return FALSE; + } + break; + case OP_LOCK: + if (!xdr_LOCK4res (xdrs, &objp->nfs_resop4_u.oplock)) + { + return FALSE; + } + break; + case OP_LOCKT: + if (!xdr_LOCKT4res (xdrs, &objp->nfs_resop4_u.oplockt)) + { + return FALSE; + } + break; + case OP_LOCKU: + if (!xdr_LOCKU4res (xdrs, &objp->nfs_resop4_u.oplocku)) + { + return FALSE; + } + break; + case OP_LOOKUP: + if (!xdr_LOOKUP4res (xdrs, &objp->nfs_resop4_u.oplookup)) + { + return FALSE; + } + break; + case OP_LOOKUPP: + if (!xdr_LOOKUPP4res (xdrs, &objp->nfs_resop4_u.oplookupp)) + { + return FALSE; + } + break; + case OP_NVERIFY: + if (!xdr_NVERIFY4res (xdrs, &objp->nfs_resop4_u.opnverify)) + { + return FALSE; + } + break; + case OP_OPEN: + if (!xdr_OPEN4res (xdrs, &objp->nfs_resop4_u.opopen)) + { + return FALSE; + } + break; + case OP_OPENATTR: + if (!xdr_OPENATTR4res (xdrs, &objp->nfs_resop4_u.opopenattr)) + { + return FALSE; + } + break; + case OP_OPEN_CONFIRM: + if (!xdr_OPEN_CONFIRM4res (xdrs, &objp->nfs_resop4_u.opopen_confirm)) + { + return FALSE; + } + break; + case OP_OPEN_DOWNGRADE: + if (!xdr_OPEN_DOWNGRADE4res (xdrs, &objp->nfs_resop4_u.opopen_downgrade)) + { + return FALSE; + } + break; + case OP_PUTFH: + if (!xdr_PUTFH4res (xdrs, &objp->nfs_resop4_u.opputfh)) + { + return FALSE; + } + break; + case OP_PUTPUBFH: + if (!xdr_PUTPUBFH4res (xdrs, &objp->nfs_resop4_u.opputpubfh)) + { + return FALSE; + } + break; + case OP_PUTROOTFH: + if (!xdr_PUTROOTFH4res (xdrs, &objp->nfs_resop4_u.opputrootfh)) + { + return FALSE; + } + break; + case OP_READ: + if (!xdr_READ4res (xdrs, &objp->nfs_resop4_u.opread)) + { + return FALSE; + } + break; + case OP_READDIR: + if (!xdr_READDIR4res (xdrs, &objp->nfs_resop4_u.opreaddir)) + { + return FALSE; + } + break; + case OP_READLINK: + if (!xdr_READLINK4res (xdrs, &objp->nfs_resop4_u.opreadlink)) + { + return FALSE; + } + break; + case OP_REMOVE: + if (!xdr_REMOVE4res (xdrs, &objp->nfs_resop4_u.opremove)) + { + return FALSE; + } + break; + case OP_RENAME: + if (!xdr_RENAME4res (xdrs, &objp->nfs_resop4_u.oprename)) + { + return FALSE; + } + break; + case OP_RENEW: + if (!xdr_RENEW4res (xdrs, &objp->nfs_resop4_u.oprenew)) + { + return FALSE; + } + break; + case OP_RESTOREFH: + if (!xdr_RESTOREFH4res (xdrs, &objp->nfs_resop4_u.oprestorefh)) + { + return FALSE; + } + break; + case OP_SAVEFH: + if (!xdr_SAVEFH4res (xdrs, &objp->nfs_resop4_u.opsavefh)) + { + return FALSE; + } + break; + case OP_SECINFO: + if (!xdr_SECINFO4res (xdrs, &objp->nfs_resop4_u.opsecinfo)) + { + return FALSE; + } + break; + case OP_SETATTR: + if (!xdr_SETATTR4res (xdrs, &objp->nfs_resop4_u.opsetattr)) + { + return FALSE; + } + break; + case OP_SETCLIENTID: + if (!xdr_SETCLIENTID4res (xdrs, &objp->nfs_resop4_u.opsetclientid)) + { + return FALSE; + } + break; + case OP_SETCLIENTID_CONFIRM: + if (!xdr_SETCLIENTID_CONFIRM4res (xdrs, &objp->nfs_resop4_u.opsetclientid_confirm)) + { + return FALSE; + } + break; + case OP_VERIFY: + if (!xdr_VERIFY4res (xdrs, &objp->nfs_resop4_u.opverify)) + { + return FALSE; + } + break; + case OP_WRITE: + if (!xdr_WRITE4res (xdrs, &objp->nfs_resop4_u.opwrite)) + { + return FALSE; + } + break; + case OP_RELEASE_LOCKOWNER: + if (!xdr_RELEASE_LOCKOWNER4res (xdrs, &objp->nfs_resop4_u.oprelease_lockowner)) + { + return FALSE; + } + break; + case OP_BACKCHANNEL_CTL: + if (!xdr_BACKCHANNEL_CTL4res (xdrs, &objp->nfs_resop4_u.opbackchannel_ctl)) + { + return FALSE; + } + break; + case OP_BIND_CONN_TO_SESSION: + if (!xdr_BIND_CONN_TO_SESSION4res (xdrs, &objp->nfs_resop4_u.opbind_conn_to_session)) + { + return FALSE; + } + break; + case OP_EXCHANGE_ID: + if (!xdr_EXCHANGE_ID4res (xdrs, &objp->nfs_resop4_u.opexchange_id)) + { + return FALSE; + } + break; + case OP_CREATE_SESSION: + if (!xdr_CREATE_SESSION4res (xdrs, &objp->nfs_resop4_u.opcreate_session)) + { + return FALSE; + } + break; + case OP_DESTROY_SESSION: + if (!xdr_DESTROY_SESSION4res (xdrs, &objp->nfs_resop4_u.opdestroy_session)) + { + return FALSE; + } + break; + case OP_FREE_STATEID: + if (!xdr_FREE_STATEID4res (xdrs, &objp->nfs_resop4_u.opfree_stateid)) + { + return FALSE; + } + break; + case OP_GET_DIR_DELEGATION: + if (!xdr_GET_DIR_DELEGATION4res (xdrs, &objp->nfs_resop4_u.opget_dir_delegation)) + { + return FALSE; + } + break; + case OP_GETDEVICEINFO: + if (!xdr_GETDEVICEINFO4res (xdrs, &objp->nfs_resop4_u.opgetdeviceinfo)) + { + return FALSE; + } + break; + case OP_GETDEVICELIST: + if (!xdr_GETDEVICELIST4res (xdrs, &objp->nfs_resop4_u.opgetdevicelist)) + { + return FALSE; + } + break; + case OP_LAYOUTCOMMIT: + if (!xdr_LAYOUTCOMMIT4res (xdrs, &objp->nfs_resop4_u.oplayoutcommit)) + { + return FALSE; + } + break; + case OP_LAYOUTGET: + if (!xdr_LAYOUTGET4res (xdrs, &objp->nfs_resop4_u.oplayoutget)) + { + return FALSE; + } + break; + case OP_LAYOUTRETURN: + if (!xdr_LAYOUTRETURN4res (xdrs, &objp->nfs_resop4_u.oplayoutreturn)) + { + return FALSE; + } + break; + case OP_SECINFO_NO_NAME: + if (!xdr_SECINFO_NO_NAME4res (xdrs, &objp->nfs_resop4_u.opsecinfo_no_name)) + { + return FALSE; + } + break; + case OP_SEQUENCE: + if (!xdr_SEQUENCE4res (xdrs, &objp->nfs_resop4_u.opsequence)) + { + return FALSE; + } + break; + case OP_SET_SSV: + if (!xdr_SET_SSV4res (xdrs, &objp->nfs_resop4_u.opset_ssv)) + { + return FALSE; + } + break; + case OP_TEST_STATEID: + if (!xdr_TEST_STATEID4res (xdrs, &objp->nfs_resop4_u.optest_stateid)) + { + return FALSE; + } + break; + case OP_WANT_DELEGATION: + if (!xdr_WANT_DELEGATION4res (xdrs, &objp->nfs_resop4_u.opwant_delegation)) + { + return FALSE; + } + break; + case OP_DESTROY_CLIENTID: + if (!xdr_DESTROY_CLIENTID4res (xdrs, &objp->nfs_resop4_u.opdestroy_clientid)) + { + return FALSE; + } + break; + case OP_RECLAIM_COMPLETE: + if (!xdr_RECLAIM_COMPLETE4res (xdrs, &objp->nfs_resop4_u.opreclaim_complete)) + { + return FALSE; + } + break; + case OP_ILLEGAL: + if (!xdr_ILLEGAL4res (xdrs, &objp->nfs_resop4_u.opillegal)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMPOUND4args (XDR* xdrs, COMPOUND4args* objp) +{ + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->minorversion)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->argarray.argarray_val, (u_int*) &objp->argarray.argarray_len, ~0, + sizeof (nfs_argop4), (xdrproc_t) xdr_nfs_argop4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMPOUND4res (XDR* xdrs, COMPOUND4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->resarray.resarray_val, (u_int*) &objp->resarray.resarray_len, ~0, + sizeof (nfs_resop4), (xdrproc_t) xdr_nfs_resop4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_GETATTR4args (XDR* xdrs, CB_GETATTR4args* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->fh)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attr_request)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_GETATTR4resok (XDR* xdrs, CB_GETATTR4resok* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_GETATTR4res (XDR* xdrs, CB_GETATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_CB_GETATTR4resok (xdrs, &objp->CB_GETATTR4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL4args (XDR* xdrs, CB_RECALL4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->truncate)) + { + return FALSE; + } + if (!xdr_nfs_fh4 (xdrs, &objp->fh)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL4res (XDR* xdrs, CB_RECALL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_ILLEGAL4res (XDR* xdrs, CB_ILLEGAL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutrecall_type4 (XDR* xdrs, layoutrecall_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutrecall_file4 (XDR* xdrs, layoutrecall_file4* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->lor_fh)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->lor_offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->lor_length)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->lor_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_layoutrecall4 (XDR* xdrs, layoutrecall4* objp) +{ + if (!xdr_layoutrecall_type4 (xdrs, &objp->lor_recalltype)) + { + return FALSE; + } + switch (objp->lor_recalltype) + { + case LAYOUTRECALL4_FILE: + if (!xdr_layoutrecall_file4 (xdrs, &objp->layoutrecall4_u.lor_layout)) + { + return FALSE; + } + break; + case LAYOUTRECALL4_FSID: + if (!xdr_fsid4 (xdrs, &objp->layoutrecall4_u.lor_fsid)) + { + return FALSE; + } + break; + case LAYOUTRECALL4_ALL: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_LAYOUTRECALL4args (XDR* xdrs, CB_LAYOUTRECALL4args* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->clora_type)) + { + return FALSE; + } + if (!xdr_layoutiomode4 (xdrs, &objp->clora_iomode)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->clora_changed)) + { + return FALSE; + } + if (!xdr_layoutrecall4 (xdrs, &objp->clora_recall)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_LAYOUTRECALL4res (XDR* xdrs, CB_LAYOUTRECALL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->clorr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_type4 (XDR* xdrs, notify_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_entry4 (XDR* xdrs, notify_entry4* objp) +{ + if (!xdr_component4 (xdrs, &objp->ne_file)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->ne_attrs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_prev_entry4 (XDR* xdrs, prev_entry4* objp) +{ + if (!xdr_notify_entry4 (xdrs, &objp->pe_prev_entry)) + { + return FALSE; + } + if (!xdr_nfs_cookie4 (xdrs, &objp->pe_prev_entry_cookie)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_remove4 (XDR* xdrs, notify_remove4* objp) +{ + if (!xdr_notify_entry4 (xdrs, &objp->nrm_old_entry)) + { + return FALSE; + } + if (!xdr_nfs_cookie4 (xdrs, &objp->nrm_old_entry_cookie)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_add4 (XDR* xdrs, notify_add4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->nad_old_entry.nad_old_entry_val, (u_int*) &objp->nad_old_entry.nad_old_entry_len, 1, + sizeof (notify_remove4), (xdrproc_t) xdr_notify_remove4)) + { + return FALSE; + } + if (!xdr_notify_entry4 (xdrs, &objp->nad_new_entry)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->nad_new_entry_cookie.nad_new_entry_cookie_val, (u_int*) &objp->nad_new_entry_cookie.nad_new_entry_cookie_len, 1, + sizeof (nfs_cookie4), (xdrproc_t) xdr_nfs_cookie4)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->nad_prev_entry.nad_prev_entry_val, (u_int*) &objp->nad_prev_entry.nad_prev_entry_len, 1, + sizeof (prev_entry4), (xdrproc_t) xdr_prev_entry4)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->nad_last_entry)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_attr4 (XDR* xdrs, notify_attr4* objp) +{ + if (!xdr_notify_entry4 (xdrs, &objp->na_changed_entry)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_rename4 (XDR* xdrs, notify_rename4* objp) +{ + if (!xdr_notify_remove4 (xdrs, &objp->nrn_old_entry)) + { + return FALSE; + } + if (!xdr_notify_add4 (xdrs, &objp->nrn_new_entry)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_verifier4 (XDR* xdrs, notify_verifier4* objp) +{ + if (!xdr_verifier4 (xdrs, objp->nv_old_cookieverf)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->nv_new_cookieverf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notifylist4 (XDR* xdrs, notifylist4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->notifylist4_val, (u_int*) &objp->notifylist4_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify4 (XDR* xdrs, notify4* objp) +{ + if (!xdr_bitmap4 (xdrs, &objp->notify_mask)) + { + return FALSE; + } + if (!xdr_notifylist4 (xdrs, &objp->notify_vals)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_NOTIFY4args (XDR* xdrs, CB_NOTIFY4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->cna_stateid)) + { + return FALSE; + } + if (!xdr_nfs_fh4 (xdrs, &objp->cna_fh)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->cna_changes.cna_changes_val, (u_int*) &objp->cna_changes.cna_changes_len, ~0, + sizeof (notify4), (xdrproc_t) xdr_notify4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_NOTIFY4res (XDR* xdrs, CB_NOTIFY4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->cnr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_PUSH_DELEG4args (XDR* xdrs, CB_PUSH_DELEG4args* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->cpda_fh)) + { + return FALSE; + } + if (!xdr_open_delegation4 (xdrs, &objp->cpda_delegation)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_PUSH_DELEG4res (XDR* xdrs, CB_PUSH_DELEG4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->cpdr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL_ANY4args (XDR* xdrs, CB_RECALL_ANY4args* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->craa_objects_to_keep)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->craa_type_mask)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL_ANY4res (XDR* xdrs, CB_RECALL_ANY4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->crar_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALLABLE_OBJ_AVAIL4args (XDR* xdrs, CB_RECALLABLE_OBJ_AVAIL4args* objp) +{ + if (!xdr_CB_RECALL_ANY4args (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALLABLE_OBJ_AVAIL4res (XDR* xdrs, CB_RECALLABLE_OBJ_AVAIL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->croa_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL_SLOT4args (XDR* xdrs, CB_RECALL_SLOT4args* objp) +{ + if (!xdr_slotid4 (xdrs, &objp->rsa_target_highest_slotid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL_SLOT4res (XDR* xdrs, CB_RECALL_SLOT4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->rsr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_referring_call4 (XDR* xdrs, referring_call4* objp) +{ + if (!xdr_sequenceid4 (xdrs, &objp->rc_sequenceid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->rc_slotid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_referring_call_list4 (XDR* xdrs, referring_call_list4* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->rcl_sessionid)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->rcl_referring_calls.rcl_referring_calls_val, (u_int*) &objp->rcl_referring_calls.rcl_referring_calls_len, ~0, + sizeof (referring_call4), (xdrproc_t) xdr_referring_call4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_SEQUENCE4args (XDR* xdrs, CB_SEQUENCE4args* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->csa_sessionid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->csa_sequenceid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->csa_slotid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->csa_highest_slotid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->csa_cachethis)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->csa_referring_call_lists.csa_referring_call_lists_val, (u_int*) &objp->csa_referring_call_lists.csa_referring_call_lists_len, ~0, + sizeof (referring_call_list4), (xdrproc_t) xdr_referring_call_list4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_SEQUENCE4resok (XDR* xdrs, CB_SEQUENCE4resok* objp) +{ + if (!xdr_sessionid4 (xdrs, objp->csr_sessionid)) + { + return FALSE; + } + if (!xdr_sequenceid4 (xdrs, &objp->csr_sequenceid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->csr_slotid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->csr_highest_slotid)) + { + return FALSE; + } + if (!xdr_slotid4 (xdrs, &objp->csr_target_highest_slotid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_SEQUENCE4res (XDR* xdrs, CB_SEQUENCE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->csr_status)) + { + return FALSE; + } + switch (objp->csr_status) + { + case NFS4_OK: + if (!xdr_CB_SEQUENCE4resok (xdrs, &objp->CB_SEQUENCE4res_u.csr_resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CB_WANTS_CANCELLED4args (XDR* xdrs, CB_WANTS_CANCELLED4args* objp) +{ + if (!xdr_bool (xdrs, &objp->cwca_contended_wants_cancelled)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->cwca_resourced_wants_cancelled)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_WANTS_CANCELLED4res (XDR* xdrs, CB_WANTS_CANCELLED4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->cwcr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_NOTIFY_LOCK4args (XDR* xdrs, CB_NOTIFY_LOCK4args* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->cnla_fh)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->cnla_lock_owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_NOTIFY_LOCK4res (XDR* xdrs, CB_NOTIFY_LOCK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->cnlr_status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_deviceid_type4 (XDR* xdrs, notify_deviceid_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_deviceid_delete4 (XDR* xdrs, notify_deviceid_delete4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->ndd_layouttype)) + { + return FALSE; + } + if (!xdr_deviceid4 (xdrs, objp->ndd_deviceid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notify_deviceid_change4 (XDR* xdrs, notify_deviceid_change4* objp) +{ + if (!xdr_layouttype4 (xdrs, &objp->ndc_layouttype)) + { + return FALSE; + } + if (!xdr_deviceid4 (xdrs, objp->ndc_deviceid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->ndc_immediate)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_NOTIFY_DEVICEID4args (XDR* xdrs, CB_NOTIFY_DEVICEID4args* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->cnda_changes.cnda_changes_val, (u_int*) &objp->cnda_changes.cnda_changes_len, ~0, + sizeof (notify4), (xdrproc_t) xdr_notify4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_NOTIFY_DEVICEID4res (XDR* xdrs, CB_NOTIFY_DEVICEID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->cndr_status)) + { + return FALSE; + } + return TRUE; +} + +/* Callback operations new to NFSv4.1 */ + +bool_t +xdr_nfs_cb_opnum4 (XDR* xdrs, nfs_cb_opnum4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cb_argop4 (XDR* xdrs, nfs_cb_argop4* objp) +{ + if (!xdr_u_int (xdrs, &objp->argop)) + { + return FALSE; + } + switch (objp->argop) + { + case OP_CB_GETATTR: + if (!xdr_CB_GETATTR4args (xdrs, &objp->nfs_cb_argop4_u.opcbgetattr)) + { + return FALSE; + } + break; + case OP_CB_RECALL: + if (!xdr_CB_RECALL4args (xdrs, &objp->nfs_cb_argop4_u.opcbrecall)) + { + return FALSE; + } + break; + case OP_CB_LAYOUTRECALL: + if (!xdr_CB_LAYOUTRECALL4args (xdrs, &objp->nfs_cb_argop4_u.opcblayoutrecall)) + { + return FALSE; + } + break; + case OP_CB_NOTIFY: + if (!xdr_CB_NOTIFY4args (xdrs, &objp->nfs_cb_argop4_u.opcbnotify)) + { + return FALSE; + } + break; + case OP_CB_PUSH_DELEG: + if (!xdr_CB_PUSH_DELEG4args (xdrs, &objp->nfs_cb_argop4_u.opcbpush_deleg)) + { + return FALSE; + } + break; + case OP_CB_RECALL_ANY: + if (!xdr_CB_RECALL_ANY4args (xdrs, &objp->nfs_cb_argop4_u.opcbrecall_any)) + { + return FALSE; + } + break; + case OP_CB_RECALLABLE_OBJ_AVAIL: + if (!xdr_CB_RECALLABLE_OBJ_AVAIL4args (xdrs, &objp->nfs_cb_argop4_u.opcbrecallable_obj_avail)) + { + return FALSE; + } + break; + case OP_CB_RECALL_SLOT: + if (!xdr_CB_RECALL_SLOT4args (xdrs, &objp->nfs_cb_argop4_u.opcbrecall_slot)) + { + return FALSE; + } + break; + case OP_CB_SEQUENCE: + if (!xdr_CB_SEQUENCE4args (xdrs, &objp->nfs_cb_argop4_u.opcbsequence)) + { + return FALSE; + } + break; + case OP_CB_WANTS_CANCELLED: + if (!xdr_CB_WANTS_CANCELLED4args (xdrs, &objp->nfs_cb_argop4_u.opcbwants_cancelled)) + { + return FALSE; + } + break; + case OP_CB_NOTIFY_LOCK: + if (!xdr_CB_NOTIFY_LOCK4args (xdrs, &objp->nfs_cb_argop4_u.opcbnotify_lock)) + { + return FALSE; + } + break; + case OP_CB_NOTIFY_DEVICEID: + if (!xdr_CB_NOTIFY_DEVICEID4args (xdrs, &objp->nfs_cb_argop4_u.opcbnotify_deviceid)) + { + return FALSE; + } + break; + case OP_CB_ILLEGAL: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cb_resop4 (XDR* xdrs, nfs_cb_resop4* objp) +{ + if (!xdr_u_int (xdrs, &objp->resop)) + { + return FALSE; + } + switch (objp->resop) + { + case OP_CB_GETATTR: + if (!xdr_CB_GETATTR4res (xdrs, &objp->nfs_cb_resop4_u.opcbgetattr)) + { + return FALSE; + } + break; + case OP_CB_RECALL: + if (!xdr_CB_RECALL4res (xdrs, &objp->nfs_cb_resop4_u.opcbrecall)) + { + return FALSE; + } + break; + case OP_CB_LAYOUTRECALL: + if (!xdr_CB_LAYOUTRECALL4res (xdrs, &objp->nfs_cb_resop4_u.opcblayoutrecall)) + { + return FALSE; + } + break; + case OP_CB_NOTIFY: + if (!xdr_CB_NOTIFY4res (xdrs, &objp->nfs_cb_resop4_u.opcbnotify)) + { + return FALSE; + } + break; + case OP_CB_PUSH_DELEG: + if (!xdr_CB_PUSH_DELEG4res (xdrs, &objp->nfs_cb_resop4_u.opcbpush_deleg)) + { + return FALSE; + } + break; + case OP_CB_RECALL_ANY: + if (!xdr_CB_RECALL_ANY4res (xdrs, &objp->nfs_cb_resop4_u.opcbrecall_any)) + { + return FALSE; + } + break; + case OP_CB_RECALLABLE_OBJ_AVAIL: + if (!xdr_CB_RECALLABLE_OBJ_AVAIL4res (xdrs, &objp->nfs_cb_resop4_u.opcbrecallable_obj_avail)) + { + return FALSE; + } + break; + case OP_CB_RECALL_SLOT: + if (!xdr_CB_RECALL_SLOT4res (xdrs, &objp->nfs_cb_resop4_u.opcbrecall_slot)) + { + return FALSE; + } + break; + case OP_CB_SEQUENCE: + if (!xdr_CB_SEQUENCE4res (xdrs, &objp->nfs_cb_resop4_u.opcbsequence)) + { + return FALSE; + } + break; + case OP_CB_WANTS_CANCELLED: + if (!xdr_CB_WANTS_CANCELLED4res (xdrs, &objp->nfs_cb_resop4_u.opcbwants_cancelled)) + { + return FALSE; + } + break; + case OP_CB_NOTIFY_LOCK: + if (!xdr_CB_NOTIFY_LOCK4res (xdrs, &objp->nfs_cb_resop4_u.opcbnotify_lock)) + { + return FALSE; + } + break; + case OP_CB_NOTIFY_DEVICEID: + if (!xdr_CB_NOTIFY_DEVICEID4res (xdrs, &objp->nfs_cb_resop4_u.opcbnotify_deviceid)) + { + return FALSE; + } + break; + case OP_CB_ILLEGAL: + if (!xdr_CB_ILLEGAL4res (xdrs, &objp->nfs_cb_resop4_u.opcbillegal)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_COMPOUND4args (XDR* xdrs, CB_COMPOUND4args* objp) +{ + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->minorversion)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->callback_ident)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->argarray.argarray_val, (u_int*) &objp->argarray.argarray_len, ~0, + sizeof (nfs_cb_argop4), (xdrproc_t) xdr_nfs_cb_argop4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_COMPOUND4res (XDR* xdrs, CB_COMPOUND4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->resarray.resarray_val, (u_int*) &objp->resarray.resarray_len, ~0, + sizeof (nfs_cb_resop4), (xdrproc_t) xdr_nfs_cb_resop4)) + { + return FALSE; + } + return TRUE; +} + +} // namespace NFS41 +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ diff --git a/src/protocols/nfs4/nfs41_utils.h b/src/protocols/nfs4/nfs41_utils.h new file mode 100644 index 0000000..77c42ea --- /dev/null +++ b/src/protocols/nfs4/nfs41_utils.h @@ -0,0 +1,629 @@ +//------------------------------------------------------------------------------ +// Author: Alexey Costroma +// Description: Helpers for parsing NFS structures. +// Copyright (c) 2015 EPAM Systems +//------------------------------------------------------------------------------ +/* + This file is part of Nfstrace. + + Nfstrace is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, version 2 of the License. + + Nfstrace is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. +*/ +//------------------------------------------------------------------------------ +#ifndef NFS41_UTILS_H +#define NFS41_UTILS_H +//------------------------------------------------------------------------------ +#include <ostream> + +#include "api/nfs_types.h" +#include "api/nfs41_types_rpcgen.h" +#include "protocols/nfs/nfs_utils.h" +#include "protocols/rpc/rpc_header.h" +//------------------------------------------------------------------------------ +namespace NST +{ +namespace protocols +{ +namespace NFS41 +{ + +namespace NFS41 = NST::API::NFS41; + +using ProcEnumNFS41 = API::ProcEnumNFS41; + +using Validator = rpc::RPCProgramValidator + < + 100003, // SunRPC/NFS program + 4, // v4 + ProcEnumNFS41::NFS_NULL, // NFSPROC41RPCGEN_NULL (0) + ProcEnumNFS41::COMPOUND // NFSPROC41RPCGEN_COMPOUND (1) + >; + +bool_t xdr_nfs_ftype4 (XDR *, NFS41::nfs_ftype4*); +bool_t xdr_nfsstat4 (XDR *, NFS41::nfsstat4*); +bool_t xdr_attrlist4 (XDR *, NFS41::attrlist4*); +bool_t xdr_bitmap4 (XDR *, NFS41::bitmap4*); +bool_t xdr_changeid4 (XDR *, NFS41::changeid4*); +bool_t xdr_clientid4 (XDR *, NFS41::clientid4*); +bool_t xdr_count4 (XDR *, NFS41::count4*); +bool_t xdr_length4 (XDR *, NFS41::length4*); +bool_t xdr_mode4 (XDR *, NFS41::mode4*); +bool_t xdr_nfs_cookie4 (XDR *, NFS41::nfs_cookie4*); +bool_t xdr_nfs_fh4 (XDR *, NFS41::nfs_fh4*); +bool_t xdr_offset4 (XDR *, NFS41::offset4*); +bool_t xdr_qop4 (XDR *, NFS41::qop4*); +bool_t xdr_sec_oid4 (XDR *, NFS41::sec_oid4*); +bool_t xdr_sequenceid4 (XDR *, NFS41::sequenceid4*); +bool_t xdr_seqid4 (XDR *, NFS41::seqid4*); +bool_t xdr_sessionid4 (XDR *, NFS41::sessionid4); +bool_t xdr_slotid4 (XDR *, NFS41::slotid4*); +bool_t xdr_utf8string (XDR *, NFS41::utf8string*); +bool_t xdr_utf8str_cis (XDR *, NFS41::utf8str_cis*); +bool_t xdr_utf8str_cs (XDR *, NFS41::utf8str_cs*); +bool_t xdr_utf8str_mixed (XDR *, NFS41::utf8str_mixed*); +bool_t xdr_component4 (XDR *, NFS41::component4*); +bool_t xdr_linktext4 (XDR *, NFS41::linktext4*); +bool_t xdr_pathname4 (XDR *, NFS41::pathname4*); +bool_t xdr_verifier4 (XDR *, NFS41::verifier4); +bool_t xdr_nfstime4 (XDR *, NFS41::nfstime4*); +bool_t xdr_time_how4 (XDR *, NFS41::time_how4*); +bool_t xdr_settime4 (XDR *, NFS41::settime4*); +bool_t xdr_nfs_lease4 (XDR *, NFS41::nfs_lease4*); +bool_t xdr_fsid4 (XDR *, NFS41::fsid4*); +bool_t xdr_change_policy4 (XDR *, NFS41::change_policy4*); +bool_t xdr_fs_location4 (XDR *, NFS41::fs_location4*); +bool_t xdr_fs_locations4 (XDR *, NFS41::fs_locations4*); +bool_t xdr_acetype4 (XDR *, NFS41::acetype4*); +bool_t xdr_aceflag4 (XDR *, NFS41::aceflag4*); +bool_t xdr_acemask4 (XDR *, NFS41::acemask4*); +bool_t xdr_nfsace4 (XDR *, NFS41::nfsace4*); +bool_t xdr_aclflag4 (XDR *, NFS41::aclflag4*); +bool_t xdr_nfsacl41 (XDR *, NFS41::nfsacl41*); +bool_t xdr_mode_masked4 (XDR *, NFS41::mode_masked4*); +bool_t xdr_specdata4 (XDR *, NFS41::specdata4*); +bool_t xdr_netaddr4 (XDR *, NFS41::netaddr4*); +bool_t xdr_nfs_impl_id4 (XDR *, NFS41::nfs_impl_id4*); +bool_t xdr_stateid4 (XDR *, NFS41::stateid4*); +bool_t xdr_layouttype4 (XDR *, NFS41::layouttype4*); +bool_t xdr_layout_content4 (XDR *, NFS41::layout_content4*); +bool_t xdr_layouthint4 (XDR *, NFS41::layouthint4*); +bool_t xdr_layoutiomode4 (XDR *, NFS41::layoutiomode4*); +bool_t xdr_layout4 (XDR *, NFS41::layout4*); +bool_t xdr_deviceid4 (XDR *, NFS41::deviceid4); +bool_t xdr_device_addr4 (XDR *, NFS41::device_addr4*); +bool_t xdr_layoutupdate4 (XDR *, NFS41::layoutupdate4*); +bool_t xdr_layoutreturn_type4 (XDR *, NFS41::layoutreturn_type4*); +bool_t xdr_layoutreturn_file4 (XDR *, NFS41::layoutreturn_file4*); +bool_t xdr_layoutreturn4 (XDR *, NFS41::layoutreturn4*); +bool_t xdr_fs4_status_type (XDR *, NFS41::fs4_status_type*); +bool_t xdr_fs4_status (XDR *, NFS41::fs4_status*); +bool_t xdr_threshold4_read_size (XDR *, NFS41::threshold4_read_size*); +bool_t xdr_threshold4_write_size (XDR *, NFS41::threshold4_write_size*); +bool_t xdr_threshold4_read_iosize (XDR *, NFS41::threshold4_read_iosize*); +bool_t xdr_threshold4_write_iosize (XDR *, NFS41::threshold4_write_iosize*); +bool_t xdr_threshold_item4 (XDR *, NFS41::threshold_item4*); +bool_t xdr_mdsthreshold4 (XDR *, NFS41::mdsthreshold4*); +bool_t xdr_retention_get4 (XDR *, NFS41::retention_get4*); +bool_t xdr_retention_set4 (XDR *, NFS41::retention_set4*); +bool_t xdr_fs_charset_cap4 (XDR *, NFS41::fs_charset_cap4*); +bool_t xdr_fattr4_supported_attrs (XDR *, NFS41::fattr4_supported_attrs*); +bool_t xdr_fattr4_type (XDR *, NFS41::fattr4_type*); +bool_t xdr_fattr4_fh_expire_type (XDR *, NFS41::fattr4_fh_expire_type*); +bool_t xdr_fattr4_change (XDR *, NFS41::fattr4_change*); +bool_t xdr_fattr4_size (XDR *, NFS41::fattr4_size*); +bool_t xdr_fattr4_link_support (XDR *, NFS41::fattr4_link_support*); +bool_t xdr_fattr4_symlink_support (XDR *, NFS41::fattr4_symlink_support*); +bool_t xdr_fattr4_named_attr (XDR *, NFS41::fattr4_named_attr*); +bool_t xdr_fattr4_fsid (XDR *, NFS41::fattr4_fsid*); +bool_t xdr_fattr4_unique_handles (XDR *, NFS41::fattr4_unique_handles*); +bool_t xdr_fattr4_lease_time (XDR *, NFS41::fattr4_lease_time*); +bool_t xdr_fattr4_rdattr_error (XDR *, NFS41::fattr4_rdattr_error*); +bool_t xdr_fattr4_acl (XDR *, NFS41::fattr4_acl*); +bool_t xdr_fattr4_aclsupport (XDR *, NFS41::fattr4_aclsupport*); +bool_t xdr_fattr4_archive (XDR *, NFS41::fattr4_archive*); +bool_t xdr_fattr4_cansettime (XDR *, NFS41::fattr4_cansettime*); +bool_t xdr_fattr4_case_insensitive (XDR *, NFS41::fattr4_case_insensitive*); +bool_t xdr_fattr4_case_preserving (XDR *, NFS41::fattr4_case_preserving*); +bool_t xdr_fattr4_chown_restricted (XDR *, NFS41::fattr4_chown_restricted*); +bool_t xdr_fattr4_fileid (XDR *, NFS41::fattr4_fileid*); +bool_t xdr_fattr4_files_avail (XDR *, NFS41::fattr4_files_avail*); +bool_t xdr_fattr4_filehandle (XDR *, NFS41::fattr4_filehandle*); +bool_t xdr_fattr4_files_free (XDR *, NFS41::fattr4_files_free*); +bool_t xdr_fattr4_files_total (XDR *, NFS41::fattr4_files_total*); +bool_t xdr_fattr4_fs_locations (XDR *, NFS41::fattr4_fs_locations*); +bool_t xdr_fattr4_hidden (XDR *, NFS41::fattr4_hidden*); +bool_t xdr_fattr4_homogeneous (XDR *, NFS41::fattr4_homogeneous*); +bool_t xdr_fattr4_maxfilesize (XDR *, NFS41::fattr4_maxfilesize*); +bool_t xdr_fattr4_maxlink (XDR *, NFS41::fattr4_maxlink*); +bool_t xdr_fattr4_maxname (XDR *, NFS41::fattr4_maxname*); +bool_t xdr_fattr4_maxread (XDR *, NFS41::fattr4_maxread*); +bool_t xdr_fattr4_maxwrite (XDR *, NFS41::fattr4_maxwrite*); +bool_t xdr_fattr4_mimetype (XDR *, NFS41::fattr4_mimetype*); +bool_t xdr_fattr4_mode (XDR *, NFS41::fattr4_mode*); +bool_t xdr_fattr4_mode_set_masked (XDR *, NFS41::fattr4_mode_set_masked*); +bool_t xdr_fattr4_mounted_on_fileid (XDR *, NFS41::fattr4_mounted_on_fileid*); +bool_t xdr_fattr4_no_trunc (XDR *, NFS41::fattr4_no_trunc*); +bool_t xdr_fattr4_numlinks (XDR *, NFS41::fattr4_numlinks*); +bool_t xdr_fattr4_owner (XDR *, NFS41::fattr4_owner*); +bool_t xdr_fattr4_owner_group (XDR *, NFS41::fattr4_owner_group*); +bool_t xdr_fattr4_quota_avail_hard (XDR *, NFS41::fattr4_quota_avail_hard*); +bool_t xdr_fattr4_quota_avail_soft (XDR *, NFS41::fattr4_quota_avail_soft*); +bool_t xdr_fattr4_quota_used (XDR *, NFS41::fattr4_quota_used*); +bool_t xdr_fattr4_rawdev (XDR *, NFS41::fattr4_rawdev*); +bool_t xdr_fattr4_space_avail (XDR *, NFS41::fattr4_space_avail*); +bool_t xdr_fattr4_space_free (XDR *, NFS41::fattr4_space_free*); +bool_t xdr_fattr4_space_total (XDR *, NFS41::fattr4_space_total*); +bool_t xdr_fattr4_space_used (XDR *, NFS41::fattr4_space_used*); +bool_t xdr_fattr4_system (XDR *, NFS41::fattr4_system*); +bool_t xdr_fattr4_time_access (XDR *, NFS41::fattr4_time_access*); +bool_t xdr_fattr4_time_access_set (XDR *, NFS41::fattr4_time_access_set*); +bool_t xdr_fattr4_time_backup (XDR *, NFS41::fattr4_time_backup*); +bool_t xdr_fattr4_time_create (XDR *, NFS41::fattr4_time_create*); +bool_t xdr_fattr4_time_delta (XDR *, NFS41::fattr4_time_delta*); +bool_t xdr_fattr4_time_metadata (XDR *, NFS41::fattr4_time_metadata*); +bool_t xdr_fattr4_time_modify (XDR *, NFS41::fattr4_time_modify*); +bool_t xdr_fattr4_time_modify_set (XDR *, NFS41::fattr4_time_modify_set*); +bool_t xdr_fattr4_suppattr_exclcreat (XDR *, NFS41::fattr4_suppattr_exclcreat*); +bool_t xdr_fattr4_dir_notif_delay (XDR *, NFS41::fattr4_dir_notif_delay*); +bool_t xdr_fattr4_dirent_notif_delay (XDR *, NFS41::fattr4_dirent_notif_delay*); +bool_t xdr_fattr4_fs_layout_types (XDR *, NFS41::fattr4_fs_layout_types*); +bool_t xdr_fattr4_fs_status (XDR *, NFS41::fattr4_fs_status*); +bool_t xdr_fattr4_fs_charset_cap (XDR *, NFS41::fattr4_fs_charset_cap*); +bool_t xdr_fattr4_layout_alignment (XDR *, NFS41::fattr4_layout_alignment*); +bool_t xdr_fattr4_layout_blksize (XDR *, NFS41::fattr4_layout_blksize*); +bool_t xdr_fattr4_layout_hint (XDR *, NFS41::fattr4_layout_hint*); +bool_t xdr_fattr4_layout_types (XDR *, NFS41::fattr4_layout_types*); +bool_t xdr_fattr4_mdsthreshold (XDR *, NFS41::fattr4_mdsthreshold*); +bool_t xdr_fattr4_retention_get (XDR *, NFS41::fattr4_retention_get*); +bool_t xdr_fattr4_retention_set (XDR *, NFS41::fattr4_retention_set*); +bool_t xdr_fattr4_retentevt_get (XDR *, NFS41::fattr4_retentevt_get*); +bool_t xdr_fattr4_retentevt_set (XDR *, NFS41::fattr4_retentevt_set*); +bool_t xdr_fattr4_retention_hold (XDR *, NFS41::fattr4_retention_hold*); +bool_t xdr_fattr4_dacl (XDR *, NFS41::fattr4_dacl*); +bool_t xdr_fattr4_sacl (XDR *, NFS41::fattr4_sacl*); +bool_t xdr_fattr4_change_policy (XDR *, NFS41::fattr4_change_policy*); +bool_t xdr_fattr4 (XDR *, NFS41::fattr4*); +bool_t xdr_change_info4 (XDR *, NFS41::change_info4*); +bool_t xdr_clientaddr4 (XDR *, NFS41::clientaddr4*); +bool_t xdr_cb_client4 (XDR *, NFS41::cb_client4*); +bool_t xdr_nfs_client_id4 (XDR *, NFS41::nfs_client_id4*); +bool_t xdr_client_owner4 (XDR *, NFS41::client_owner4*); +bool_t xdr_server_owner4 (XDR *, NFS41::server_owner4*); +bool_t xdr_state_owner4 (XDR *, NFS41::state_owner4*); +bool_t xdr_open_owner4 (XDR *, NFS41::open_owner4*); +bool_t xdr_lock_owner4 (XDR *, NFS41::lock_owner4*); +bool_t xdr_nfs_lock_type4 (XDR *, NFS41::nfs_lock_type4*); +bool_t xdr_ssv_subkey4 (XDR *, NFS41::ssv_subkey4*); +bool_t xdr_ssv_mic_plain_tkn4 (XDR *, NFS41::ssv_mic_plain_tkn4*); +bool_t xdr_ssv_mic_tkn4 (XDR *, NFS41::ssv_mic_tkn4*); +bool_t xdr_ssv_seal_plain_tkn4 (XDR *, NFS41::ssv_seal_plain_tkn4*); +bool_t xdr_ssv_seal_cipher_tkn4 (XDR *, NFS41::ssv_seal_cipher_tkn4*); +bool_t xdr_fs_locations_server4 (XDR *, NFS41::fs_locations_server4*); +bool_t xdr_fs_locations_item4 (XDR *, NFS41::fs_locations_item4*); +bool_t xdr_fs_locations_info4 (XDR *, NFS41::fs_locations_info4*); +bool_t xdr_fattr4_fs_locations_info (XDR *, NFS41::fattr4_fs_locations_info*); +bool_t xdr_nfl_util4 (XDR *, NFS41::nfl_util4*); +bool_t xdr_filelayout_hint_care4 (XDR *, NFS41::filelayout_hint_care4*); +bool_t xdr_nfsv4_1_file_layouthint4 (XDR *, NFS41::nfsv4_1_file_layouthint4*); +bool_t xdr_multipath_list4 (XDR *, NFS41::multipath_list4*); +bool_t xdr_nfsv4_1_file_layout_ds_addr4 (XDR *, NFS41::nfsv4_1_file_layout_ds_addr4*); +bool_t xdr_nfsv4_1_file_layout4 (XDR *, NFS41::nfsv4_1_file_layout4*); +bool_t xdr_NULL4args (XDR *, NFS41::NULL4args*); // for compatibility +bool_t xdr_NULL4res (XDR *, NFS41::NULL4res*); // for compatibility +bool_t xdr_ACCESS4args (XDR *, NFS41::ACCESS4args*); +bool_t xdr_ACCESS4resok (XDR *, NFS41::ACCESS4resok*); +bool_t xdr_ACCESS4res (XDR *, NFS41::ACCESS4res*); +bool_t xdr_CLOSE4args (XDR *, NFS41::CLOSE4args*); +bool_t xdr_CLOSE4res (XDR *, NFS41::CLOSE4res*); +bool_t xdr_COMMIT4args (XDR *, NFS41::COMMIT4args*); +bool_t xdr_COMMIT4resok (XDR *, NFS41::COMMIT4resok*); +bool_t xdr_COMMIT4res (XDR *, NFS41::COMMIT4res*); +bool_t xdr_createtype4 (XDR *, NFS41::createtype4*); +bool_t xdr_CREATE4args (XDR *, NFS41::CREATE4args*); +bool_t xdr_CREATE4resok (XDR *, NFS41::CREATE4resok*); +bool_t xdr_CREATE4res (XDR *, NFS41::CREATE4res*); +bool_t xdr_DELEGPURGE4args (XDR *, NFS41::DELEGPURGE4args*); +bool_t xdr_DELEGPURGE4res (XDR *, NFS41::DELEGPURGE4res*); +bool_t xdr_DELEGRETURN4args (XDR *, NFS41::DELEGRETURN4args*); +bool_t xdr_DELEGRETURN4res (XDR *, NFS41::DELEGRETURN4res*); +bool_t xdr_GETATTR4args (XDR *, NFS41::GETATTR4args*); +bool_t xdr_GETATTR4resok (XDR *, NFS41::GETATTR4resok*); +bool_t xdr_GETATTR4res (XDR *, NFS41::GETATTR4res*); +bool_t xdr_GETFH4resok (XDR *, NFS41::GETFH4resok*); +bool_t xdr_GETFH4res (XDR *, NFS41::GETFH4res*); +bool_t xdr_LINK4args (XDR *, NFS41::LINK4args*); +bool_t xdr_LINK4resok (XDR *, NFS41::LINK4resok*); +bool_t xdr_LINK4res (XDR *, NFS41::LINK4res*); +bool_t xdr_open_to_lock_owner4 (XDR *, NFS41::open_to_lock_owner4*); +bool_t xdr_exist_lock_owner4 (XDR *, NFS41::exist_lock_owner4*); +bool_t xdr_locker4 (XDR *, NFS41::locker4*); +bool_t xdr_LOCK4args (XDR *, NFS41::LOCK4args*); +bool_t xdr_LOCK4denied (XDR *, NFS41::LOCK4denied*); +bool_t xdr_LOCK4resok (XDR *, NFS41::LOCK4resok*); +bool_t xdr_LOCK4res (XDR *, NFS41::LOCK4res*); +bool_t xdr_LOCKT4args (XDR *, NFS41::LOCKT4args*); +bool_t xdr_LOCKT4res (XDR *, NFS41::LOCKT4res*); +bool_t xdr_LOCKU4args (XDR *, NFS41::LOCKU4args*); +bool_t xdr_LOCKU4res (XDR *, NFS41::LOCKU4res*); +bool_t xdr_LOOKUP4args (XDR *, NFS41::LOOKUP4args*); +bool_t xdr_LOOKUP4res (XDR *, NFS41::LOOKUP4res*); +bool_t xdr_LOOKUPP4res (XDR *, NFS41::LOOKUPP4res*); +bool_t xdr_NVERIFY4args (XDR *, NFS41::NVERIFY4args*); +bool_t xdr_NVERIFY4res (XDR *, NFS41::NVERIFY4res*); +bool_t xdr_createmode4 (XDR *, NFS41::createmode4*); +bool_t xdr_creatverfattr (XDR *, NFS41::creatverfattr*); +bool_t xdr_createhow4 (XDR *, NFS41::createhow4*); +bool_t xdr_opentype4 (XDR *, NFS41::opentype4*); +bool_t xdr_openflag4 (XDR *, NFS41::openflag4*); +bool_t xdr_limit_by4 (XDR *, NFS41::limit_by4*); +bool_t xdr_nfs_modified_limit4 (XDR *, NFS41::nfs_modified_limit4*); +bool_t xdr_nfs_space_limit4 (XDR *, NFS41::nfs_space_limit4*); +bool_t xdr_open_delegation_type4 (XDR *, NFS41::open_delegation_type4*); +bool_t xdr_open_claim_type4 (XDR *, NFS41::open_claim_type4*); +bool_t xdr_open_claim_delegate_cur4 (XDR *, NFS41::open_claim_delegate_cur4*); +bool_t xdr_open_claim4 (XDR *, NFS41::open_claim4*); +bool_t xdr_OPEN4args (XDR *, NFS41::OPEN4args*); +bool_t xdr_open_read_delegation4 (XDR *, NFS41::open_read_delegation4*); +bool_t xdr_open_write_delegation4 (XDR *, NFS41::open_write_delegation4*); +bool_t xdr_why_no_delegation4 (XDR *, NFS41::why_no_delegation4*); +bool_t xdr_open_none_delegation4 (XDR *, NFS41::open_none_delegation4*); +bool_t xdr_open_delegation4 (XDR *, NFS41::open_delegation4*); +bool_t xdr_OPEN4resok (XDR *, NFS41::OPEN4resok*); +bool_t xdr_OPEN4res (XDR *, NFS41::OPEN4res*); +bool_t xdr_OPENATTR4args (XDR *, NFS41::OPENATTR4args*); +bool_t xdr_OPENATTR4res (XDR *, NFS41::OPENATTR4res*); +bool_t xdr_OPEN_CONFIRM4args (XDR *, NFS41::OPEN_CONFIRM4args*); +bool_t xdr_OPEN_CONFIRM4resok (XDR *, NFS41::OPEN_CONFIRM4resok*); +bool_t xdr_OPEN_CONFIRM4res (XDR *, NFS41::OPEN_CONFIRM4res*); +bool_t xdr_OPEN_DOWNGRADE4args (XDR *, NFS41::OPEN_DOWNGRADE4args*); +bool_t xdr_OPEN_DOWNGRADE4resok (XDR *, NFS41::OPEN_DOWNGRADE4resok*); +bool_t xdr_OPEN_DOWNGRADE4res (XDR *, NFS41::OPEN_DOWNGRADE4res*); +bool_t xdr_PUTFH4args (XDR *, NFS41::PUTFH4args*); +bool_t xdr_PUTFH4res (XDR *, NFS41::PUTFH4res*); +bool_t xdr_PUTPUBFH4res (XDR *, NFS41::PUTPUBFH4res*); +bool_t xdr_PUTROOTFH4res (XDR *, NFS41::PUTROOTFH4res*); +bool_t xdr_READ4args (XDR *, NFS41::READ4args*); +bool_t xdr_READ4resok (XDR *, NFS41::READ4resok*); +bool_t xdr_READ4res (XDR *, NFS41::READ4res*); +bool_t xdr_READDIR4args (XDR *, NFS41::READDIR4args*); +bool_t xdr_entry4 (XDR *, NFS41::entry4*); +bool_t xdr_dirlist4 (XDR *, NFS41::dirlist4*); +bool_t xdr_READDIR4resok (XDR *, NFS41::READDIR4resok*); +bool_t xdr_READDIR4res (XDR *, NFS41::READDIR4res*); +bool_t xdr_READLINK4resok (XDR *, NFS41::READLINK4resok*); +bool_t xdr_READLINK4res (XDR *, NFS41::READLINK4res*); +bool_t xdr_REMOVE4args (XDR *, NFS41::REMOVE4args*); +bool_t xdr_REMOVE4resok (XDR *, NFS41::REMOVE4resok*); +bool_t xdr_REMOVE4res (XDR *, NFS41::REMOVE4res*); +bool_t xdr_RENAME4args (XDR *, NFS41::RENAME4args*); +bool_t xdr_RENAME4resok (XDR *, NFS41::RENAME4resok*); +bool_t xdr_RENAME4res (XDR *, NFS41::RENAME4res*); +bool_t xdr_RENEW4args (XDR *, NFS41::RENEW4args*); +bool_t xdr_RENEW4res (XDR *, NFS41::RENEW4res*); +bool_t xdr_RESTOREFH4res (XDR *, NFS41::RESTOREFH4res*); +bool_t xdr_SAVEFH4res (XDR *, NFS41::SAVEFH4res*); +bool_t xdr_SECINFO4args (XDR *, NFS41::SECINFO4args*); +bool_t xdr_rpc_gss_svc_t (XDR *, NFS41::rpc_gss_svc_t*); +bool_t xdr_rpcsec_gss_info (XDR *, NFS41::rpcsec_gss_info*); +bool_t xdr_secinfo4 (XDR *, NFS41::secinfo4*); +bool_t xdr_SECINFO4resok (XDR *, NFS41::SECINFO4resok*); +bool_t xdr_SECINFO4res (XDR *, NFS41::SECINFO4res*); +bool_t xdr_SETATTR4args (XDR *, NFS41::SETATTR4args*); +bool_t xdr_SETATTR4res (XDR *, NFS41::SETATTR4res*); +bool_t xdr_SETCLIENTID4args (XDR *, NFS41::SETCLIENTID4args*); +bool_t xdr_SETCLIENTID4resok (XDR *, NFS41::SETCLIENTID4resok*); +bool_t xdr_SETCLIENTID4res (XDR *, NFS41::SETCLIENTID4res*); +bool_t xdr_SETCLIENTID_CONFIRM4args (XDR *, NFS41::SETCLIENTID_CONFIRM4args*); +bool_t xdr_SETCLIENTID_CONFIRM4res (XDR *, NFS41::SETCLIENTID_CONFIRM4res*); +bool_t xdr_VERIFY4args (XDR *, NFS41::VERIFY4args*); +bool_t xdr_VERIFY4res (XDR *, NFS41::VERIFY4res*); +bool_t xdr_stable_how4 (XDR *, NFS41::stable_how4*); +bool_t xdr_WRITE4args (XDR *, NFS41::WRITE4args*); +bool_t xdr_WRITE4resok (XDR *, NFS41::WRITE4resok*); +bool_t xdr_WRITE4res (XDR *, NFS41::WRITE4res*); +bool_t xdr_RELEASE_LOCKOWNER4args (XDR *, NFS41::RELEASE_LOCKOWNER4args*); +bool_t xdr_RELEASE_LOCKOWNER4res (XDR *, NFS41::RELEASE_LOCKOWNER4res*); +bool_t xdr_ILLEGAL4res (XDR *, NFS41::ILLEGAL4res*); +bool_t xdr_gsshandle4_t (XDR *, NFS41::gsshandle4_t*); +bool_t xdr_gss_cb_handles4 (XDR *, NFS41::gss_cb_handles4*); +bool_t xdr_callback_sec_parms4 (XDR *, NFS41::callback_sec_parms4*); +bool_t xdr_BACKCHANNEL_CTL4args (XDR *, NFS41::BACKCHANNEL_CTL4args*); +bool_t xdr_BACKCHANNEL_CTL4res (XDR *, NFS41::BACKCHANNEL_CTL4res*); +bool_t xdr_channel_dir_from_client4 (XDR *, NFS41::channel_dir_from_client4*); +bool_t xdr_BIND_CONN_TO_SESSION4args (XDR *, NFS41::BIND_CONN_TO_SESSION4args*); +bool_t xdr_channel_dir_from_server4 (XDR *, NFS41::channel_dir_from_server4*); +bool_t xdr_BIND_CONN_TO_SESSION4resok (XDR *, NFS41::BIND_CONN_TO_SESSION4resok*); +bool_t xdr_BIND_CONN_TO_SESSION4res (XDR *, NFS41::BIND_CONN_TO_SESSION4res*); +bool_t xdr_state_protect_ops4 (XDR *, NFS41::state_protect_ops4*); +bool_t xdr_ssv_sp_parms4 (XDR *, NFS41::ssv_sp_parms4*); +bool_t xdr_state_protect_how4 (XDR *, NFS41::state_protect_how4*); +bool_t xdr_state_protect4_a (XDR *, NFS41::state_protect4_a*); +bool_t xdr_EXCHANGE_ID4args (XDR *, NFS41::EXCHANGE_ID4args*); +bool_t xdr_ssv_prot_info4 (XDR *, NFS41::ssv_prot_info4*); +bool_t xdr_state_protect4_r (XDR *, NFS41::state_protect4_r*); +bool_t xdr_EXCHANGE_ID4resok (XDR *, NFS41::EXCHANGE_ID4resok*); +bool_t xdr_EXCHANGE_ID4res (XDR *, NFS41::EXCHANGE_ID4res*); +bool_t xdr_channel_attrs4 (XDR *, NFS41::channel_attrs4*); +bool_t xdr_CREATE_SESSION4args (XDR *, NFS41::CREATE_SESSION4args*); +bool_t xdr_CREATE_SESSION4resok (XDR *, NFS41::CREATE_SESSION4resok*); +bool_t xdr_CREATE_SESSION4res (XDR *, NFS41::CREATE_SESSION4res*); +bool_t xdr_DESTROY_SESSION4args (XDR *, NFS41::DESTROY_SESSION4args*); +bool_t xdr_DESTROY_SESSION4res (XDR *, NFS41::DESTROY_SESSION4res*); +bool_t xdr_FREE_STATEID4args (XDR *, NFS41::FREE_STATEID4args*); +bool_t xdr_FREE_STATEID4res (XDR *, NFS41::FREE_STATEID4res*); +bool_t xdr_attr_notice4 (XDR *, NFS41::attr_notice4*); +bool_t xdr_GET_DIR_DELEGATION4args (XDR *, NFS41::GET_DIR_DELEGATION4args*); +bool_t xdr_GET_DIR_DELEGATION4resok (XDR *, NFS41::GET_DIR_DELEGATION4resok*); +bool_t xdr_gddrnf4_status (XDR *, NFS41::gddrnf4_status*); +bool_t xdr_GET_DIR_DELEGATION4res_non_fatal (XDR *, NFS41::GET_DIR_DELEGATION4res_non_fatal*); +bool_t xdr_GET_DIR_DELEGATION4res (XDR *, NFS41::GET_DIR_DELEGATION4res*); +bool_t xdr_GETDEVICEINFO4args (XDR *, NFS41::GETDEVICEINFO4args*); +bool_t xdr_GETDEVICEINFO4resok (XDR *, NFS41::GETDEVICEINFO4resok*); +bool_t xdr_GETDEVICEINFO4res (XDR *, NFS41::GETDEVICEINFO4res*); +bool_t xdr_GETDEVICELIST4args (XDR *, NFS41::GETDEVICELIST4args*); +bool_t xdr_GETDEVICELIST4resok (XDR *, NFS41::GETDEVICELIST4resok*); +bool_t xdr_GETDEVICELIST4res (XDR *, NFS41::GETDEVICELIST4res*); +bool_t xdr_newtime4 (XDR *, NFS41::newtime4*); +bool_t xdr_newoffset4 (XDR *, NFS41::newoffset4*); +bool_t xdr_LAYOUTCOMMIT4args (XDR *, NFS41::LAYOUTCOMMIT4args*); +bool_t xdr_newsize4 (XDR *, NFS41::newsize4*); +bool_t xdr_LAYOUTCOMMIT4resok (XDR *, NFS41::LAYOUTCOMMIT4resok*); +bool_t xdr_LAYOUTCOMMIT4res (XDR *, NFS41::LAYOUTCOMMIT4res*); +bool_t xdr_LAYOUTGET4args (XDR *, NFS41::LAYOUTGET4args*); +bool_t xdr_LAYOUTGET4resok (XDR *, NFS41::LAYOUTGET4resok*); +bool_t xdr_LAYOUTGET4res (XDR *, NFS41::LAYOUTGET4res*); +bool_t xdr_LAYOUTRETURN4args (XDR *, NFS41::LAYOUTRETURN4args*); +bool_t xdr_layoutreturn_stateid (XDR *, NFS41::layoutreturn_stateid*); +bool_t xdr_LAYOUTRETURN4res (XDR *, NFS41::LAYOUTRETURN4res*); +bool_t xdr_secinfo_style4 (XDR *, NFS41::secinfo_style4*); +bool_t xdr_SECINFO_NO_NAME4args (XDR *, NFS41::SECINFO_NO_NAME4args*); +bool_t xdr_SECINFO_NO_NAME4res (XDR *, NFS41::SECINFO_NO_NAME4res*); +bool_t xdr_SEQUENCE4args (XDR *, NFS41::SEQUENCE4args*); +bool_t xdr_SEQUENCE4resok (XDR *, NFS41::SEQUENCE4resok*); +bool_t xdr_SEQUENCE4res (XDR *, NFS41::SEQUENCE4res*); +bool_t xdr_ssa_digest_input4 (XDR *, NFS41::ssa_digest_input4*); +bool_t xdr_SET_SSV4args (XDR *, NFS41::SET_SSV4args*); +bool_t xdr_ssr_digest_input4 (XDR *, NFS41::ssr_digest_input4*); +bool_t xdr_SET_SSV4resok (XDR *, NFS41::SET_SSV4resok*); +bool_t xdr_SET_SSV4res (XDR *, NFS41::SET_SSV4res*); +bool_t xdr_TEST_STATEID4args (XDR *, NFS41::TEST_STATEID4args*); +bool_t xdr_TEST_STATEID4resok (XDR *, NFS41::TEST_STATEID4resok*); +bool_t xdr_TEST_STATEID4res (XDR *, NFS41::TEST_STATEID4res*); +bool_t xdr_deleg_claim4 (XDR *, NFS41::deleg_claim4*); +bool_t xdr_WANT_DELEGATION4args (XDR *, NFS41::WANT_DELEGATION4args*); +bool_t xdr_WANT_DELEGATION4res (XDR *, NFS41::WANT_DELEGATION4res*); +bool_t xdr_DESTROY_CLIENTID4args (XDR *, NFS41::DESTROY_CLIENTID4args*); +bool_t xdr_DESTROY_CLIENTID4res (XDR *, NFS41::DESTROY_CLIENTID4res*); +bool_t xdr_RECLAIM_COMPLETE4args (XDR *, NFS41::RECLAIM_COMPLETE4args*); +bool_t xdr_RECLAIM_COMPLETE4res (XDR *, NFS41::RECLAIM_COMPLETE4res*); +bool_t xdr_nfs_opnum4 (XDR *, NFS41::nfs_opnum4*); +bool_t xdr_nfs_argop4 (XDR *, NFS41::nfs_argop4*); +bool_t xdr_nfs_resop4 (XDR *, NFS41::nfs_resop4*); +bool_t xdr_COMPOUND4args (XDR *, NFS41::COMPOUND4args*); +bool_t xdr_COMPOUND4res (XDR *, NFS41::COMPOUND4res*); +bool_t xdr_CB_GETATTR4args (XDR *, NFS41::CB_GETATTR4args*); +bool_t xdr_CB_GETATTR4resok (XDR *, NFS41::CB_GETATTR4resok*); +bool_t xdr_CB_GETATTR4res (XDR *, NFS41::CB_GETATTR4res*); +bool_t xdr_CB_RECALL4args (XDR *, NFS41::CB_RECALL4args*); +bool_t xdr_CB_RECALL4res (XDR *, NFS41::CB_RECALL4res*); +bool_t xdr_CB_ILLEGAL4res (XDR *, NFS41::CB_ILLEGAL4res*); +bool_t xdr_layoutrecall_type4 (XDR *, NFS41::layoutrecall_type4*); +bool_t xdr_layoutrecall_file4 (XDR *, NFS41::layoutrecall_file4*); +bool_t xdr_layoutrecall4 (XDR *, NFS41::layoutrecall4*); +bool_t xdr_CB_LAYOUTRECALL4args (XDR *, NFS41::CB_LAYOUTRECALL4args*); +bool_t xdr_CB_LAYOUTRECALL4res (XDR *, NFS41::CB_LAYOUTRECALL4res*); +bool_t xdr_notify_type4 (XDR *, NFS41::notify_type4*); +bool_t xdr_notify_entry4 (XDR *, NFS41::notify_entry4*); +bool_t xdr_prev_entry4 (XDR *, NFS41::prev_entry4*); +bool_t xdr_notify_remove4 (XDR *, NFS41::notify_remove4*); +bool_t xdr_notify_add4 (XDR *, NFS41::notify_add4*); +bool_t xdr_notify_attr4 (XDR *, NFS41::notify_attr4*); +bool_t xdr_notify_rename4 (XDR *, NFS41::notify_rename4*); +bool_t xdr_notify_verifier4 (XDR *, NFS41::notify_verifier4*); +bool_t xdr_notifylist4 (XDR *, NFS41::notifylist4*); +bool_t xdr_notify4 (XDR *, NFS41::notify4*); +bool_t xdr_CB_NOTIFY4args (XDR *, NFS41::CB_NOTIFY4args*); +bool_t xdr_CB_NOTIFY4res (XDR *, NFS41::CB_NOTIFY4res*); +bool_t xdr_CB_PUSH_DELEG4args (XDR *, NFS41::CB_PUSH_DELEG4args*); +bool_t xdr_CB_PUSH_DELEG4res (XDR *, NFS41::CB_PUSH_DELEG4res*); +bool_t xdr_CB_RECALL_ANY4args (XDR *, NFS41::CB_RECALL_ANY4args*); +bool_t xdr_CB_RECALL_ANY4res (XDR *, NFS41::CB_RECALL_ANY4res*); +bool_t xdr_CB_RECALLABLE_OBJ_AVAIL4args (XDR *, NFS41::CB_RECALLABLE_OBJ_AVAIL4args*); +bool_t xdr_CB_RECALLABLE_OBJ_AVAIL4res (XDR *, NFS41::CB_RECALLABLE_OBJ_AVAIL4res*); +bool_t xdr_CB_RECALL_SLOT4args (XDR *, NFS41::CB_RECALL_SLOT4args*); +bool_t xdr_CB_RECALL_SLOT4res (XDR *, NFS41::CB_RECALL_SLOT4res*); +bool_t xdr_referring_call4 (XDR *, NFS41::referring_call4*); +bool_t xdr_referring_call_list4 (XDR *, NFS41::referring_call_list4*); +bool_t xdr_CB_SEQUENCE4args (XDR *, NFS41::CB_SEQUENCE4args*); +bool_t xdr_CB_SEQUENCE4resok (XDR *, NFS41::CB_SEQUENCE4resok*); +bool_t xdr_CB_SEQUENCE4res (XDR *, NFS41::CB_SEQUENCE4res*); +bool_t xdr_CB_WANTS_CANCELLED4args (XDR *, NFS41::CB_WANTS_CANCELLED4args*); +bool_t xdr_CB_WANTS_CANCELLED4res (XDR *, NFS41::CB_WANTS_CANCELLED4res*); +bool_t xdr_CB_NOTIFY_LOCK4args (XDR *, NFS41::CB_NOTIFY_LOCK4args*); +bool_t xdr_CB_NOTIFY_LOCK4res (XDR *, NFS41::CB_NOTIFY_LOCK4res*); +bool_t xdr_notify_deviceid_type4 (XDR *, NFS41::notify_deviceid_type4*); +bool_t xdr_notify_deviceid_delete4 (XDR *, NFS41::notify_deviceid_delete4*); +bool_t xdr_notify_deviceid_change4 (XDR *, NFS41::notify_deviceid_change4*); +bool_t xdr_CB_NOTIFY_DEVICEID4args (XDR *, NFS41::CB_NOTIFY_DEVICEID4args*); +bool_t xdr_CB_NOTIFY_DEVICEID4res (XDR *, NFS41::CB_NOTIFY_DEVICEID4res*); +bool_t xdr_nfs_cb_opnum4 (XDR *, NFS41::nfs_cb_opnum4*); +bool_t xdr_nfs_cb_argop4 (XDR *, NFS41::nfs_cb_argop4*); +bool_t xdr_nfs_cb_resop4 (XDR *, NFS41::nfs_cb_resop4*); +bool_t xdr_CB_COMPOUND4args (XDR *, NFS41::CB_COMPOUND4args*); +bool_t xdr_CB_COMPOUND4res (XDR *, NFS41::CB_COMPOUND4res*); + +// Procedure 0: NULL - Do nothing +inline auto proc_t_of(NFS41::NULL4args&)->decltype(&xdr_NULL4args) +{ + return xdr_NULL4args; +} + +inline auto proc_t_of(NFS41::NULL4res&)->decltype(&xdr_NULL4res) +{ + return &xdr_NULL4res; +} + +// Procedure 1: COMPOUND +inline auto proc_t_of(NFS41::COMPOUND4args&)->decltype(&xdr_COMPOUND4args) +{ + return &xdr_COMPOUND4args; +} + +inline auto proc_t_of(NFS41::COMPOUND4res&)->decltype(&xdr_COMPOUND4res) +{ + return &xdr_COMPOUND4res; +} + +#define NST_PUBLIC __attribute__ ((visibility("default"))) + +extern"C" +NST_PUBLIC +const char* print_nfs41_procedures(const ProcEnumNFS41::NFSProcedure proc); + +std::ostream& operator<<(std::ostream& out, const ProcEnumNFS41::NFSProcedure proc); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_ftype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfsstat4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::bitmap4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_fh4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::sec_oid4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::utf8string& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::pathname4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfstime4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::time_how4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::settime4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fsid4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs_location4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs_locations4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfsace4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::change_policy4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfsacl41& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::mode_masked4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::specdata4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::netaddr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_impl_id4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::stateid4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layouttype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layout_content4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layouthint4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutiomode4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layout4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::device_addr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutupdate4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutreturn_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutreturn_file4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutreturn4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs4_status_type& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs4_status& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::threshold_item4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::mdsthreshold4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::retention_get4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::retention_set4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fattr4_acl& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fattr4_fs_layout_types& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fattr4_layout_types& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fattr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::change_info4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::cb_client4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_client_id4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::client_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::server_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::state_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_lock_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_subkey4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_mic_plain_tkn4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_mic_tkn4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_seal_plain_tkn4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_seal_cipher_tkn4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs_locations_server4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs_locations_item4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::fs_locations_info4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::filelayout_hint_care4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfsv4_1_file_layouthint4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::multipath_list4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfsv4_1_file_layout_ds_addr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfsv4_1_file_layout4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::createtype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_to_lock_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::exist_lock_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::locker4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::createmode4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::creatverfattr& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::createhow4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::opentype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::openflag4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::limit_by4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_modified_limit4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::nfs_space_limit4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_delegation_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_claim_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_claim_delegate_cur4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_claim4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_read_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_write_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::why_no_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_none_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::open_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::entry4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::dirlist4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::rpc_gss_svc_t& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::rpcsec_gss_info& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::secinfo4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::stable_how4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::gsshandle4_t& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::gss_cb_handles4& obj); +std::ostream& operator<<(std::ostream& out, const authunix_parms& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::authsys_parms& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::callback_sec_parms4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::channel_dir_from_client4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::channel_dir_from_server4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::state_protect_ops4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_sp_parms4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::state_protect_how4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::state_protect4_a& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssv_prot_info4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::state_protect4_r& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::channel_attrs4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::gddrnf4_status& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::newtime4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::newoffset4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::newsize4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutreturn_stateid& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::secinfo_style4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::SEQUENCE4args& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssa_digest_input4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::ssr_digest_input4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::deleg_claim4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutrecall_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutrecall_file4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::layoutrecall4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_entry4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::prev_entry4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_remove4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_add4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_attr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_rename4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_verifier4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notifylist4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::referring_call4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::referring_call_list4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_deviceid_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_deviceid_delete4& obj); +std::ostream& operator<<(std::ostream& out, const NFS41::notify_deviceid_change4& obj); + +} // namespace NFS41 +} // namespace protocols +} // namespace NST +//------------------------------------------------------------------------------ +#endif//NFS41_UTILS_H +//------------------------------------------------------------------------------ diff --git a/src/protocols/nfs4/nfs4_rpcgen.cpp b/src/protocols/nfs4/nfs4_rpcgen.cpp deleted file mode 100644 index 99d2b7e..0000000 --- a/src/protocols/nfs4/nfs4_rpcgen.cpp +++ /dev/null @@ -1,2800 +0,0 @@ -//------------------------------------------------------------------------------ -// Author: Alexey Costroma -// Description: Definition and fill up NFSv4 procedures. -// Copyright (c) 2014 EPAM Systems -//------------------------------------------------------------------------------ -/* - This file is part of Nfstrace. - - Nfstrace is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, version 2 of the License. - - Nfstrace is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. -*/ -//------------------------------------------------------------------------------ -#include "api/nfs4_types_rpcgen.h" -//------------------------------------------------------------------------------ -namespace rpcgen -{ - -bool_t -xdr_int32_t (XDR *xdrs, int32_t *objp) -{ - if (!xdr_int (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_uint32_t (XDR *xdrs, uint32_t *objp) -{ - if (!xdr_u_int (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_int64_t (XDR *xdrs, int64_t *objp) -{ - if (!xdr_longlong_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_uint64_t (XDR *xdrs, uint64_t *objp) -{ - if (!xdr_u_longlong_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_ftype4 (XDR *xdrs, nfs_ftype4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfsstat4 (XDR *xdrs, nfsstat4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_bitmap4 (XDR *xdrs, bitmap4 *objp) -{ - if (!xdr_array (xdrs, (char **)&objp->bitmap4_val, (u_int *) &objp->bitmap4_len, ~0, - sizeof (uint32_t), (xdrproc_t) xdr_uint32_t)) - return FALSE; - return TRUE; -} - -bool_t -xdr_offset4 (XDR *xdrs, offset4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_count4 (XDR *xdrs, count4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_length4 (XDR *xdrs, length4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_clientid4 (XDR *xdrs, clientid4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_seqid4 (XDR *xdrs, seqid4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_utf8string (XDR *xdrs, utf8string *objp) -{ - if (!xdr_bytes (xdrs, (char **)&objp->utf8string_val, (u_int *) &objp->utf8string_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_utf8str_cis (XDR *xdrs, utf8str_cis *objp) -{ - if (!xdr_utf8string (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_utf8str_cs (XDR *xdrs, utf8str_cs *objp) -{ - if (!xdr_utf8string (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_utf8str_mixed (XDR *xdrs, utf8str_mixed *objp) -{ - if (!xdr_utf8string (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_component4 (XDR *xdrs, component4 *objp) -{ - if (!xdr_utf8str_cs (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pathname4 (XDR *xdrs, pathname4 *objp) -{ - if (!xdr_array (xdrs, (char **)&objp->pathname4_val, (u_int *) &objp->pathname4_len, ~0, - sizeof (component4), (xdrproc_t) xdr_component4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_lockid4 (XDR *xdrs, nfs_lockid4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_cookie4 (XDR *xdrs, nfs_cookie4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_linktext4 (XDR *xdrs, linktext4 *objp) -{ - if (!xdr_utf8str_cs (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_sec_oid4 (XDR *xdrs, sec_oid4 *objp) -{ - if (!xdr_bytes (xdrs, (char **)&objp->sec_oid4_val, (u_int *) &objp->sec_oid4_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_qop4 (XDR *xdrs, qop4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_mode4 (XDR *xdrs, mode4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_changeid4 (XDR *xdrs, changeid4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_verifier4 (XDR *xdrs, verifier4 objp) -{ - if (!xdr_opaque (xdrs, objp, NFS4_VERIFIER_SIZE)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfstime4 (XDR *xdrs, nfstime4 *objp) -{ - if (!rpcgen::xdr_int64_t (xdrs, &objp->seconds)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->nseconds)) - return FALSE; - return TRUE; -} - -bool_t -xdr_time_how4 (XDR *xdrs, time_how4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_settime4 (XDR *xdrs, settime4 *objp) -{ - if (!xdr_time_how4 (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME4: - if (!xdr_nfstime4 (xdrs, &objp->settime4_u.time)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_nfs_fh4 (XDR *xdrs, nfs_fh4 *objp) -{ - if (!xdr_bytes (xdrs, (char **)&objp->nfs_fh4_val, (u_int *) &objp->nfs_fh4_len, NFS4_FHSIZE)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fsid4 (XDR *xdrs, fsid4 *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, &objp->major)) - return FALSE; - if (!rpcgen::xdr_uint64_t (xdrs, &objp->minor)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fs_location4 (XDR *xdrs, fs_location4 *objp) -{ - if (!xdr_array (xdrs, (char **)&objp->server.server_val, (u_int *) &objp->server.server_len, ~0, - sizeof (utf8str_cis), (xdrproc_t) xdr_utf8str_cis)) - return FALSE; - if (!xdr_pathname4 (xdrs, &objp->rootpath)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fs_locations4 (XDR *xdrs, fs_locations4 *objp) -{ - if (!xdr_pathname4 (xdrs, &objp->fs_root)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->locations.locations_val, (u_int *) &objp->locations.locations_len, ~0, - sizeof (fs_location4), (xdrproc_t) xdr_fs_location4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_acetype4 (XDR *xdrs, acetype4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_aceflag4 (XDR *xdrs, aceflag4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_acemask4 (XDR *xdrs, acemask4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfsace4 (XDR *xdrs, nfsace4 *objp) -{ - if (!xdr_acetype4 (xdrs, &objp->type)) - return FALSE; - if (!xdr_aceflag4 (xdrs, &objp->flag)) - return FALSE; - if (!xdr_acemask4 (xdrs, &objp->access_mask)) - return FALSE; - if (!xdr_utf8str_mixed (xdrs, &objp->who)) - return FALSE; - return TRUE; -} - -bool_t -xdr_specdata4 (XDR *xdrs, specdata4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->specdata1)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->specdata2)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_supported_attrs (XDR *xdrs, fattr4_supported_attrs *objp) -{ - if (!xdr_bitmap4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_type (XDR *xdrs, fattr4_type *objp) -{ - if (!xdr_nfs_ftype4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_fh_expire_type (XDR *xdrs, fattr4_fh_expire_type *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_change (XDR *xdrs, fattr4_change *objp) -{ - if (!xdr_changeid4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_size (XDR *xdrs, fattr4_size *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_link_support (XDR *xdrs, fattr4_link_support *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_symlink_support (XDR *xdrs, fattr4_symlink_support *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_named_attr (XDR *xdrs, fattr4_named_attr *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_fsid (XDR *xdrs, fattr4_fsid *objp) -{ - if (!xdr_fsid4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_unique_handles (XDR *xdrs, fattr4_unique_handles *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_lease_time (XDR *xdrs, fattr4_lease_time *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_rdattr_error (XDR *xdrs, fattr4_rdattr_error *objp) -{ - if (!xdr_nfsstat4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_acl (XDR *xdrs, fattr4_acl *objp) -{ - if (!xdr_array (xdrs, (char **)&objp->fattr4_acl_val, (u_int *) &objp->fattr4_acl_len, ~0, - sizeof (nfsace4), (xdrproc_t) xdr_nfsace4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_aclsupport (XDR *xdrs, fattr4_aclsupport *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_archive (XDR *xdrs, fattr4_archive *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_cansettime (XDR *xdrs, fattr4_cansettime *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_case_insensitive (XDR *xdrs, fattr4_case_insensitive *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_case_preserving (XDR *xdrs, fattr4_case_preserving *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_chown_restricted (XDR *xdrs, fattr4_chown_restricted *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_fileid (XDR *xdrs, fattr4_fileid *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_files_avail (XDR *xdrs, fattr4_files_avail *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_filehandle (XDR *xdrs, fattr4_filehandle *objp) -{ - if (!xdr_nfs_fh4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_files_free (XDR *xdrs, fattr4_files_free *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_files_total (XDR *xdrs, fattr4_files_total *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_fs_locations (XDR *xdrs, fattr4_fs_locations *objp) -{ - if (!xdr_fs_locations4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_hidden (XDR *xdrs, fattr4_hidden *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_homogeneous (XDR *xdrs, fattr4_homogeneous *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_maxfilesize (XDR *xdrs, fattr4_maxfilesize *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_maxlink (XDR *xdrs, fattr4_maxlink *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_maxname (XDR *xdrs, fattr4_maxname *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_maxread (XDR *xdrs, fattr4_maxread *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_maxwrite (XDR *xdrs, fattr4_maxwrite *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_mimetype (XDR *xdrs, fattr4_mimetype *objp) -{ - if (!xdr_utf8str_cs (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_mode (XDR *xdrs, fattr4_mode *objp) -{ - if (!xdr_mode4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_mounted_on_fileid (XDR *xdrs, fattr4_mounted_on_fileid *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_no_trunc (XDR *xdrs, fattr4_no_trunc *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_numlinks (XDR *xdrs, fattr4_numlinks *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_owner (XDR *xdrs, fattr4_owner *objp) -{ - if (!xdr_utf8str_mixed (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_owner_group (XDR *xdrs, fattr4_owner_group *objp) -{ - if (!xdr_utf8str_mixed (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_quota_avail_hard (XDR *xdrs, fattr4_quota_avail_hard *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_quota_avail_soft (XDR *xdrs, fattr4_quota_avail_soft *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_quota_used (XDR *xdrs, fattr4_quota_used *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_rawdev (XDR *xdrs, fattr4_rawdev *objp) -{ - if (!xdr_specdata4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_space_avail (XDR *xdrs, fattr4_space_avail *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_space_free (XDR *xdrs, fattr4_space_free *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_space_total (XDR *xdrs, fattr4_space_total *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_space_used (XDR *xdrs, fattr4_space_used *objp) -{ - if (!rpcgen::xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_system (XDR *xdrs, fattr4_system *objp) -{ - if (!xdr_bool (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_access (XDR *xdrs, fattr4_time_access *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_access_set (XDR *xdrs, fattr4_time_access_set *objp) -{ - if (!xdr_settime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_backup (XDR *xdrs, fattr4_time_backup *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_create (XDR *xdrs, fattr4_time_create *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_delta (XDR *xdrs, fattr4_time_delta *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_metadata (XDR *xdrs, fattr4_time_metadata *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_modify (XDR *xdrs, fattr4_time_modify *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4_time_modify_set (XDR *xdrs, fattr4_time_modify_set *objp) -{ - if (!xdr_settime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_attrlist4 (XDR *xdrs, attrlist4 *objp) -{ - if (!xdr_bytes (xdrs, (char **)&objp->attrlist4_val, (u_int *) &objp->attrlist4_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fattr4 (XDR *xdrs, fattr4 *objp) -{ - if (!xdr_bitmap4 (xdrs, &objp->attrmask)) - return FALSE; - if (!xdr_attrlist4 (xdrs, &objp->attr_vals)) - return FALSE; - return TRUE; -} - -bool_t -xdr_change_info4 (XDR *xdrs, change_info4 *objp) -{ - if (!xdr_bool (xdrs, &objp->atomic)) - return FALSE; - if (!xdr_changeid4 (xdrs, &objp->before)) - return FALSE; - if (!xdr_changeid4 (xdrs, &objp->after)) - return FALSE; - return TRUE; -} - -bool_t -xdr_clientaddr4 (XDR *xdrs, clientaddr4 *objp) -{ - if (!xdr_string (xdrs, &objp->r_netid, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->r_addr, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_cb_client4 (XDR *xdrs, cb_client4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->cb_program)) - return FALSE; - if (!xdr_clientaddr4 (xdrs, &objp->cb_location)) - return FALSE; - return TRUE; -} - -bool_t -xdr_stateid4 (XDR *xdrs, stateid4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->seqid)) - return FALSE; - if (!xdr_opaque (xdrs, objp->other, 12)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_client_id4 (XDR *xdrs, nfs_client_id4 *objp) -{ - if (!xdr_verifier4 (xdrs, objp->verifier)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->id.id_val, (u_int *) &objp->id.id_len, NFS4_OPAQUE_LIMIT)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_owner4 (XDR *xdrs, open_owner4 *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->owner.owner_val, (u_int *) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) - return FALSE; - return TRUE; -} - -bool_t -xdr_lock_owner4 (XDR *xdrs, lock_owner4 *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->owner.owner_val, (u_int *) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_lock_type4 (XDR *xdrs, nfs_lock_type4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -//for compatibility -bool_t -xdr_NULL4args(XDR*, NULL4args*) -{ - return TRUE; -} - -bool_t -xdr_NULL4res(XDR*, NULL4res*) -{ - return TRUE; -} - -bool_t -xdr_ACCESS4args (XDR *xdrs, ACCESS4args *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->access)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ACCESS4resok (XDR *xdrs, ACCESS4resok *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->supported)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->access)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ACCESS4res (XDR *xdrs, ACCESS4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_ACCESS4resok (xdrs, &objp->ACCESS4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_CLOSE4args (XDR *xdrs, CLOSE4args *objp) -{ - if (!xdr_seqid4 (xdrs, &objp->seqid)) - return FALSE; - if (!xdr_stateid4 (xdrs, &objp->open_stateid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CLOSE4res (XDR *xdrs, CLOSE4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_stateid4 (xdrs, &objp->CLOSE4res_u.open_stateid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_COMMIT4args (XDR *xdrs, COMMIT4args *objp) -{ - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count4 (xdrs, &objp->count)) - return FALSE; - return TRUE; -} - -bool_t -xdr_COMMIT4resok (XDR *xdrs, COMMIT4resok *objp) -{ - if (!xdr_verifier4 (xdrs, objp->writeverf)) - return FALSE; - return TRUE; -} - -bool_t -xdr_COMMIT4res (XDR *xdrs, COMMIT4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_COMMIT4resok (xdrs, &objp->COMMIT4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_createtype4 (XDR *xdrs, createtype4 *objp) -{ - if (!xdr_nfs_ftype4 (xdrs, &objp->type)) - return FALSE; - switch (objp->type) { - case NF4LNK: - if (!xdr_linktext4 (xdrs, &objp->createtype4_u.linkdata)) - return FALSE; - break; - case NF4BLK: - case NF4CHR: - if (!xdr_specdata4 (xdrs, &objp->createtype4_u.devdata)) - return FALSE; - break; - case NF4SOCK: - case NF4FIFO: - case NF4DIR: - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_CREATE4args (XDR *xdrs, CREATE4args *objp) -{ - if (!xdr_createtype4 (xdrs, &objp->objtype)) - return FALSE; - if (!xdr_component4 (xdrs, &objp->objname)) - return FALSE; - if (!xdr_fattr4 (xdrs, &objp->createattrs)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CREATE4resok (XDR *xdrs, CREATE4resok *objp) -{ - if (!xdr_change_info4 (xdrs, &objp->cinfo)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->attrset)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CREATE4res (XDR *xdrs, CREATE4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_CREATE4resok (xdrs, &objp->CREATE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_DELEGPURGE4args (XDR *xdrs, DELEGPURGE4args *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_DELEGPURGE4res (XDR *xdrs, DELEGPURGE4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_DELEGRETURN4args (XDR *xdrs, DELEGRETURN4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->deleg_stateid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_DELEGRETURN4res (XDR *xdrs, DELEGRETURN4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETATTR4args (XDR *xdrs, GETATTR4args *objp) -{ - if (!xdr_bitmap4 (xdrs, &objp->attr_request)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETATTR4resok (XDR *xdrs, GETATTR4resok *objp) -{ - if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETATTR4res (XDR *xdrs, GETATTR4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_GETATTR4resok (xdrs, &objp->GETATTR4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_notification_types4 (XDR *xdrs, notification_types4 *objp) -{ - if (!xdr_bitmap4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_notification_delay4 (XDR *xdrs, notification_delay4 *objp) -{ - if (!xdr_nfstime4 (xdrs, objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_dir_delegation_status4 (XDR *xdrs, dir_delegation_status4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GET_DIR_DELEGATION4args (XDR *xdrs, GET_DIR_DELEGATION4args *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - if (!xdr_notification_types4 (xdrs, &objp->notif_types)) - return FALSE; - if (!xdr_notification_delay4 (xdrs, &objp->dir_notif_delay)) - return FALSE; - if (!xdr_notification_delay4 (xdrs, &objp->dir_entry_notif_delay)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GET_DIR_DELEGATION4resok (XDR *xdrs, GET_DIR_DELEGATION4resok *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_dir_delegation_status4 (xdrs, &objp->status)) - return FALSE; - if (!xdr_notification_types4 (xdrs, &objp->notif_types)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->dir_notif_attrs)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->dir_entry_notif_attrs)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GET_DIR_DELEGATION4res (XDR *xdrs, GET_DIR_DELEGATION4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_GET_DIR_DELEGATION4resok (xdrs, &objp->GET_DIR_DELEGATION4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_GETFH4resok (XDR *xdrs, GETFH4resok *objp) -{ - if (!xdr_nfs_fh4 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_GETFH4res (XDR *xdrs, GETFH4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_GETFH4resok (xdrs, &objp->GETFH4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_LINK4args (XDR *xdrs, LINK4args *objp) -{ - if (!xdr_component4 (xdrs, &objp->newname)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LINK4resok (XDR *xdrs, LINK4resok *objp) -{ - if (!xdr_change_info4 (xdrs, &objp->cinfo)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LINK4res (XDR *xdrs, LINK4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_LINK4resok (xdrs, &objp->LINK4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_open_to_lock_owner4 (XDR *xdrs, open_to_lock_owner4 *objp) -{ - if (!xdr_seqid4 (xdrs, &objp->open_seqid)) - return FALSE; - if (!xdr_stateid4 (xdrs, &objp->open_stateid)) - return FALSE; - if (!xdr_seqid4 (xdrs, &objp->lock_seqid)) - return FALSE; - if (!xdr_lock_owner4 (xdrs, &objp->lock_owner)) - return FALSE; - return TRUE; -} - -bool_t -xdr_exist_lock_owner4 (XDR *xdrs, exist_lock_owner4 *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) - return FALSE; - if (!xdr_seqid4 (xdrs, &objp->lock_seqid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_locker4 (XDR *xdrs, locker4 *objp) -{ - if (!xdr_bool (xdrs, &objp->new_lock_owner)) - return FALSE; - switch (objp->new_lock_owner) { - case TRUE: - if (!xdr_open_to_lock_owner4 (xdrs, &objp->locker4_u.open_owner)) - return FALSE; - break; - case FALSE: - if (!xdr_exist_lock_owner4 (xdrs, &objp->locker4_u.lock_owner)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_LOCK4args (XDR *xdrs, LOCK4args *objp) -{ - if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) - return FALSE; - if (!xdr_bool (xdrs, &objp->reclaim)) - return FALSE; - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_length4 (xdrs, &objp->length)) - return FALSE; - if (!xdr_locker4 (xdrs, &objp->locker)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOCK4denied (XDR *xdrs, LOCK4denied *objp) -{ - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_length4 (xdrs, &objp->length)) - return FALSE; - if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) - return FALSE; - if (!xdr_lock_owner4 (xdrs, &objp->owner)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOCK4resok (XDR *xdrs, LOCK4resok *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOCK4res (XDR *xdrs, LOCK4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_LOCK4resok (xdrs, &objp->LOCK4res_u.resok4)) - return FALSE; - break; - case NFS4ERR_DENIED: - if (!xdr_LOCK4denied (xdrs, &objp->LOCK4res_u.denied)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_LOCKT4args (XDR *xdrs, LOCKT4args *objp) -{ - if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) - return FALSE; - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_length4 (xdrs, &objp->length)) - return FALSE; - if (!xdr_lock_owner4 (xdrs, &objp->owner)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOCKT4res (XDR *xdrs, LOCKT4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4ERR_DENIED: - if (!xdr_LOCK4denied (xdrs, &objp->LOCKT4res_u.denied)) - return FALSE; - break; - case NFS4_OK: - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_LOCKU4args (XDR *xdrs, LOCKU4args *objp) -{ - if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) - return FALSE; - if (!xdr_seqid4 (xdrs, &objp->seqid)) - return FALSE; - if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) - return FALSE; - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_length4 (xdrs, &objp->length)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOCKU4res (XDR *xdrs, LOCKU4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_stateid4 (xdrs, &objp->LOCKU4res_u.lock_stateid)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_LOOKUP4args (XDR *xdrs, LOOKUP4args *objp) -{ - if (!xdr_component4 (xdrs, &objp->objname)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOOKUP4res (XDR *xdrs, LOOKUP4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_LOOKUPP4res (XDR *xdrs, LOOKUPP4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_NVERIFY4args (XDR *xdrs, NVERIFY4args *objp) -{ - if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_NVERIFY4res (XDR *xdrs, NVERIFY4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_createmode4 (XDR *xdrs, createmode4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_createhow4 (XDR *xdrs, createhow4 *objp) -{ - if (!xdr_createmode4 (xdrs, &objp->mode)) - return FALSE; - switch (objp->mode) { - case UNCHECKED4: - case GUARDED4: - if (!xdr_fattr4 (xdrs, &objp->createhow4_u.createattrs)) - return FALSE; - break; - case EXCLUSIVE4: - if (!xdr_verifier4 (xdrs, objp->createhow4_u.createverf)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_opentype4 (XDR *xdrs, opentype4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_openflag4 (XDR *xdrs, openflag4 *objp) -{ - if (!xdr_opentype4 (xdrs, &objp->opentype)) - return FALSE; - switch (objp->opentype) { - case OPEN4_CREATE: - if (!xdr_createhow4 (xdrs, &objp->openflag4_u.how)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_limit_by4 (XDR *xdrs, limit_by4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_modified_limit4 (XDR *xdrs, nfs_modified_limit4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->num_blocks)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->bytes_per_block)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_space_limit4 (XDR *xdrs, nfs_space_limit4 *objp) -{ - if (!xdr_limit_by4 (xdrs, &objp->limitby)) - return FALSE; - switch (objp->limitby) { - case NFS_LIMIT_SIZE: - if (!rpcgen::xdr_uint64_t (xdrs, &objp->nfs_space_limit4_u.filesize)) - return FALSE; - break; - case NFS_LIMIT_BLOCKS: - if (!xdr_nfs_modified_limit4 (xdrs, &objp->nfs_space_limit4_u.mod_blocks)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_open_delegation_type4 (XDR *xdrs, open_delegation_type4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_claim_type4 (XDR *xdrs, open_claim_type4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_claim_delegate_cur4 (XDR *xdrs, open_claim_delegate_cur4 *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->delegate_stateid)) - return FALSE; - if (!xdr_component4 (xdrs, &objp->file)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_claim4 (XDR *xdrs, open_claim4 *objp) -{ - if (!xdr_open_claim_type4 (xdrs, &objp->claim)) - return FALSE; - switch (objp->claim) { - case CLAIM_NULL: - if (!xdr_component4 (xdrs, &objp->open_claim4_u.file)) - return FALSE; - break; - case CLAIM_PREVIOUS: - if (!xdr_open_delegation_type4 (xdrs, &objp->open_claim4_u.delegate_type)) - return FALSE; - break; - case CLAIM_DELEGATE_CUR: - if (!xdr_open_claim_delegate_cur4 (xdrs, &objp->open_claim4_u.delegate_cur_info)) - return FALSE; - break; - case CLAIM_DELEGATE_PREV: - if (!xdr_component4 (xdrs, &objp->open_claim4_u.file_delegate_prev)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_OPEN4args (XDR *xdrs, OPEN4args *objp) -{ - if (!xdr_seqid4 (xdrs, &objp->seqid)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->share_access)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->share_deny)) - return FALSE; - if (!xdr_open_owner4 (xdrs, &objp->owner)) - return FALSE; - if (!xdr_openflag4 (xdrs, &objp->openhow)) - return FALSE; - if (!xdr_open_claim4 (xdrs, &objp->claim)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_read_delegation4 (XDR *xdrs, open_read_delegation4 *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_bool (xdrs, &objp->recall)) - return FALSE; - if (!xdr_nfsace4 (xdrs, &objp->permissions)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_write_delegation4 (XDR *xdrs, open_write_delegation4 *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_bool (xdrs, &objp->recall)) - return FALSE; - if (!xdr_nfs_space_limit4 (xdrs, &objp->space_limit)) - return FALSE; - if (!xdr_nfsace4 (xdrs, &objp->permissions)) - return FALSE; - return TRUE; -} - -bool_t -xdr_open_delegation4 (XDR *xdrs, open_delegation4 *objp) -{ - if (!xdr_open_delegation_type4 (xdrs, &objp->delegation_type)) - return FALSE; - switch (objp->delegation_type) { - case OPEN_DELEGATE_NONE: - break; - case OPEN_DELEGATE_READ: - if (!xdr_open_read_delegation4 (xdrs, &objp->open_delegation4_u.read)) - return FALSE; - break; - case OPEN_DELEGATE_WRITE: - if (!xdr_open_write_delegation4 (xdrs, &objp->open_delegation4_u.write)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_OPEN4resok (XDR *xdrs, OPEN4resok *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_change_info4 (xdrs, &objp->cinfo)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->rflags)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->attrset)) - return FALSE; - if (!xdr_open_delegation4 (xdrs, &objp->delegation)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPEN4res (XDR *xdrs, OPEN4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_OPEN4resok (xdrs, &objp->OPEN4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_OPENATTR4args (XDR *xdrs, OPENATTR4args *objp) -{ - if (!xdr_bool (xdrs, &objp->createdir)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPENATTR4res (XDR *xdrs, OPENATTR4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPEN_CONFIRM4args (XDR *xdrs, OPEN_CONFIRM4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->open_stateid)) - return FALSE; - if (!xdr_seqid4 (xdrs, &objp->seqid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPEN_CONFIRM4resok (XDR *xdrs, OPEN_CONFIRM4resok *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->open_stateid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPEN_CONFIRM4res (XDR *xdrs, OPEN_CONFIRM4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_OPEN_CONFIRM4resok (xdrs, &objp->OPEN_CONFIRM4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_OPEN_DOWNGRADE4args (XDR *xdrs, OPEN_DOWNGRADE4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->open_stateid)) - return FALSE; - if (!xdr_seqid4 (xdrs, &objp->seqid)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->share_access)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->share_deny)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPEN_DOWNGRADE4resok (XDR *xdrs, OPEN_DOWNGRADE4resok *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->open_stateid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_OPEN_DOWNGRADE4res (XDR *xdrs, OPEN_DOWNGRADE4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_OPEN_DOWNGRADE4resok (xdrs, &objp->OPEN_DOWNGRADE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_PUTFH4args (XDR *xdrs, PUTFH4args *objp) -{ - if (!xdr_nfs_fh4 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_PUTFH4res (XDR *xdrs, PUTFH4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_PUTPUBFH4res (XDR *xdrs, PUTPUBFH4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_PUTROOTFH4res (XDR *xdrs, PUTROOTFH4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READ4args (XDR *xdrs, READ4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count4 (xdrs, &objp->count)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READ4resok (XDR *xdrs, READ4resok *objp) -{ - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READ4res (XDR *xdrs, READ4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_READ4resok (xdrs, &objp->READ4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_READDIR4args (XDR *xdrs, READDIR4args *objp) -{ - if (!xdr_nfs_cookie4 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_verifier4 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_count4 (xdrs, &objp->dircount)) - return FALSE; - if (!xdr_count4 (xdrs, &objp->maxcount)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->attr_request)) - return FALSE; - return TRUE; -} - -bool_t -xdr_entry4 (XDR *xdrs, entry4 *objp) -{ - if (!xdr_nfs_cookie4 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_component4 (xdrs, &objp->name)) - return FALSE; - if (!xdr_fattr4 (xdrs, &objp->attrs)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entry4), (xdrproc_t) xdr_entry4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_dirlist4 (XDR *xdrs, dirlist4 *objp) -{ - if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entry4), (xdrproc_t) xdr_entry4)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIR4resok (XDR *xdrs, READDIR4resok *objp) -{ - if (!xdr_verifier4 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_dirlist4 (xdrs, &objp->reply)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READDIR4res (XDR *xdrs, READDIR4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_READDIR4resok (xdrs, &objp->READDIR4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_READLINK4resok (XDR *xdrs, READLINK4resok *objp) -{ - if (!xdr_linktext4 (xdrs, &objp->link)) - return FALSE; - return TRUE; -} - -bool_t -xdr_READLINK4res (XDR *xdrs, READLINK4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_READLINK4resok (xdrs, &objp->READLINK4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_REMOVE4args (XDR *xdrs, REMOVE4args *objp) -{ - if (!xdr_component4 (xdrs, &objp->target)) - return FALSE; - return TRUE; -} - -bool_t -xdr_REMOVE4resok (XDR *xdrs, REMOVE4resok *objp) -{ - if (!xdr_change_info4 (xdrs, &objp->cinfo)) - return FALSE; - return TRUE; -} - -bool_t -xdr_REMOVE4res (XDR *xdrs, REMOVE4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_REMOVE4resok (xdrs, &objp->REMOVE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_RENAME4args (XDR *xdrs, RENAME4args *objp) -{ - if (!xdr_component4 (xdrs, &objp->oldname)) - return FALSE; - if (!xdr_component4 (xdrs, &objp->newname)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RENAME4resok (XDR *xdrs, RENAME4resok *objp) -{ - if (!xdr_change_info4 (xdrs, &objp->source_cinfo)) - return FALSE; - if (!xdr_change_info4 (xdrs, &objp->target_cinfo)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RENAME4res (XDR *xdrs, RENAME4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_RENAME4resok (xdrs, &objp->RENAME4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_RENEW4args (XDR *xdrs, RENEW4args *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RENEW4res (XDR *xdrs, RENEW4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RESTOREFH4res (XDR *xdrs, RESTOREFH4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SAVEFH4res (XDR *xdrs, SAVEFH4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SECINFO4args (XDR *xdrs, SECINFO4args *objp) -{ - if (!xdr_component4 (xdrs, &objp->name)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpc_gss_svc_t (XDR *xdrs, rpc_gss_svc_t *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_rpcsec_gss_info (XDR *xdrs, rpcsec_gss_info *objp) -{ - if (!xdr_sec_oid4 (xdrs, &objp->oid)) - return FALSE; - if (!xdr_qop4 (xdrs, &objp->qop)) - return FALSE; - if (!xdr_rpc_gss_svc_t (xdrs, &objp->service)) - return FALSE; - return TRUE; -} - -bool_t -xdr_secinfo4 (XDR *xdrs, secinfo4 *objp) -{ - if (!rpcgen::xdr_uint32_t (xdrs, &objp->flavor)) - return FALSE; - switch (objp->flavor) { - case RPCSEC_GSS: - if (!xdr_rpcsec_gss_info (xdrs, &objp->secinfo4_u.flavor_info)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_SECINFO4resok (XDR *xdrs, SECINFO4resok *objp) -{ - if (!xdr_array (xdrs, (char **)&objp->SECINFO4resok_val, (u_int *) &objp->SECINFO4resok_len, ~0, - sizeof (secinfo4), (xdrproc_t) xdr_secinfo4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SECINFO4res (XDR *xdrs, SECINFO4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_SECINFO4resok (xdrs, &objp->SECINFO4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_SETATTR4args (XDR *xdrs, SETATTR4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETATTR4res (XDR *xdrs, SETATTR4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->attrsset)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETCLIENTID4args (XDR *xdrs, SETCLIENTID4args *objp) -{ - if (!xdr_nfs_client_id4 (xdrs, &objp->client)) - return FALSE; - if (!xdr_cb_client4 (xdrs, &objp->callback)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->callback_ident)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETCLIENTID4resok (XDR *xdrs, SETCLIENTID4resok *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - if (!xdr_verifier4 (xdrs, objp->setclientid_confirm)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETCLIENTID4res (XDR *xdrs, SETCLIENTID4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_SETCLIENTID4resok (xdrs, &objp->SETCLIENTID4res_u.resok4)) - return FALSE; - break; - case NFS4ERR_CLID_INUSE: - if (!xdr_clientaddr4 (xdrs, &objp->SETCLIENTID4res_u.client_using)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_SETCLIENTID_CONFIRM4args (XDR *xdrs, SETCLIENTID_CONFIRM4args *objp) -{ - if (!xdr_clientid4 (xdrs, &objp->clientid)) - return FALSE; - if (!xdr_verifier4 (xdrs, objp->setclientid_confirm)) - return FALSE; - return TRUE; -} - -bool_t -xdr_SETCLIENTID_CONFIRM4res (XDR *xdrs, SETCLIENTID_CONFIRM4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_VERIFY4args (XDR *xdrs, VERIFY4args *objp) -{ - if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_VERIFY4res (XDR *xdrs, VERIFY4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_stable_how4 (XDR *xdrs, stable_how4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE4args (XDR *xdrs, WRITE4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_offset4 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_stable_how4 (xdrs, &objp->stable)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE4resok (XDR *xdrs, WRITE4resok *objp) -{ - if (!xdr_count4 (xdrs, &objp->count)) - return FALSE; - if (!xdr_stable_how4 (xdrs, &objp->committed)) - return FALSE; - if (!xdr_verifier4 (xdrs, objp->writeverf)) - return FALSE; - return TRUE; -} - -bool_t -xdr_WRITE4res (XDR *xdrs, WRITE4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_WRITE4resok (xdrs, &objp->WRITE4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_RELEASE_LOCKOWNER4args (XDR *xdrs, RELEASE_LOCKOWNER4args *objp) -{ - if (!xdr_lock_owner4 (xdrs, &objp->lock_owner)) - return FALSE; - return TRUE; -} - -bool_t -xdr_RELEASE_LOCKOWNER4res (XDR *xdrs, RELEASE_LOCKOWNER4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_ILLEGAL4res (XDR *xdrs, ILLEGAL4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_opnum4 (XDR *xdrs, nfs_opnum4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_argop4 (XDR *xdrs, nfs_argop4 *objp) -{ - if (!xdr_nfs_opnum4 (xdrs, &objp->argop)) - return FALSE; - switch (objp->argop) { - case OP_ACCESS: - if (!xdr_ACCESS4args (xdrs, &objp->nfs_argop4_u.opaccess)) - return FALSE; - break; - case OP_CLOSE: - if (!xdr_CLOSE4args (xdrs, &objp->nfs_argop4_u.opclose)) - return FALSE; - break; - case OP_COMMIT: - if (!xdr_COMMIT4args (xdrs, &objp->nfs_argop4_u.opcommit)) - return FALSE; - break; - case OP_CREATE: - if (!xdr_CREATE4args (xdrs, &objp->nfs_argop4_u.opcreate)) - return FALSE; - break; - case OP_DELEGPURGE: - if (!xdr_DELEGPURGE4args (xdrs, &objp->nfs_argop4_u.opdelegpurge)) - return FALSE; - break; - case OP_DELEGRETURN: - if (!xdr_DELEGRETURN4args (xdrs, &objp->nfs_argop4_u.opdelegreturn)) - return FALSE; - break; - case OP_GETATTR: - if (!xdr_GETATTR4args (xdrs, &objp->nfs_argop4_u.opgetattr)) - return FALSE; - break; - case OP_GETFH: - break; - case OP_LINK: - if (!xdr_LINK4args (xdrs, &objp->nfs_argop4_u.oplink)) - return FALSE; - break; - case OP_LOCK: - if (!xdr_LOCK4args (xdrs, &objp->nfs_argop4_u.oplock)) - return FALSE; - break; - case OP_LOCKT: - if (!xdr_LOCKT4args (xdrs, &objp->nfs_argop4_u.oplockt)) - return FALSE; - break; - case OP_LOCKU: - if (!xdr_LOCKU4args (xdrs, &objp->nfs_argop4_u.oplocku)) - return FALSE; - break; - case OP_LOOKUP: - if (!xdr_LOOKUP4args (xdrs, &objp->nfs_argop4_u.oplookup)) - return FALSE; - break; - case OP_LOOKUPP: - break; - case OP_NVERIFY: - if (!xdr_NVERIFY4args (xdrs, &objp->nfs_argop4_u.opnverify)) - return FALSE; - break; - case OP_OPEN: - if (!xdr_OPEN4args (xdrs, &objp->nfs_argop4_u.opopen)) - return FALSE; - break; - case OP_OPENATTR: - if (!xdr_OPENATTR4args (xdrs, &objp->nfs_argop4_u.opopenattr)) - return FALSE; - break; - case OP_OPEN_CONFIRM: - if (!xdr_OPEN_CONFIRM4args (xdrs, &objp->nfs_argop4_u.opopen_confirm)) - return FALSE; - break; - case OP_OPEN_DOWNGRADE: - if (!xdr_OPEN_DOWNGRADE4args (xdrs, &objp->nfs_argop4_u.opopen_downgrade)) - return FALSE; - break; - case OP_PUTFH: - if (!xdr_PUTFH4args (xdrs, &objp->nfs_argop4_u.opputfh)) - return FALSE; - break; - case OP_PUTPUBFH: - break; - case OP_PUTROOTFH: - break; - case OP_READ: - if (!xdr_READ4args (xdrs, &objp->nfs_argop4_u.opread)) - return FALSE; - break; - case OP_READDIR: - if (!xdr_READDIR4args (xdrs, &objp->nfs_argop4_u.opreaddir)) - return FALSE; - break; - case OP_READLINK: - break; - case OP_REMOVE: - if (!xdr_REMOVE4args (xdrs, &objp->nfs_argop4_u.opremove)) - return FALSE; - break; - case OP_RENAME: - if (!xdr_RENAME4args (xdrs, &objp->nfs_argop4_u.oprename)) - return FALSE; - break; - case OP_RENEW: - if (!xdr_RENEW4args (xdrs, &objp->nfs_argop4_u.oprenew)) - return FALSE; - break; - case OP_RESTOREFH: - break; - case OP_SAVEFH: - break; - case OP_SECINFO: - if (!xdr_SECINFO4args (xdrs, &objp->nfs_argop4_u.opsecinfo)) - return FALSE; - break; - case OP_SETATTR: - if (!xdr_SETATTR4args (xdrs, &objp->nfs_argop4_u.opsetattr)) - return FALSE; - break; - case OP_SETCLIENTID: - if (!xdr_SETCLIENTID4args (xdrs, &objp->nfs_argop4_u.opsetclientid)) - return FALSE; - break; - case OP_SETCLIENTID_CONFIRM: - if (!xdr_SETCLIENTID_CONFIRM4args (xdrs, &objp->nfs_argop4_u.opsetclientid_confirm)) - return FALSE; - break; - case OP_VERIFY: - if (!xdr_VERIFY4args (xdrs, &objp->nfs_argop4_u.opverify)) - return FALSE; - break; - case OP_WRITE: - if (!xdr_WRITE4args (xdrs, &objp->nfs_argop4_u.opwrite)) - return FALSE; - break; - case OP_RELEASE_LOCKOWNER: - if (!xdr_RELEASE_LOCKOWNER4args (xdrs, &objp->nfs_argop4_u.oprelease_lockowner)) - return FALSE; - break; - case OP_GET_DIR_DELEGATION: - if (!xdr_GET_DIR_DELEGATION4args (xdrs, &objp->nfs_argop4_u.opget_dir_delegation)) - return FALSE; - break; - case OP_ILLEGAL: - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_nfs_resop4 (XDR *xdrs, nfs_resop4 *objp) -{ - if (!xdr_nfs_opnum4 (xdrs, &objp->resop)) - return FALSE; - switch (objp->resop) { - case OP_ACCESS: - if (!xdr_ACCESS4res (xdrs, &objp->nfs_resop4_u.opaccess)) - return FALSE; - break; - case OP_CLOSE: - if (!xdr_CLOSE4res (xdrs, &objp->nfs_resop4_u.opclose)) - return FALSE; - break; - case OP_COMMIT: - if (!xdr_COMMIT4res (xdrs, &objp->nfs_resop4_u.opcommit)) - return FALSE; - break; - case OP_CREATE: - if (!xdr_CREATE4res (xdrs, &objp->nfs_resop4_u.opcreate)) - return FALSE; - break; - case OP_DELEGPURGE: - if (!xdr_DELEGPURGE4res (xdrs, &objp->nfs_resop4_u.opdelegpurge)) - return FALSE; - break; - case OP_DELEGRETURN: - if (!xdr_DELEGRETURN4res (xdrs, &objp->nfs_resop4_u.opdelegreturn)) - return FALSE; - break; - case OP_GETATTR: - if (!xdr_GETATTR4res (xdrs, &objp->nfs_resop4_u.opgetattr)) - return FALSE; - break; - case OP_GETFH: - if (!xdr_GETFH4res (xdrs, &objp->nfs_resop4_u.opgetfh)) - return FALSE; - break; - case OP_LINK: - if (!xdr_LINK4res (xdrs, &objp->nfs_resop4_u.oplink)) - return FALSE; - break; - case OP_LOCK: - if (!xdr_LOCK4res (xdrs, &objp->nfs_resop4_u.oplock)) - return FALSE; - break; - case OP_LOCKT: - if (!xdr_LOCKT4res (xdrs, &objp->nfs_resop4_u.oplockt)) - return FALSE; - break; - case OP_LOCKU: - if (!xdr_LOCKU4res (xdrs, &objp->nfs_resop4_u.oplocku)) - return FALSE; - break; - case OP_LOOKUP: - if (!xdr_LOOKUP4res (xdrs, &objp->nfs_resop4_u.oplookup)) - return FALSE; - break; - case OP_LOOKUPP: - if (!xdr_LOOKUPP4res (xdrs, &objp->nfs_resop4_u.oplookupp)) - return FALSE; - break; - case OP_NVERIFY: - if (!xdr_NVERIFY4res (xdrs, &objp->nfs_resop4_u.opnverify)) - return FALSE; - break; - case OP_OPEN: - if (!xdr_OPEN4res (xdrs, &objp->nfs_resop4_u.opopen)) - return FALSE; - break; - case OP_OPENATTR: - if (!xdr_OPENATTR4res (xdrs, &objp->nfs_resop4_u.opopenattr)) - return FALSE; - break; - case OP_OPEN_CONFIRM: - if (!xdr_OPEN_CONFIRM4res (xdrs, &objp->nfs_resop4_u.opopen_confirm)) - return FALSE; - break; - case OP_OPEN_DOWNGRADE: - if (!xdr_OPEN_DOWNGRADE4res (xdrs, &objp->nfs_resop4_u.opopen_downgrade)) - return FALSE; - break; - case OP_PUTFH: - if (!xdr_PUTFH4res (xdrs, &objp->nfs_resop4_u.opputfh)) - return FALSE; - break; - case OP_PUTPUBFH: - if (!xdr_PUTPUBFH4res (xdrs, &objp->nfs_resop4_u.opputpubfh)) - return FALSE; - break; - case OP_PUTROOTFH: - if (!xdr_PUTROOTFH4res (xdrs, &objp->nfs_resop4_u.opputrootfh)) - return FALSE; - break; - case OP_READ: - if (!xdr_READ4res (xdrs, &objp->nfs_resop4_u.opread)) - return FALSE; - break; - case OP_READDIR: - if (!xdr_READDIR4res (xdrs, &objp->nfs_resop4_u.opreaddir)) - return FALSE; - break; - case OP_READLINK: - if (!xdr_READLINK4res (xdrs, &objp->nfs_resop4_u.opreadlink)) - return FALSE; - break; - case OP_REMOVE: - if (!xdr_REMOVE4res (xdrs, &objp->nfs_resop4_u.opremove)) - return FALSE; - break; - case OP_RENAME: - if (!xdr_RENAME4res (xdrs, &objp->nfs_resop4_u.oprename)) - return FALSE; - break; - case OP_RENEW: - if (!xdr_RENEW4res (xdrs, &objp->nfs_resop4_u.oprenew)) - return FALSE; - break; - case OP_RESTOREFH: - if (!xdr_RESTOREFH4res (xdrs, &objp->nfs_resop4_u.oprestorefh)) - return FALSE; - break; - case OP_SAVEFH: - if (!xdr_SAVEFH4res (xdrs, &objp->nfs_resop4_u.opsavefh)) - return FALSE; - break; - case OP_SECINFO: - if (!xdr_SECINFO4res (xdrs, &objp->nfs_resop4_u.opsecinfo)) - return FALSE; - break; - case OP_SETATTR: - if (!xdr_SETATTR4res (xdrs, &objp->nfs_resop4_u.opsetattr)) - return FALSE; - break; - case OP_SETCLIENTID: - if (!xdr_SETCLIENTID4res (xdrs, &objp->nfs_resop4_u.opsetclientid)) - return FALSE; - break; - case OP_SETCLIENTID_CONFIRM: - if (!xdr_SETCLIENTID_CONFIRM4res (xdrs, &objp->nfs_resop4_u.opsetclientid_confirm)) - return FALSE; - break; - case OP_VERIFY: - if (!xdr_VERIFY4res (xdrs, &objp->nfs_resop4_u.opverify)) - return FALSE; - break; - case OP_WRITE: - if (!xdr_WRITE4res (xdrs, &objp->nfs_resop4_u.opwrite)) - return FALSE; - break; - case OP_RELEASE_LOCKOWNER: - if (!xdr_RELEASE_LOCKOWNER4res (xdrs, &objp->nfs_resop4_u.oprelease_lockowner)) - return FALSE; - break; - case OP_GET_DIR_DELEGATION: - if (!xdr_GET_DIR_DELEGATION4res (xdrs, &objp->nfs_resop4_u.opget_dir_delegation)) - return FALSE; - break; - case OP_ILLEGAL: - if (!xdr_ILLEGAL4res (xdrs, &objp->nfs_resop4_u.opillegal)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_COMPOUND4args (XDR *xdrs, COMPOUND4args *objp) -{ - if (!xdr_utf8str_cs (xdrs, &objp->tag)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->minorversion)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->argarray.argarray_val, (u_int *) &objp->argarray.argarray_len, ~0, - sizeof (nfs_argop4), (xdrproc_t) xdr_nfs_argop4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_COMPOUND4res (XDR *xdrs, COMPOUND4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - if (!xdr_utf8str_cs (xdrs, &objp->tag)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->resarray.resarray_val, (u_int *) &objp->resarray.resarray_len, ~0, - sizeof (nfs_resop4), (xdrproc_t) xdr_nfs_resop4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CB_GETATTR4args (XDR *xdrs, CB_GETATTR4args *objp) -{ - if (!xdr_nfs_fh4 (xdrs, &objp->fh)) - return FALSE; - if (!xdr_bitmap4 (xdrs, &objp->attr_request)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CB_GETATTR4resok (XDR *xdrs, CB_GETATTR4resok *objp) -{ - if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CB_GETATTR4res (XDR *xdrs, CB_GETATTR4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS4_OK: - if (!xdr_CB_GETATTR4resok (xdrs, &objp->CB_GETATTR4res_u.resok4)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_CB_RECALL4args (XDR *xdrs, CB_RECALL4args *objp) -{ - if (!xdr_stateid4 (xdrs, &objp->stateid)) - return FALSE; - if (!xdr_bool (xdrs, &objp->truncate)) - return FALSE; - if (!xdr_nfs_fh4 (xdrs, &objp->fh)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CB_RECALL4res (XDR *xdrs, CB_RECALL4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CB_ILLEGAL4res (XDR *xdrs, CB_ILLEGAL4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_cb_opnum4 (XDR *xdrs, nfs_cb_opnum4 *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nfs_cb_argop4 (XDR *xdrs, nfs_cb_argop4 *objp) -{ - if (!xdr_u_int (xdrs, &objp->argop)) - return FALSE; - switch (objp->argop) { - case OP_CB_GETATTR: - if (!xdr_CB_GETATTR4args (xdrs, &objp->nfs_cb_argop4_u.opcbgetattr)) - return FALSE; - break; - case OP_CB_RECALL: - if (!xdr_CB_RECALL4args (xdrs, &objp->nfs_cb_argop4_u.opcbrecall)) - return FALSE; - break; - case OP_CB_ILLEGAL: - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_nfs_cb_resop4 (XDR *xdrs, nfs_cb_resop4 *objp) -{ - if (!xdr_u_int (xdrs, &objp->resop)) - return FALSE; - switch (objp->resop) { - case OP_CB_GETATTR: - if (!xdr_CB_GETATTR4res (xdrs, &objp->nfs_cb_resop4_u.opcbgetattr)) - return FALSE; - break; - case OP_CB_RECALL: - if (!xdr_CB_RECALL4res (xdrs, &objp->nfs_cb_resop4_u.opcbrecall)) - return FALSE; - break; - case OP_CB_ILLEGAL: - if (!xdr_CB_ILLEGAL4res (xdrs, &objp->nfs_cb_resop4_u.opcbillegal)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_CB_COMPOUND4args (XDR *xdrs, CB_COMPOUND4args *objp) -{ - if (!xdr_utf8str_cs (xdrs, &objp->tag)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->minorversion)) - return FALSE; - if (!rpcgen::xdr_uint32_t (xdrs, &objp->callback_ident)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->argarray.argarray_val, (u_int *) &objp->argarray.argarray_len, ~0, - sizeof (nfs_cb_argop4), (xdrproc_t) xdr_nfs_cb_argop4)) - return FALSE; - return TRUE; -} - -bool_t -xdr_CB_COMPOUND4res (XDR *xdrs, CB_COMPOUND4res *objp) -{ - if (!xdr_nfsstat4 (xdrs, &objp->status)) - return FALSE; - if (!xdr_utf8str_cs (xdrs, &objp->tag)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->resarray.resarray_val, (u_int *) &objp->resarray.resarray_len, ~0, - sizeof (nfs_cb_resop4), (xdrproc_t) xdr_nfs_cb_resop4)) - return FALSE; - return TRUE; -} - -}// namespace rpcgen diff --git a/src/protocols/nfs4/nfs4_utils.cpp b/src/protocols/nfs4/nfs4_utils.cpp index 2e01e7f..4e1e855 100644 --- a/src/protocols/nfs4/nfs4_utils.cpp +++ b/src/protocols/nfs4/nfs4_utils.cpp @@ -1,7 +1,7 @@ //------------------------------------------------------------------------------ // Author: Alexey Costroma // Description: Helpers for parsing NFS structures. -// Copyright (c) 2014 EPAM Systems +// Copyright (c) 2014-2015 EPAM Systems //------------------------------------------------------------------------------ /* This file is part of Nfstrace. @@ -24,7 +24,8 @@ #include "protocols/nfs/nfs_utils.h" #include "protocols/nfs4/nfs4_utils.h" //------------------------------------------------------------------------------ -using namespace rpcgen; +using namespace NST::API::NFS4; +using namespace NST::protocols::NFS; // NFS helpers //------------------------------------------------------------------------------ namespace NST { @@ -33,8 +34,6 @@ namespace protocols namespace NFS4 { -using namespace NST::protocols::NFS; // NFS helpers - std::ostream& operator<<(std::ostream& out, const ProcEnumNFS4::NFSProcedure proc) { return out << print_nfs4_procedures(proc); @@ -64,164 +63,164 @@ const char* print_nfs4_procedures(const ProcEnumNFS4::NFSProcedure proc) return NFS4ProcedureTitles[i]; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_ftype4& obj) +std::ostream& operator<<(std::ostream& out, const nfs_ftype4& obj) { switch(obj) { - case rpcgen::nfs_ftype4::NF4REG: return out << "REG"; - case rpcgen::nfs_ftype4::NF4DIR: return out << "DIR"; - case rpcgen::nfs_ftype4::NF4BLK: return out << "BLK"; - case rpcgen::nfs_ftype4::NF4CHR: return out << "CHR"; - case rpcgen::nfs_ftype4::NF4LNK: return out << "LNK"; - case rpcgen::nfs_ftype4::NF4SOCK: return out << "SOCK"; - case rpcgen::nfs_ftype4::NF4FIFO: return out << "FIFO"; - case rpcgen::nfs_ftype4::NF4ATTRDIR: return out << "ATTRDIR"; - case rpcgen::nfs_ftype4::NF4NAMEDATTR: return out << "NAMEDATTR"; + case nfs_ftype4::NF4REG: return out << "REG"; + case nfs_ftype4::NF4DIR: return out << "DIR"; + case nfs_ftype4::NF4BLK: return out << "BLK"; + case nfs_ftype4::NF4CHR: return out << "CHR"; + case nfs_ftype4::NF4LNK: return out << "LNK"; + case nfs_ftype4::NF4SOCK: return out << "SOCK"; + case nfs_ftype4::NF4FIFO: return out << "FIFO"; + case nfs_ftype4::NF4ATTRDIR: return out << "ATTRDIR"; + case nfs_ftype4::NF4NAMEDATTR: return out << "NAMEDATTR"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfsstat4& obj) +std::ostream& operator<<(std::ostream& out, const nfsstat4& obj) { switch(obj) { - case rpcgen::nfsstat4::NFS4_OK: + case nfsstat4::NFS4_OK: return out << "OK"; - case rpcgen::nfsstat4::NFS4ERR_PERM: + case nfsstat4::NFS4ERR_PERM: return out << "ERROR_PERM"; - case rpcgen::nfsstat4::NFS4ERR_NOENT: + case nfsstat4::NFS4ERR_NOENT: return out << "ERROR_NOENT"; - case rpcgen::nfsstat4::NFS4ERR_IO: + case nfsstat4::NFS4ERR_IO: return out << "ERROR_IO"; - case rpcgen::nfsstat4::NFS4ERR_NXIO: + case nfsstat4::NFS4ERR_NXIO: return out << "ERROR_NXIO"; - case rpcgen::nfsstat4::NFS4ERR_ACCESS: + case nfsstat4::NFS4ERR_ACCESS: return out << "ERROR_ACCESS"; - case rpcgen::nfsstat4::NFS4ERR_EXIST: + case nfsstat4::NFS4ERR_EXIST: return out << "ERROR_EXIST"; - case rpcgen::nfsstat4::NFS4ERR_XDEV: + case nfsstat4::NFS4ERR_XDEV: return out << "ERROR_XDEV"; - case rpcgen::nfsstat4::NFS4ERR_NOTDIR: + case nfsstat4::NFS4ERR_NOTDIR: return out << "ERROR_NOTDIR"; - case rpcgen::nfsstat4::NFS4ERR_ISDIR: + case nfsstat4::NFS4ERR_ISDIR: return out << "ERROR_ISDIR"; - case rpcgen::nfsstat4::NFS4ERR_INVAL: + case nfsstat4::NFS4ERR_INVAL: return out << "ERROR_INVAL"; - case rpcgen::nfsstat4::NFS4ERR_FBIG: + case nfsstat4::NFS4ERR_FBIG: return out << "ERROR_FBIG"; - case rpcgen::nfsstat4::NFS4ERR_NOSPC: + case nfsstat4::NFS4ERR_NOSPC: return out << "ERROR_NOSPC"; - case rpcgen::nfsstat4::NFS4ERR_ROFS: + case nfsstat4::NFS4ERR_ROFS: return out << "ERROR_ROFS"; - case rpcgen::nfsstat4::NFS4ERR_MLINK: + case nfsstat4::NFS4ERR_MLINK: return out << "ERROR_MLINK"; - case rpcgen::nfsstat4::NFS4ERR_NAMETOOLONG: + case nfsstat4::NFS4ERR_NAMETOOLONG: return out << "ERROR_NAMETOOLONG"; - case rpcgen::nfsstat4::NFS4ERR_NOTEMPTY: + case nfsstat4::NFS4ERR_NOTEMPTY: return out << "ERROR_NOTEMPTY"; - case rpcgen::nfsstat4::NFS4ERR_DQUOT: + case nfsstat4::NFS4ERR_DQUOT: return out << "ERROR_DQUOT"; - case rpcgen::nfsstat4::NFS4ERR_STALE: + case nfsstat4::NFS4ERR_STALE: return out << "ERROR_STALE"; - case rpcgen::nfsstat4::NFS4ERR_BADHANDLE: + case nfsstat4::NFS4ERR_BADHANDLE: return out << "ERROR_BADHANDLE"; - case rpcgen::nfsstat4::NFS4ERR_BAD_COOKIE: + case nfsstat4::NFS4ERR_BAD_COOKIE: return out << "ERROR_BAD_COOKIE"; - case rpcgen::nfsstat4::NFS4ERR_NOTSUPP: + case nfsstat4::NFS4ERR_NOTSUPP: return out << "ERROR_NOTSUPP"; - case rpcgen::nfsstat4::NFS4ERR_TOOSMALL: + case nfsstat4::NFS4ERR_TOOSMALL: return out << "ERROR_TOOSMALL"; - case rpcgen::nfsstat4::NFS4ERR_SERVERFAULT: + case nfsstat4::NFS4ERR_SERVERFAULT: return out << "ERROR_SERVERFAULT"; - case rpcgen::nfsstat4::NFS4ERR_BADTYPE: + case nfsstat4::NFS4ERR_BADTYPE: return out << "ERROR_BADTYPE"; - case rpcgen::nfsstat4::NFS4ERR_DELAY: + case nfsstat4::NFS4ERR_DELAY: return out << "ERROR_DELAY"; - case rpcgen::nfsstat4::NFS4ERR_SAME: + case nfsstat4::NFS4ERR_SAME: return out << "ERROR_SAME"; - case rpcgen::nfsstat4::NFS4ERR_DENIED: + case nfsstat4::NFS4ERR_DENIED: return out << "ERROR_DENIED"; - case rpcgen::nfsstat4::NFS4ERR_EXPIRED: + case nfsstat4::NFS4ERR_EXPIRED: return out << "ERROR_EXPIRED"; - case rpcgen::nfsstat4::NFS4ERR_LOCKED: + case nfsstat4::NFS4ERR_LOCKED: return out << "ERROR_LOCKED"; - case rpcgen::nfsstat4::NFS4ERR_GRACE: + case nfsstat4::NFS4ERR_GRACE: return out << "ERROR_GRACE"; - case rpcgen::nfsstat4::NFS4ERR_FHEXPIRED: + case nfsstat4::NFS4ERR_FHEXPIRED: return out << "ERROR_FHEXPIRED"; - case rpcgen::nfsstat4::NFS4ERR_SHARE_DENIED: + case nfsstat4::NFS4ERR_SHARE_DENIED: return out << "ERROR_SHARE_DENIED"; - case rpcgen::nfsstat4::NFS4ERR_WRONGSEC: + case nfsstat4::NFS4ERR_WRONGSEC: return out << "ERROR_WRONGSEC"; - case rpcgen::nfsstat4::NFS4ERR_CLID_INUSE: + case nfsstat4::NFS4ERR_CLID_INUSE: return out << "ERROR_CLID_INUSE"; - case rpcgen::nfsstat4::NFS4ERR_RESOURCE: + case nfsstat4::NFS4ERR_RESOURCE: return out << "ERROR_RESOURCE"; - case rpcgen::nfsstat4::NFS4ERR_MOVED: + case nfsstat4::NFS4ERR_MOVED: return out << "ERROR_MOVED"; - case rpcgen::nfsstat4::NFS4ERR_NOFILEHANDLE: + case nfsstat4::NFS4ERR_NOFILEHANDLE: return out << "ERROR_NOFILEHANDLE"; - case rpcgen::nfsstat4::NFS4ERR_MINOR_VERS_MISMATCH: + case nfsstat4::NFS4ERR_MINOR_VERS_MISMATCH: return out << "ERROR_MINOR_VERS_MISMATCH"; - case rpcgen::nfsstat4::NFS4ERR_STALE_CLIENTID: + case nfsstat4::NFS4ERR_STALE_CLIENTID: return out << "ERROR_STALE_CLIENTID"; - case rpcgen::nfsstat4::NFS4ERR_STALE_STATEID: + case nfsstat4::NFS4ERR_STALE_STATEID: return out << "ERROR_STALE_STATEID"; - case rpcgen::nfsstat4::NFS4ERR_OLD_STATEID: + case nfsstat4::NFS4ERR_OLD_STATEID: return out << "ERROR_OLD_STATEID"; - case rpcgen::nfsstat4::NFS4ERR_BAD_STATEID: + case nfsstat4::NFS4ERR_BAD_STATEID: return out << "ERROR_BAD_STATEID"; - case rpcgen::nfsstat4::NFS4ERR_BAD_SEQID: + case nfsstat4::NFS4ERR_BAD_SEQID: return out << "ERROR_BAD_SEQID"; - case rpcgen::nfsstat4::NFS4ERR_NOT_SAME: + case nfsstat4::NFS4ERR_NOT_SAME: return out << "ERROR_NOT_SAME"; - case rpcgen::nfsstat4::NFS4ERR_LOCK_RANGE: + case nfsstat4::NFS4ERR_LOCK_RANGE: return out << "ERROR_LOCK_RANGE"; - case rpcgen::nfsstat4::NFS4ERR_SYMLINK: + case nfsstat4::NFS4ERR_SYMLINK: return out << "ERROR_SYMLINK"; - case rpcgen::nfsstat4::NFS4ERR_RESTOREFH: + case nfsstat4::NFS4ERR_RESTOREFH: return out << "ERROR_RESTOREFH"; - case rpcgen::nfsstat4::NFS4ERR_LEASE_MOVED: + case nfsstat4::NFS4ERR_LEASE_MOVED: return out << "ERROR_LEASE_MOVED"; - case rpcgen::nfsstat4::NFS4ERR_ATTRNOTSUPP: + case nfsstat4::NFS4ERR_ATTRNOTSUPP: return out << "ERROR_ATTRNOTSUPP"; - case rpcgen::nfsstat4::NFS4ERR_NO_GRACE: + case nfsstat4::NFS4ERR_NO_GRACE: return out << "ERROR_NO_GRACE"; - case rpcgen::nfsstat4::NFS4ERR_RECLAIM_BAD: + case nfsstat4::NFS4ERR_RECLAIM_BAD: return out << "ERROR_RECLAIM_BAD"; - case rpcgen::nfsstat4::NFS4ERR_RECLAIM_CONFLICT: + case nfsstat4::NFS4ERR_RECLAIM_CONFLICT: return out << "ERROR_RECLAIM_CONFLICT"; - case rpcgen::nfsstat4::NFS4ERR_BADXDR: + case nfsstat4::NFS4ERR_BADXDR: return out << "ERROR_BADXDR"; - case rpcgen::nfsstat4::NFS4ERR_LOCKS_HELD: + case nfsstat4::NFS4ERR_LOCKS_HELD: return out << "ERROR_LOCKS_HELD"; - case rpcgen::nfsstat4::NFS4ERR_OPENMODE: + case nfsstat4::NFS4ERR_OPENMODE: return out << "ERROR_OPENMODE"; - case rpcgen::nfsstat4::NFS4ERR_BADOWNER: + case nfsstat4::NFS4ERR_BADOWNER: return out << "ERROR_BADOWNER"; - case rpcgen::nfsstat4::NFS4ERR_BADCHAR: + case nfsstat4::NFS4ERR_BADCHAR: return out << "ERROR_BADCHAR"; - case rpcgen::nfsstat4::NFS4ERR_BADNAME: + case nfsstat4::NFS4ERR_BADNAME: return out << "ERROR_BADNAME"; - case rpcgen::nfsstat4::NFS4ERR_BAD_RANGE: + case nfsstat4::NFS4ERR_BAD_RANGE: return out << "ERROR_BAD_RANGE"; - case rpcgen::nfsstat4::NFS4ERR_LOCK_NOTSUPP: + case nfsstat4::NFS4ERR_LOCK_NOTSUPP: return out << "ERROR_LOCK_NOTSUPP"; - case rpcgen::nfsstat4::NFS4ERR_OP_ILLEGAL: + case nfsstat4::NFS4ERR_OP_ILLEGAL: return out << "ERROR_OP_ILLEGAL"; - case rpcgen::nfsstat4::NFS4ERR_DEADLOCK: + case nfsstat4::NFS4ERR_DEADLOCK: return out << "ERROR_DEADLOCK"; - case rpcgen::nfsstat4::NFS4ERR_FILE_OPEN: + case nfsstat4::NFS4ERR_FILE_OPEN: return out << "ERROR_FILE_OPEN"; - case rpcgen::nfsstat4::NFS4ERR_ADMIN_REVOKED: + case nfsstat4::NFS4ERR_ADMIN_REVOKED: return out << "ERROR_ADMIN_REVOKED"; - case rpcgen::nfsstat4::NFS4ERR_CB_PATH_DOWN: + case nfsstat4::NFS4ERR_CB_PATH_DOWN: return out << "ERROR_CB_PATH_DOWN"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::bitmap4& obj) +std::ostream& operator<<(std::ostream& out, const bitmap4& obj) { if(obj.bitmap4_len) { @@ -258,7 +257,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::bitmap4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::utf8string& obj) +std::ostream& operator<<(std::ostream& out, const utf8string& obj) { if(obj.utf8string_len) { @@ -272,9 +271,9 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::utf8string& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::pathname4& obj) +std::ostream& operator<<(std::ostream& out, const pathname4& obj) { - rpcgen::component4 *current_el = obj.pathname4_val; + component4 *current_el = obj.pathname4_val; for(size_t i {0}; i<obj.pathname4_len; i++,current_el++) { out.write(current_el->utf8string_val, @@ -284,7 +283,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::pathname4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::sec_oid4& obj) +std::ostream& operator<<(std::ostream& out, const sec_oid4& obj) { print_hex(out, obj.sec_oid4_val, @@ -292,30 +291,30 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::sec_oid4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfstime4& obj) +std::ostream& operator<<(std::ostream& out, const nfstime4& obj) { return out << "sec: " << obj.seconds << " nsec: " << obj.nseconds; } -std::ostream& operator<<(std::ostream& out, const rpcgen::time_how4& obj) +std::ostream& operator<<(std::ostream& out, const time_how4& obj) { switch(obj) { - case rpcgen::time_how4::SET_TO_SERVER_TIME4: + case time_how4::SET_TO_SERVER_TIME4: return out << "server time"; - case rpcgen::time_how4::SET_TO_CLIENT_TIME4: + case time_how4::SET_TO_CLIENT_TIME4: return out << "client time"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::settime4& obj) +std::ostream& operator<<(std::ostream& out, const settime4& obj) { return out << obj.set_it << ": " << obj.settime4_u.time; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_fh4& obj) +std::ostream& operator<<(std::ostream& out, const nfs_fh4& obj) { NFS::print_nfs_fh(out, obj.nfs_fh4_val, @@ -323,16 +322,16 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_fh4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::fsid4& obj) +std::ostream& operator<<(std::ostream& out, const fsid4& obj) { return out << "major: " << obj.major << " minor: " << obj.minor; } -std::ostream& operator<<(std::ostream& out, const rpcgen::fs_location4& obj) +std::ostream& operator<<(std::ostream& out, const fs_location4& obj) { out << "root path: " << obj.rootpath; - rpcgen::utf8str_cis *current_el {obj.server.server_val}; + utf8str_cis *current_el {obj.server.server_val}; for(size_t i {0}; i<obj.server.server_len; i++,current_el++) { out.write(current_el->utf8string_val, @@ -342,12 +341,12 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::fs_location4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::fs_locations4& obj) +std::ostream& operator<<(std::ostream& out, const fs_locations4& obj) { out << "root: " << obj.fs_root; if(obj.locations.locations_len) { - rpcgen::fs_location4* current_el {obj.locations.locations_val}; + fs_location4* current_el {obj.locations.locations_val}; for(u_int i {0}; i<obj.locations.locations_len; i++,current_el++) { out << current_el; @@ -356,7 +355,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::fs_locations4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfsace4& obj) +std::ostream& operator<<(std::ostream& out, const nfsace4& obj) { return out << "type: " << obj.type << " flag: " << obj.flag @@ -364,24 +363,24 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::nfsace4& obj) << " who: " << obj.who; } -std::ostream& operator<<(std::ostream& out, const rpcgen::specdata4& obj) +std::ostream& operator<<(std::ostream& out, const specdata4& obj) { return out << "specdata 1: " << obj.specdata1 << " specdata 2: " << obj.specdata2; } -std::ostream& operator<<(std::ostream& out, const rpcgen::fattr4_acl& obj) +std::ostream& operator<<(std::ostream& out, const fattr4_acl& obj) { if(obj.fattr4_acl_len) return out << *obj.fattr4_acl_val; else return out << "void"; } -std::ostream& operator<<(std::ostream& out, const rpcgen::fattr4& obj) +std::ostream& operator<<(std::ostream& out, const fattr4& obj) { return out << obj.attrmask; } -std::ostream& operator<<(std::ostream& out, const rpcgen::change_info4& obj) +std::ostream& operator<<(std::ostream& out, const change_info4& obj) { out << " atomic: "; if(obj.atomic) out << "YES"; @@ -391,19 +390,19 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::change_info4& obj) << " change id after: " << obj.after; } -std::ostream& operator<<(std::ostream& out, const rpcgen::clientaddr4& obj) +std::ostream& operator<<(std::ostream& out, const clientaddr4& obj) { return out << "netid: " << obj.r_netid << " addr: " << obj.r_addr; } -std::ostream& operator<<(std::ostream& out, const rpcgen::cb_client4& obj) +std::ostream& operator<<(std::ostream& out, const cb_client4& obj) { return out << "program: " << std::hex << obj.cb_program << " location: " << obj.cb_location; } -std::ostream& operator<<(std::ostream& out, const rpcgen::stateid4& obj) +std::ostream& operator<<(std::ostream& out, const stateid4& obj) { out << " seqid: " << std::hex << obj.seqid << " data: "; print_hex(out, @@ -412,7 +411,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::stateid4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_client_id4& obj) +std::ostream& operator<<(std::ostream& out, const nfs_client_id4& obj) { out << "verifier: "; print_hex(out, @@ -426,7 +425,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_client_id4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_owner4& obj) +std::ostream& operator<<(std::ostream& out, const open_owner4& obj) { out << "client id: " << std::hex << obj.clientid << " owner: "; print_hex(out, @@ -435,7 +434,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::open_owner4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::lock_owner4& obj) +std::ostream& operator<<(std::ostream& out, const lock_owner4& obj) { out << "client id: " << std::hex << obj.clientid << " owner: "; print_hex(out, @@ -444,7 +443,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::lock_owner4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_lock_type4& obj) +std::ostream& operator<<(std::ostream& out, const nfs_lock_type4& obj) { switch(obj) { @@ -456,22 +455,22 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_lock_type4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::createtype4& obj) +std::ostream& operator<<(std::ostream& out, const createtype4& obj) { out << "type: " << obj.type; switch(obj.type) { - case rpcgen::nfs_ftype4::NF4BLK: - case rpcgen::nfs_ftype4::NF4CHR: + case nfs_ftype4::NF4BLK: + case nfs_ftype4::NF4CHR: return out << " dev data: " << obj.createtype4_u.devdata; - case rpcgen::nfs_ftype4::NF4LNK: + case nfs_ftype4::NF4LNK: return out << " link data: " << obj.createtype4_u.linkdata; default: break; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::dir_delegation_status4& obj) +std::ostream& operator<<(std::ostream& out, const dir_delegation_status4& obj) { switch(obj) { @@ -487,7 +486,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::dir_delegation_status4 return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_to_lock_owner4& obj) +std::ostream& operator<<(std::ostream& out, const open_to_lock_owner4& obj) { return out << "open seqid: " << obj.open_seqid << " open state id: " << obj.open_stateid @@ -495,13 +494,13 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::open_to_lock_owner4& o << " lock owner: " << obj.lock_owner; } -std::ostream& operator<<(std::ostream& out, const rpcgen::exist_lock_owner4& obj) +std::ostream& operator<<(std::ostream& out, const exist_lock_owner4& obj) { return out << "lock state id: " << obj.lock_stateid << " lock seqid: " << obj.lock_seqid; } -std::ostream& operator<<(std::ostream& out, const rpcgen::locker4& obj) +std::ostream& operator<<(std::ostream& out, const locker4& obj) { out << "new lock owner: " << obj.new_lock_owner; if(obj.new_lock_owner) @@ -510,102 +509,102 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::locker4& obj) return out << " lock owner: " << obj.locker4_u.lock_owner; } -std::ostream& operator<<(std::ostream& out, const rpcgen::createmode4& obj) +std::ostream& operator<<(std::ostream& out, const createmode4& obj) { switch(obj) { - case rpcgen::createmode4::UNCHECKED4: return out << "UNCHECKED"; - case rpcgen::createmode4::GUARDED4: return out << "GUARDED"; - case rpcgen::createmode4::EXCLUSIVE4: return out << "EXCLUSIVE"; + case createmode4::UNCHECKED4: return out << "UNCHECKED"; + case createmode4::GUARDED4: return out << "GUARDED"; + case createmode4::EXCLUSIVE4: return out << "EXCLUSIVE"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::opentype4& obj) +std::ostream& operator<<(std::ostream& out, const opentype4& obj) { switch(obj) { - case rpcgen::opentype4::OPEN4_NOCREATE: return out << "NO CREATE"; - case rpcgen::opentype4::OPEN4_CREATE: return out << "CREATE"; + case opentype4::OPEN4_NOCREATE: return out << "NO CREATE"; + case opentype4::OPEN4_CREATE: return out << "CREATE"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::limit_by4& obj) +std::ostream& operator<<(std::ostream& out, const limit_by4& obj) { switch(obj) { - case rpcgen::limit_by4::NFS_LIMIT_SIZE: return out << "SIZE"; - case rpcgen::limit_by4::NFS_LIMIT_BLOCKS: return out << "BLOCKS"; + case limit_by4::NFS_LIMIT_SIZE: return out << "SIZE"; + case limit_by4::NFS_LIMIT_BLOCKS: return out << "BLOCKS"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_delegation_type4& obj) +std::ostream& operator<<(std::ostream& out, const open_delegation_type4& obj) { switch(obj) { - case rpcgen::open_delegation_type4::OPEN_DELEGATE_NONE: + case open_delegation_type4::OPEN_DELEGATE_NONE: return out << "NONE"; - case rpcgen::open_delegation_type4::OPEN_DELEGATE_READ: + case open_delegation_type4::OPEN_DELEGATE_READ: return out << "READ"; - case rpcgen::open_delegation_type4::OPEN_DELEGATE_WRITE: + case open_delegation_type4::OPEN_DELEGATE_WRITE: return out << "WRITE"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim_type4& obj) +std::ostream& operator<<(std::ostream& out, const open_claim_type4& obj) { switch(obj) { - case rpcgen::open_claim_type4::CLAIM_NULL: + case open_claim_type4::CLAIM_NULL: return out << "NULL"; - case rpcgen::open_claim_type4::CLAIM_PREVIOUS: + case open_claim_type4::CLAIM_PREVIOUS: return out << "PREVIOUS"; - case rpcgen::open_claim_type4::CLAIM_DELEGATE_CUR: + case open_claim_type4::CLAIM_DELEGATE_CUR: return out << "DELEGATE CURRENT"; - case rpcgen::open_claim_type4::CLAIM_DELEGATE_PREV: + case open_claim_type4::CLAIM_DELEGATE_PREV: return out << "DELEGATE PREVIOUS"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::rpc_gss_svc_t& obj) +std::ostream& operator<<(std::ostream& out, const rpc_gss_svc_t& obj) { switch(obj) { - case rpcgen::rpc_gss_svc_t::RPC_GSS_SVC_NONE: + case rpc_gss_svc_t::RPC_GSS_SVC_NONE: return out << "NONE"; - case rpcgen::rpc_gss_svc_t::RPC_GSS_SVC_INTEGRITY: + case rpc_gss_svc_t::RPC_GSS_SVC_INTEGRITY: return out << "INTEGRITY"; - case rpcgen::rpc_gss_svc_t::RPC_GSS_SVC_PRIVACY: + case rpc_gss_svc_t::RPC_GSS_SVC_PRIVACY: return out << "PRIVACY"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::stable_how4& obj) +std::ostream& operator<<(std::ostream& out, const stable_how4& obj) { switch(obj) { - case rpcgen::stable_how4::UNSTABLE4: return out << "UNSTABLE"; - case rpcgen::stable_how4::DATA_SYNC4: return out << "DATA SYNC"; - case rpcgen::stable_how4::FILE_SYNC4: return out << "FILE SYNC"; + case stable_how4::UNSTABLE4: return out << "UNSTABLE"; + case stable_how4::DATA_SYNC4: return out << "DATA SYNC"; + case stable_how4::FILE_SYNC4: return out << "FILE SYNC"; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::createhow4& obj) +std::ostream& operator<<(std::ostream& out, const createhow4& obj) { out << " mode: " << obj.mode; switch(obj.mode) { - case rpcgen::createmode4::UNCHECKED4: - case rpcgen::createmode4::GUARDED4: + case createmode4::UNCHECKED4: + case createmode4::GUARDED4: return out << " attributes: " << obj.createhow4_u.createattrs; - case rpcgen::createmode4::EXCLUSIVE4: + case createmode4::EXCLUSIVE4: out << " verifier: "; print_hex(out, obj.createhow4_u.createverf, NFS4_VERIFIER_SIZE); default: break; @@ -613,30 +612,30 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::createhow4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::openflag4& obj) +std::ostream& operator<<(std::ostream& out, const openflag4& obj) { out << "open type: " << obj.opentype; - if(obj.opentype == rpcgen::opentype4::OPEN4_CREATE) + if(obj.opentype == opentype4::OPEN4_CREATE) return out << obj.openflag4_u.how; else return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_modified_limit4& obj) +std::ostream& operator<<(std::ostream& out, const nfs_modified_limit4& obj) { return out << "blocks number: " << obj.num_blocks << " bytes per block: " << obj.bytes_per_block; } -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_space_limit4& obj) +std::ostream& operator<<(std::ostream& out, const nfs_space_limit4& obj) { out << "limit by: " << obj.limitby; switch(obj.limitby) { - case rpcgen::limit_by4::NFS_LIMIT_SIZE: + case limit_by4::NFS_LIMIT_SIZE: return out << " filesize: " << obj.nfs_space_limit4_u.filesize; - case rpcgen::limit_by4::NFS_LIMIT_BLOCKS: + case limit_by4::NFS_LIMIT_BLOCKS: return out << " modified blocks: " << obj.nfs_space_limit4_u.mod_blocks; default: break; @@ -644,28 +643,28 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_space_limit4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim_delegate_cur4& obj) +std::ostream& operator<<(std::ostream& out, const open_claim_delegate_cur4& obj) { return out << "delegate state id: " << obj.delegate_stateid << " file: " << obj.file; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim4& obj) +std::ostream& operator<<(std::ostream& out, const open_claim4& obj) { out << "claim: " << obj.claim; switch(obj.claim) { - case rpcgen::open_claim_type4::CLAIM_NULL: + case open_claim_type4::CLAIM_NULL: out << " file: "; return out.write(obj.open_claim4_u.file.utf8string_val, obj.open_claim4_u.file.utf8string_len); - case rpcgen::open_claim_type4::CLAIM_PREVIOUS: + case open_claim_type4::CLAIM_PREVIOUS: return out << " delegate type: " << obj.open_claim4_u.delegate_type; - case rpcgen::open_claim_type4::CLAIM_DELEGATE_CUR: + case open_claim_type4::CLAIM_DELEGATE_CUR: return out << " delegate current info: " << obj.open_claim4_u.delegate_cur_info; - case rpcgen::open_claim_type4::CLAIM_DELEGATE_PREV: + case open_claim_type4::CLAIM_DELEGATE_PREV: return out << " file delegate previous: " << obj.open_claim4_u.file_delegate_prev; default: break; @@ -673,14 +672,14 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim4& obj) return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_read_delegation4& obj) +std::ostream& operator<<(std::ostream& out, const open_read_delegation4& obj) { return out << "stateid: " << obj.stateid << " recall: " << obj.recall << " permissions: " << obj.permissions; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_write_delegation4& obj) +std::ostream& operator<<(std::ostream& out, const open_write_delegation4& obj) { return out << "stateid: " << obj.stateid << " recall: " << obj.recall @@ -688,23 +687,23 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::open_write_delegation4 << " permissions: " << obj.permissions; } -std::ostream& operator<<(std::ostream& out, const rpcgen::open_delegation4& obj) +std::ostream& operator<<(std::ostream& out, const open_delegation4& obj) { out << "delegation type: " << obj.delegation_type; switch(obj.delegation_type) { - case rpcgen::open_delegation_type4::OPEN_DELEGATE_NONE: + case open_delegation_type4::OPEN_DELEGATE_NONE: break; - case rpcgen::open_delegation_type4::OPEN_DELEGATE_READ: + case open_delegation_type4::OPEN_DELEGATE_READ: return out << ": " << obj.open_delegation4_u.read; - case rpcgen::open_delegation_type4::OPEN_DELEGATE_WRITE: + case open_delegation_type4::OPEN_DELEGATE_WRITE: return out << ": " << obj.open_delegation4_u.write; default: break; } return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::entry4& obj) +std::ostream& operator<<(std::ostream& out, const entry4& obj) { out << "cookie: " << obj.cookie << " name: " << obj.name @@ -713,7 +712,7 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::entry4& obj) else return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::dirlist4& obj) +std::ostream& operator<<(std::ostream& out, const dirlist4& obj) { out << "eof: " << obj.eof; if(obj.entries) return out << " entries:\n" @@ -721,14 +720,14 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::dirlist4& obj) else return out; } -std::ostream& operator<<(std::ostream& out, const rpcgen::rpcsec_gss_info& obj) +std::ostream& operator<<(std::ostream& out, const rpcsec_gss_info& obj) { return out << "oid: " << obj.oid << " qop: " << obj.qop << " service: " << obj.service; } -std::ostream& operator<<(std::ostream& out, const rpcgen::secinfo4& obj) +std::ostream& operator<<(std::ostream& out, const secinfo4& obj) { out << "flavor: " << obj.flavor; if(obj.flavor == RPCSEC_GSS) return out << " info: " @@ -736,6 +735,3707 @@ std::ostream& operator<<(std::ostream& out, const rpcgen::secinfo4& obj) else return out; } +bool_t +xdr_int32_t (XDR* xdrs, int32_t* objp) +{ + if (!xdr_int (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_ftype4 (XDR* xdrs, nfs_ftype4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfsstat4 (XDR* xdrs, nfsstat4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_bitmap4 (XDR* xdrs, bitmap4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->bitmap4_val, (u_int*) &objp->bitmap4_len, ~0, + sizeof (uint32_t), (xdrproc_t) xdr_uint32_t)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_offset4 (XDR* xdrs, offset4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_count4 (XDR* xdrs, count4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_length4 (XDR* xdrs, length4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_clientid4 (XDR* xdrs, clientid4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_seqid4 (XDR* xdrs, seqid4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8string (XDR* xdrs, utf8string* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->utf8string_val, (u_int*) &objp->utf8string_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8str_cis (XDR* xdrs, utf8str_cis* objp) +{ + if (!xdr_utf8string (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8str_cs (XDR* xdrs, utf8str_cs* objp) +{ + if (!xdr_utf8string (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_utf8str_mixed (XDR* xdrs, utf8str_mixed* objp) +{ + if (!xdr_utf8string (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_component4 (XDR* xdrs, component4* objp) +{ + if (!xdr_utf8str_cs (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_pathname4 (XDR* xdrs, pathname4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->pathname4_val, (u_int*) &objp->pathname4_len, ~0, + sizeof (component4), (xdrproc_t) xdr_component4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_lockid4 (XDR* xdrs, nfs_lockid4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cookie4 (XDR* xdrs, nfs_cookie4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_linktext4 (XDR* xdrs, linktext4* objp) +{ + if (!xdr_utf8str_cs (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_sec_oid4 (XDR* xdrs, sec_oid4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->sec_oid4_val, (u_int*) &objp->sec_oid4_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_qop4 (XDR* xdrs, qop4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_mode4 (XDR* xdrs, mode4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_changeid4 (XDR* xdrs, changeid4* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_verifier4 (XDR* xdrs, verifier4 objp) +{ + if (!xdr_opaque (xdrs, objp, NFS4_VERIFIER_SIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfstime4 (XDR* xdrs, nfstime4* objp) +{ + if (!xdr_int64_t (xdrs, &objp->seconds)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->nseconds)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_time_how4 (XDR* xdrs, time_how4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_settime4 (XDR* xdrs, settime4* objp) +{ + if (!xdr_time_how4 (xdrs, &objp->set_it)) + { + return FALSE; + } + switch (objp->set_it) + { + case SET_TO_CLIENT_TIME4: + if (!xdr_nfstime4 (xdrs, &objp->settime4_u.time)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_nfs_fh4 (XDR* xdrs, nfs_fh4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->nfs_fh4_val, (u_int*) &objp->nfs_fh4_len, NFS4_FHSIZE)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fsid4 (XDR* xdrs, fsid4* objp) +{ + if (!xdr_uint64_t (xdrs, &objp->major)) + { + return FALSE; + } + if (!xdr_uint64_t (xdrs, &objp->minor)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_location4 (XDR* xdrs, fs_location4* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->server.server_val, (u_int*) &objp->server.server_len, ~0, + sizeof (utf8str_cis), (xdrproc_t) xdr_utf8str_cis)) + { + return FALSE; + } + if (!xdr_pathname4 (xdrs, &objp->rootpath)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fs_locations4 (XDR* xdrs, fs_locations4* objp) +{ + if (!xdr_pathname4 (xdrs, &objp->fs_root)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->locations.locations_val, (u_int*) &objp->locations.locations_len, ~0, + sizeof (fs_location4), (xdrproc_t) xdr_fs_location4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_acetype4 (XDR* xdrs, acetype4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_aceflag4 (XDR* xdrs, aceflag4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_acemask4 (XDR* xdrs, acemask4* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfsace4 (XDR* xdrs, nfsace4* objp) +{ + if (!xdr_acetype4 (xdrs, &objp->type)) + { + return FALSE; + } + if (!xdr_aceflag4 (xdrs, &objp->flag)) + { + return FALSE; + } + if (!xdr_acemask4 (xdrs, &objp->access_mask)) + { + return FALSE; + } + if (!xdr_utf8str_mixed (xdrs, &objp->who)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_specdata4 (XDR* xdrs, specdata4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->specdata1)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->specdata2)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_supported_attrs (XDR* xdrs, fattr4_supported_attrs* objp) +{ + if (!xdr_bitmap4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_type (XDR* xdrs, fattr4_type* objp) +{ + if (!xdr_nfs_ftype4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fh_expire_type (XDR* xdrs, fattr4_fh_expire_type* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_change (XDR* xdrs, fattr4_change* objp) +{ + if (!xdr_changeid4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_size (XDR* xdrs, fattr4_size* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_link_support (XDR* xdrs, fattr4_link_support* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_symlink_support (XDR* xdrs, fattr4_symlink_support* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_named_attr (XDR* xdrs, fattr4_named_attr* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fsid (XDR* xdrs, fattr4_fsid* objp) +{ + if (!xdr_fsid4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_unique_handles (XDR* xdrs, fattr4_unique_handles* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_lease_time (XDR* xdrs, fattr4_lease_time* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_rdattr_error (XDR* xdrs, fattr4_rdattr_error* objp) +{ + if (!xdr_nfsstat4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_acl (XDR* xdrs, fattr4_acl* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->fattr4_acl_val, (u_int*) &objp->fattr4_acl_len, ~0, + sizeof (nfsace4), (xdrproc_t) xdr_nfsace4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_aclsupport (XDR* xdrs, fattr4_aclsupport* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_archive (XDR* xdrs, fattr4_archive* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_cansettime (XDR* xdrs, fattr4_cansettime* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_case_insensitive (XDR* xdrs, fattr4_case_insensitive* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_case_preserving (XDR* xdrs, fattr4_case_preserving* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_chown_restricted (XDR* xdrs, fattr4_chown_restricted* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fileid (XDR* xdrs, fattr4_fileid* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_files_avail (XDR* xdrs, fattr4_files_avail* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_filehandle (XDR* xdrs, fattr4_filehandle* objp) +{ + if (!xdr_nfs_fh4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_files_free (XDR* xdrs, fattr4_files_free* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_files_total (XDR* xdrs, fattr4_files_total* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_fs_locations (XDR* xdrs, fattr4_fs_locations* objp) +{ + if (!xdr_fs_locations4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_hidden (XDR* xdrs, fattr4_hidden* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_homogeneous (XDR* xdrs, fattr4_homogeneous* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxfilesize (XDR* xdrs, fattr4_maxfilesize* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxlink (XDR* xdrs, fattr4_maxlink* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxname (XDR* xdrs, fattr4_maxname* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxread (XDR* xdrs, fattr4_maxread* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_maxwrite (XDR* xdrs, fattr4_maxwrite* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mimetype (XDR* xdrs, fattr4_mimetype* objp) +{ + if (!xdr_utf8str_cs (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mode (XDR* xdrs, fattr4_mode* objp) +{ + if (!xdr_mode4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_mounted_on_fileid (XDR* xdrs, fattr4_mounted_on_fileid* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_no_trunc (XDR* xdrs, fattr4_no_trunc* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_numlinks (XDR* xdrs, fattr4_numlinks* objp) +{ + if (!xdr_uint32_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_owner (XDR* xdrs, fattr4_owner* objp) +{ + if (!xdr_utf8str_mixed (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_owner_group (XDR* xdrs, fattr4_owner_group* objp) +{ + if (!xdr_utf8str_mixed (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_quota_avail_hard (XDR* xdrs, fattr4_quota_avail_hard* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_quota_avail_soft (XDR* xdrs, fattr4_quota_avail_soft* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_quota_used (XDR* xdrs, fattr4_quota_used* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_rawdev (XDR* xdrs, fattr4_rawdev* objp) +{ + if (!xdr_specdata4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_avail (XDR* xdrs, fattr4_space_avail* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_free (XDR* xdrs, fattr4_space_free* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_total (XDR* xdrs, fattr4_space_total* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_space_used (XDR* xdrs, fattr4_space_used* objp) +{ + if (!xdr_uint64_t (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_system (XDR* xdrs, fattr4_system* objp) +{ + if (!xdr_bool (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_access (XDR* xdrs, fattr4_time_access* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_access_set (XDR* xdrs, fattr4_time_access_set* objp) +{ + if (!xdr_settime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_backup (XDR* xdrs, fattr4_time_backup* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_create (XDR* xdrs, fattr4_time_create* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_delta (XDR* xdrs, fattr4_time_delta* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_metadata (XDR* xdrs, fattr4_time_metadata* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_modify (XDR* xdrs, fattr4_time_modify* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4_time_modify_set (XDR* xdrs, fattr4_time_modify_set* objp) +{ + if (!xdr_settime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_attrlist4 (XDR* xdrs, attrlist4* objp) +{ + if (!xdr_bytes (xdrs, (char**)&objp->attrlist4_val, (u_int*) &objp->attrlist4_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_fattr4 (XDR* xdrs, fattr4* objp) +{ + if (!xdr_bitmap4 (xdrs, &objp->attrmask)) + { + return FALSE; + } + if (!xdr_attrlist4 (xdrs, &objp->attr_vals)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_change_info4 (XDR* xdrs, change_info4* objp) +{ + if (!xdr_bool (xdrs, &objp->atomic)) + { + return FALSE; + } + if (!xdr_changeid4 (xdrs, &objp->before)) + { + return FALSE; + } + if (!xdr_changeid4 (xdrs, &objp->after)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_clientaddr4 (XDR* xdrs, clientaddr4* objp) +{ + if (!xdr_string (xdrs, &objp->r_netid, ~0)) + { + return FALSE; + } + if (!xdr_string (xdrs, &objp->r_addr, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_cb_client4 (XDR* xdrs, cb_client4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->cb_program)) + { + return FALSE; + } + if (!xdr_clientaddr4 (xdrs, &objp->cb_location)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_stateid4 (XDR* xdrs, stateid4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_opaque (xdrs, objp->other, 12)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_client_id4 (XDR* xdrs, nfs_client_id4* objp) +{ + if (!xdr_verifier4 (xdrs, objp->verifier)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->id.id_val, (u_int*) &objp->id.id_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_owner4 (XDR* xdrs, open_owner4* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->owner.owner_val, (u_int*) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_lock_owner4 (XDR* xdrs, lock_owner4* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->owner.owner_val, (u_int*) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_lock_type4 (XDR* xdrs, nfs_lock_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +//for compatibility +bool_t +xdr_NULL4args(XDR*, NULL4args*) +{ + return TRUE; +} + +bool_t +xdr_NULL4res(XDR*, NULL4res*) +{ + return TRUE; +} + +bool_t +xdr_ACCESS4args (XDR* xdrs, ACCESS4args* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->access)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS4resok (XDR* xdrs, ACCESS4resok* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->supported)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->access)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ACCESS4res (XDR* xdrs, ACCESS4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_ACCESS4resok (xdrs, &objp->ACCESS4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CLOSE4args (XDR* xdrs, CLOSE4args* objp) +{ + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CLOSE4res (XDR* xdrs, CLOSE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_stateid4 (xdrs, &objp->CLOSE4res_u.open_stateid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_COMMIT4args (XDR* xdrs, COMMIT4args* objp) +{ + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT4resok (XDR* xdrs, COMMIT4resok* objp) +{ + if (!xdr_verifier4 (xdrs, objp->writeverf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMMIT4res (XDR* xdrs, COMMIT4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_COMMIT4resok (xdrs, &objp->COMMIT4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_createtype4 (XDR* xdrs, createtype4* objp) +{ + if (!xdr_nfs_ftype4 (xdrs, &objp->type)) + { + return FALSE; + } + switch (objp->type) + { + case NF4LNK: + if (!xdr_linktext4 (xdrs, &objp->createtype4_u.linkdata)) + { + return FALSE; + } + break; + case NF4BLK: + case NF4CHR: + if (!xdr_specdata4 (xdrs, &objp->createtype4_u.devdata)) + { + return FALSE; + } + break; + case NF4SOCK: + case NF4FIFO: + case NF4DIR: + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CREATE4args (XDR* xdrs, CREATE4args* objp) +{ + if (!xdr_createtype4 (xdrs, &objp->objtype)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->objname)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->createattrs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE4resok (XDR* xdrs, CREATE4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attrset)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CREATE4res (XDR* xdrs, CREATE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_CREATE4resok (xdrs, &objp->CREATE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_DELEGPURGE4args (XDR* xdrs, DELEGPURGE4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DELEGPURGE4res (XDR* xdrs, DELEGPURGE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DELEGRETURN4args (XDR* xdrs, DELEGRETURN4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->deleg_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_DELEGRETURN4res (XDR* xdrs, DELEGRETURN4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR4args (XDR* xdrs, GETATTR4args* objp) +{ + if (!xdr_bitmap4 (xdrs, &objp->attr_request)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR4resok (XDR* xdrs, GETATTR4resok* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETATTR4res (XDR* xdrs, GETATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_GETATTR4resok (xdrs, &objp->GETATTR4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_notification_types4 (XDR* xdrs, notification_types4* objp) +{ + if (!xdr_bitmap4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_notification_delay4 (XDR* xdrs, notification_delay4* objp) +{ + if (!xdr_nfstime4 (xdrs, objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_dir_delegation_status4 (XDR* xdrs, dir_delegation_status4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4args (XDR* xdrs, GET_DIR_DELEGATION4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_notification_types4 (xdrs, &objp->notif_types)) + { + return FALSE; + } + if (!xdr_notification_delay4 (xdrs, &objp->dir_notif_delay)) + { + return FALSE; + } + if (!xdr_notification_delay4 (xdrs, &objp->dir_entry_notif_delay)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4resok (XDR* xdrs, GET_DIR_DELEGATION4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_dir_delegation_status4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_notification_types4 (xdrs, &objp->notif_types)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->dir_notif_attrs)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->dir_entry_notif_attrs)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GET_DIR_DELEGATION4res (XDR* xdrs, GET_DIR_DELEGATION4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_GET_DIR_DELEGATION4resok (xdrs, &objp->GET_DIR_DELEGATION4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_GETFH4resok (XDR* xdrs, GETFH4resok* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_GETFH4res (XDR* xdrs, GETFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_GETFH4resok (xdrs, &objp->GETFH4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LINK4args (XDR* xdrs, LINK4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->newname)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK4resok (XDR* xdrs, LINK4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LINK4res (XDR* xdrs, LINK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_LINK4resok (xdrs, &objp->LINK4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_open_to_lock_owner4 (XDR* xdrs, open_to_lock_owner4* objp) +{ + if (!xdr_seqid4 (xdrs, &objp->open_seqid)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->lock_seqid)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->lock_owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_exist_lock_owner4 (XDR* xdrs, exist_lock_owner4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->lock_seqid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_locker4 (XDR* xdrs, locker4* objp) +{ + if (!xdr_bool (xdrs, &objp->new_lock_owner)) + { + return FALSE; + } + switch (objp->new_lock_owner) + { + case TRUE: + if (!xdr_open_to_lock_owner4 (xdrs, &objp->locker4_u.open_owner)) + { + return FALSE; + } + break; + case FALSE: + if (!xdr_exist_lock_owner4 (xdrs, &objp->locker4_u.lock_owner)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4args (XDR* xdrs, LOCK4args* objp) +{ + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->reclaim)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + if (!xdr_locker4 (xdrs, &objp->locker)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4denied (XDR* xdrs, LOCK4denied* objp) +{ + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4resok (XDR* xdrs, LOCK4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCK4res (XDR* xdrs, LOCK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_LOCK4resok (xdrs, &objp->LOCK4res_u.resok4)) + { + return FALSE; + } + break; + case NFS4ERR_DENIED: + if (!xdr_LOCK4denied (xdrs, &objp->LOCK4res_u.denied)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LOCKT4args (XDR* xdrs, LOCKT4args* objp) +{ + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + if (!xdr_lock_owner4 (xdrs, &objp->owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCKT4res (XDR* xdrs, LOCKT4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4ERR_DENIED: + if (!xdr_LOCK4denied (xdrs, &objp->LOCKT4res_u.denied)) + { + return FALSE; + } + break; + case NFS4_OK: + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LOCKU4args (XDR* xdrs, LOCKU4args* objp) +{ + if (!xdr_nfs_lock_type4 (xdrs, &objp->locktype)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_stateid4 (xdrs, &objp->lock_stateid)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_length4 (xdrs, &objp->length)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOCKU4res (XDR* xdrs, LOCKU4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_stateid4 (xdrs, &objp->LOCKU4res_u.lock_stateid)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_LOOKUP4args (XDR* xdrs, LOOKUP4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->objname)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUP4res (XDR* xdrs, LOOKUP4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_LOOKUPP4res (XDR* xdrs, LOOKUPP4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_NVERIFY4args (XDR* xdrs, NVERIFY4args* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_NVERIFY4res (XDR* xdrs, NVERIFY4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_createmode4 (XDR* xdrs, createmode4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_createhow4 (XDR* xdrs, createhow4* objp) +{ + if (!xdr_createmode4 (xdrs, &objp->mode)) + { + return FALSE; + } + switch (objp->mode) + { + case UNCHECKED4: + case GUARDED4: + if (!xdr_fattr4 (xdrs, &objp->createhow4_u.createattrs)) + { + return FALSE; + } + break; + case EXCLUSIVE4: + if (!xdr_verifier4 (xdrs, objp->createhow4_u.createverf)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_opentype4 (XDR* xdrs, opentype4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_openflag4 (XDR* xdrs, openflag4* objp) +{ + if (!xdr_opentype4 (xdrs, &objp->opentype)) + { + return FALSE; + } + switch (objp->opentype) + { + case OPEN4_CREATE: + if (!xdr_createhow4 (xdrs, &objp->openflag4_u.how)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_limit_by4 (XDR* xdrs, limit_by4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_modified_limit4 (XDR* xdrs, nfs_modified_limit4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->num_blocks)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->bytes_per_block)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_space_limit4 (XDR* xdrs, nfs_space_limit4* objp) +{ + if (!xdr_limit_by4 (xdrs, &objp->limitby)) + { + return FALSE; + } + switch (objp->limitby) + { + case NFS_LIMIT_SIZE: + if (!xdr_uint64_t (xdrs, &objp->nfs_space_limit4_u.filesize)) + { + return FALSE; + } + break; + case NFS_LIMIT_BLOCKS: + if (!xdr_nfs_modified_limit4 (xdrs, &objp->nfs_space_limit4_u.mod_blocks)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_delegation_type4 (XDR* xdrs, open_delegation_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_claim_type4 (XDR* xdrs, open_claim_type4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_claim_delegate_cur4 (XDR* xdrs, open_claim_delegate_cur4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->delegate_stateid)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->file)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_claim4 (XDR* xdrs, open_claim4* objp) +{ + if (!xdr_open_claim_type4 (xdrs, &objp->claim)) + { + return FALSE; + } + switch (objp->claim) + { + case CLAIM_NULL: + if (!xdr_component4 (xdrs, &objp->open_claim4_u.file)) + { + return FALSE; + } + break; + case CLAIM_PREVIOUS: + if (!xdr_open_delegation_type4 (xdrs, &objp->open_claim4_u.delegate_type)) + { + return FALSE; + } + break; + case CLAIM_DELEGATE_CUR: + if (!xdr_open_claim_delegate_cur4 (xdrs, &objp->open_claim4_u.delegate_cur_info)) + { + return FALSE; + } + break; + case CLAIM_DELEGATE_PREV: + if (!xdr_component4 (xdrs, &objp->open_claim4_u.file_delegate_prev)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN4args (XDR* xdrs, OPEN4args* objp) +{ + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_access)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_deny)) + { + return FALSE; + } + if (!xdr_open_owner4 (xdrs, &objp->owner)) + { + return FALSE; + } + if (!xdr_openflag4 (xdrs, &objp->openhow)) + { + return FALSE; + } + if (!xdr_open_claim4 (xdrs, &objp->claim)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_read_delegation4 (XDR* xdrs, open_read_delegation4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->recall)) + { + return FALSE; + } + if (!xdr_nfsace4 (xdrs, &objp->permissions)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_write_delegation4 (XDR* xdrs, open_write_delegation4* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->recall)) + { + return FALSE; + } + if (!xdr_nfs_space_limit4 (xdrs, &objp->space_limit)) + { + return FALSE; + } + if (!xdr_nfsace4 (xdrs, &objp->permissions)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_open_delegation4 (XDR* xdrs, open_delegation4* objp) +{ + if (!xdr_open_delegation_type4 (xdrs, &objp->delegation_type)) + { + return FALSE; + } + switch (objp->delegation_type) + { + case OPEN_DELEGATE_NONE: + break; + case OPEN_DELEGATE_READ: + if (!xdr_open_read_delegation4 (xdrs, &objp->open_delegation4_u.read)) + { + return FALSE; + } + break; + case OPEN_DELEGATE_WRITE: + if (!xdr_open_write_delegation4 (xdrs, &objp->open_delegation4_u.write)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN4resok (XDR* xdrs, OPEN4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->rflags)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attrset)) + { + return FALSE; + } + if (!xdr_open_delegation4 (xdrs, &objp->delegation)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN4res (XDR* xdrs, OPEN4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_OPEN4resok (xdrs, &objp->OPEN4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_OPENATTR4args (XDR* xdrs, OPENATTR4args* objp) +{ + if (!xdr_bool (xdrs, &objp->createdir)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPENATTR4res (XDR* xdrs, OPENATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_CONFIRM4args (XDR* xdrs, OPEN_CONFIRM4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_CONFIRM4resok (XDR* xdrs, OPEN_CONFIRM4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_CONFIRM4res (XDR* xdrs, OPEN_CONFIRM4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_OPEN_CONFIRM4resok (xdrs, &objp->OPEN_CONFIRM4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_OPEN_DOWNGRADE4args (XDR* xdrs, OPEN_DOWNGRADE4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + if (!xdr_seqid4 (xdrs, &objp->seqid)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_access)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->share_deny)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_DOWNGRADE4resok (XDR* xdrs, OPEN_DOWNGRADE4resok* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->open_stateid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_OPEN_DOWNGRADE4res (XDR* xdrs, OPEN_DOWNGRADE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_OPEN_DOWNGRADE4resok (xdrs, &objp->OPEN_DOWNGRADE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_PUTFH4args (XDR* xdrs, PUTFH4args* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->object)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PUTFH4res (XDR* xdrs, PUTFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PUTPUBFH4res (XDR* xdrs, PUTPUBFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_PUTROOTFH4res (XDR* xdrs, PUTROOTFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ4args (XDR* xdrs, READ4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->count)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ4resok (XDR* xdrs, READ4resok* objp) +{ + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->data.data_val, (u_int*) &objp->data.data_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READ4res (XDR* xdrs, READ4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_READ4resok (xdrs, &objp->READ4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_READDIR4args (XDR* xdrs, READDIR4args* objp) +{ + if (!xdr_nfs_cookie4 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->dircount)) + { + return FALSE; + } + if (!xdr_count4 (xdrs, &objp->maxcount)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attr_request)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_entry4 (XDR* xdrs, entry4* objp) +{ + if (!xdr_nfs_cookie4 (xdrs, &objp->cookie)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->name)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->attrs)) + { + return FALSE; + } + if (!xdr_pointer (xdrs, (char**)&objp->nextentry, sizeof (entry4), (xdrproc_t) xdr_entry4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_dirlist4 (XDR* xdrs, dirlist4* objp) +{ + if (!xdr_pointer (xdrs, (char**)&objp->entries, sizeof (entry4), (xdrproc_t) xdr_entry4)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->eof)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR4resok (XDR* xdrs, READDIR4resok* objp) +{ + if (!xdr_verifier4 (xdrs, objp->cookieverf)) + { + return FALSE; + } + if (!xdr_dirlist4 (xdrs, &objp->reply)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READDIR4res (XDR* xdrs, READDIR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_READDIR4resok (xdrs, &objp->READDIR4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_READLINK4resok (XDR* xdrs, READLINK4resok* objp) +{ + if (!xdr_linktext4 (xdrs, &objp->link)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_READLINK4res (XDR* xdrs, READLINK4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_READLINK4resok (xdrs, &objp->READLINK4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_REMOVE4args (XDR* xdrs, REMOVE4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->target)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE4resok (XDR* xdrs, REMOVE4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->cinfo)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_REMOVE4res (XDR* xdrs, REMOVE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_REMOVE4resok (xdrs, &objp->REMOVE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_RENAME4args (XDR* xdrs, RENAME4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->oldname)) + { + return FALSE; + } + if (!xdr_component4 (xdrs, &objp->newname)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME4resok (XDR* xdrs, RENAME4resok* objp) +{ + if (!xdr_change_info4 (xdrs, &objp->source_cinfo)) + { + return FALSE; + } + if (!xdr_change_info4 (xdrs, &objp->target_cinfo)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENAME4res (XDR* xdrs, RENAME4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_RENAME4resok (xdrs, &objp->RENAME4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_RENEW4args (XDR* xdrs, RENEW4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RENEW4res (XDR* xdrs, RENEW4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RESTOREFH4res (XDR* xdrs, RESTOREFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SAVEFH4res (XDR* xdrs, SAVEFH4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SECINFO4args (XDR* xdrs, SECINFO4args* objp) +{ + if (!xdr_component4 (xdrs, &objp->name)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_rpc_gss_svc_t (XDR* xdrs, rpc_gss_svc_t* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_rpcsec_gss_info (XDR* xdrs, rpcsec_gss_info* objp) +{ + if (!xdr_sec_oid4 (xdrs, &objp->oid)) + { + return FALSE; + } + if (!xdr_qop4 (xdrs, &objp->qop)) + { + return FALSE; + } + if (!xdr_rpc_gss_svc_t (xdrs, &objp->service)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_secinfo4 (XDR* xdrs, secinfo4* objp) +{ + if (!xdr_uint32_t (xdrs, &objp->flavor)) + { + return FALSE; + } + switch (objp->flavor) + { + case RPCSEC_GSS: + if (!xdr_rpcsec_gss_info (xdrs, &objp->secinfo4_u.flavor_info)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_SECINFO4resok (XDR* xdrs, SECINFO4resok* objp) +{ + if (!xdr_array (xdrs, (char**)&objp->SECINFO4resok_val, (u_int*) &objp->SECINFO4resok_len, ~0, + sizeof (secinfo4), (xdrproc_t) xdr_secinfo4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SECINFO4res (XDR* xdrs, SECINFO4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_SECINFO4resok (xdrs, &objp->SECINFO4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_SETATTR4args (XDR* xdrs, SETATTR4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETATTR4res (XDR* xdrs, SETATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attrsset)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID4args (XDR* xdrs, SETCLIENTID4args* objp) +{ + if (!xdr_nfs_client_id4 (xdrs, &objp->client)) + { + return FALSE; + } + if (!xdr_cb_client4 (xdrs, &objp->callback)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->callback_ident)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID4resok (XDR* xdrs, SETCLIENTID4resok* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->setclientid_confirm)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID4res (XDR* xdrs, SETCLIENTID4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_SETCLIENTID4resok (xdrs, &objp->SETCLIENTID4res_u.resok4)) + { + return FALSE; + } + break; + case NFS4ERR_CLID_INUSE: + if (!xdr_clientaddr4 (xdrs, &objp->SETCLIENTID4res_u.client_using)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID_CONFIRM4args (XDR* xdrs, SETCLIENTID_CONFIRM4args* objp) +{ + if (!xdr_clientid4 (xdrs, &objp->clientid)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->setclientid_confirm)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_SETCLIENTID_CONFIRM4res (XDR* xdrs, SETCLIENTID_CONFIRM4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_VERIFY4args (XDR* xdrs, VERIFY4args* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_VERIFY4res (XDR* xdrs, VERIFY4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_stable_how4 (XDR* xdrs, stable_how4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE4args (XDR* xdrs, WRITE4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_offset4 (xdrs, &objp->offset)) + { + return FALSE; + } + if (!xdr_stable_how4 (xdrs, &objp->stable)) + { + return FALSE; + } + if (!xdr_bytes (xdrs, (char**)&objp->data.data_val, (u_int*) &objp->data.data_len, ~0)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE4resok (XDR* xdrs, WRITE4resok* objp) +{ + if (!xdr_count4 (xdrs, &objp->count)) + { + return FALSE; + } + if (!xdr_stable_how4 (xdrs, &objp->committed)) + { + return FALSE; + } + if (!xdr_verifier4 (xdrs, objp->writeverf)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_WRITE4res (XDR* xdrs, WRITE4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_WRITE4resok (xdrs, &objp->WRITE4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_RELEASE_LOCKOWNER4args (XDR* xdrs, RELEASE_LOCKOWNER4args* objp) +{ + if (!xdr_lock_owner4 (xdrs, &objp->lock_owner)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_RELEASE_LOCKOWNER4res (XDR* xdrs, RELEASE_LOCKOWNER4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_ILLEGAL4res (XDR* xdrs, ILLEGAL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_opnum4 (XDR* xdrs, nfs_opnum4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_argop4 (XDR* xdrs, nfs_argop4* objp) +{ + if (!xdr_nfs_opnum4 (xdrs, &objp->argop)) + { + return FALSE; + } + switch (objp->argop) + { + case OP_ACCESS: + if (!xdr_ACCESS4args (xdrs, &objp->nfs_argop4_u.opaccess)) + { + return FALSE; + } + break; + case OP_CLOSE: + if (!xdr_CLOSE4args (xdrs, &objp->nfs_argop4_u.opclose)) + { + return FALSE; + } + break; + case OP_COMMIT: + if (!xdr_COMMIT4args (xdrs, &objp->nfs_argop4_u.opcommit)) + { + return FALSE; + } + break; + case OP_CREATE: + if (!xdr_CREATE4args (xdrs, &objp->nfs_argop4_u.opcreate)) + { + return FALSE; + } + break; + case OP_DELEGPURGE: + if (!xdr_DELEGPURGE4args (xdrs, &objp->nfs_argop4_u.opdelegpurge)) + { + return FALSE; + } + break; + case OP_DELEGRETURN: + if (!xdr_DELEGRETURN4args (xdrs, &objp->nfs_argop4_u.opdelegreturn)) + { + return FALSE; + } + break; + case OP_GETATTR: + if (!xdr_GETATTR4args (xdrs, &objp->nfs_argop4_u.opgetattr)) + { + return FALSE; + } + break; + case OP_GETFH: + break; + case OP_LINK: + if (!xdr_LINK4args (xdrs, &objp->nfs_argop4_u.oplink)) + { + return FALSE; + } + break; + case OP_LOCK: + if (!xdr_LOCK4args (xdrs, &objp->nfs_argop4_u.oplock)) + { + return FALSE; + } + break; + case OP_LOCKT: + if (!xdr_LOCKT4args (xdrs, &objp->nfs_argop4_u.oplockt)) + { + return FALSE; + } + break; + case OP_LOCKU: + if (!xdr_LOCKU4args (xdrs, &objp->nfs_argop4_u.oplocku)) + { + return FALSE; + } + break; + case OP_LOOKUP: + if (!xdr_LOOKUP4args (xdrs, &objp->nfs_argop4_u.oplookup)) + { + return FALSE; + } + break; + case OP_LOOKUPP: + break; + case OP_NVERIFY: + if (!xdr_NVERIFY4args (xdrs, &objp->nfs_argop4_u.opnverify)) + { + return FALSE; + } + break; + case OP_OPEN: + if (!xdr_OPEN4args (xdrs, &objp->nfs_argop4_u.opopen)) + { + return FALSE; + } + break; + case OP_OPENATTR: + if (!xdr_OPENATTR4args (xdrs, &objp->nfs_argop4_u.opopenattr)) + { + return FALSE; + } + break; + case OP_OPEN_CONFIRM: + if (!xdr_OPEN_CONFIRM4args (xdrs, &objp->nfs_argop4_u.opopen_confirm)) + { + return FALSE; + } + break; + case OP_OPEN_DOWNGRADE: + if (!xdr_OPEN_DOWNGRADE4args (xdrs, &objp->nfs_argop4_u.opopen_downgrade)) + { + return FALSE; + } + break; + case OP_PUTFH: + if (!xdr_PUTFH4args (xdrs, &objp->nfs_argop4_u.opputfh)) + { + return FALSE; + } + break; + case OP_PUTPUBFH: + break; + case OP_PUTROOTFH: + break; + case OP_READ: + if (!xdr_READ4args (xdrs, &objp->nfs_argop4_u.opread)) + { + return FALSE; + } + break; + case OP_READDIR: + if (!xdr_READDIR4args (xdrs, &objp->nfs_argop4_u.opreaddir)) + { + return FALSE; + } + break; + case OP_READLINK: + break; + case OP_REMOVE: + if (!xdr_REMOVE4args (xdrs, &objp->nfs_argop4_u.opremove)) + { + return FALSE; + } + break; + case OP_RENAME: + if (!xdr_RENAME4args (xdrs, &objp->nfs_argop4_u.oprename)) + { + return FALSE; + } + break; + case OP_RENEW: + if (!xdr_RENEW4args (xdrs, &objp->nfs_argop4_u.oprenew)) + { + return FALSE; + } + break; + case OP_RESTOREFH: + break; + case OP_SAVEFH: + break; + case OP_SECINFO: + if (!xdr_SECINFO4args (xdrs, &objp->nfs_argop4_u.opsecinfo)) + { + return FALSE; + } + break; + case OP_SETATTR: + if (!xdr_SETATTR4args (xdrs, &objp->nfs_argop4_u.opsetattr)) + { + return FALSE; + } + break; + case OP_SETCLIENTID: + if (!xdr_SETCLIENTID4args (xdrs, &objp->nfs_argop4_u.opsetclientid)) + { + return FALSE; + } + break; + case OP_SETCLIENTID_CONFIRM: + if (!xdr_SETCLIENTID_CONFIRM4args (xdrs, &objp->nfs_argop4_u.opsetclientid_confirm)) + { + return FALSE; + } + break; + case OP_VERIFY: + if (!xdr_VERIFY4args (xdrs, &objp->nfs_argop4_u.opverify)) + { + return FALSE; + } + break; + case OP_WRITE: + if (!xdr_WRITE4args (xdrs, &objp->nfs_argop4_u.opwrite)) + { + return FALSE; + } + break; + case OP_RELEASE_LOCKOWNER: + if (!xdr_RELEASE_LOCKOWNER4args (xdrs, &objp->nfs_argop4_u.oprelease_lockowner)) + { + return FALSE; + } + break; + case OP_GET_DIR_DELEGATION: + if (!xdr_GET_DIR_DELEGATION4args (xdrs, &objp->nfs_argop4_u.opget_dir_delegation)) + { + return FALSE; + } + break; + case OP_ILLEGAL: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_resop4 (XDR* xdrs, nfs_resop4* objp) +{ + if (!xdr_nfs_opnum4 (xdrs, &objp->resop)) + { + return FALSE; + } + switch (objp->resop) + { + case OP_ACCESS: + if (!xdr_ACCESS4res (xdrs, &objp->nfs_resop4_u.opaccess)) + { + return FALSE; + } + break; + case OP_CLOSE: + if (!xdr_CLOSE4res (xdrs, &objp->nfs_resop4_u.opclose)) + { + return FALSE; + } + break; + case OP_COMMIT: + if (!xdr_COMMIT4res (xdrs, &objp->nfs_resop4_u.opcommit)) + { + return FALSE; + } + break; + case OP_CREATE: + if (!xdr_CREATE4res (xdrs, &objp->nfs_resop4_u.opcreate)) + { + return FALSE; + } + break; + case OP_DELEGPURGE: + if (!xdr_DELEGPURGE4res (xdrs, &objp->nfs_resop4_u.opdelegpurge)) + { + return FALSE; + } + break; + case OP_DELEGRETURN: + if (!xdr_DELEGRETURN4res (xdrs, &objp->nfs_resop4_u.opdelegreturn)) + { + return FALSE; + } + break; + case OP_GETATTR: + if (!xdr_GETATTR4res (xdrs, &objp->nfs_resop4_u.opgetattr)) + { + return FALSE; + } + break; + case OP_GETFH: + if (!xdr_GETFH4res (xdrs, &objp->nfs_resop4_u.opgetfh)) + { + return FALSE; + } + break; + case OP_LINK: + if (!xdr_LINK4res (xdrs, &objp->nfs_resop4_u.oplink)) + { + return FALSE; + } + break; + case OP_LOCK: + if (!xdr_LOCK4res (xdrs, &objp->nfs_resop4_u.oplock)) + { + return FALSE; + } + break; + case OP_LOCKT: + if (!xdr_LOCKT4res (xdrs, &objp->nfs_resop4_u.oplockt)) + { + return FALSE; + } + break; + case OP_LOCKU: + if (!xdr_LOCKU4res (xdrs, &objp->nfs_resop4_u.oplocku)) + { + return FALSE; + } + break; + case OP_LOOKUP: + if (!xdr_LOOKUP4res (xdrs, &objp->nfs_resop4_u.oplookup)) + { + return FALSE; + } + break; + case OP_LOOKUPP: + if (!xdr_LOOKUPP4res (xdrs, &objp->nfs_resop4_u.oplookupp)) + { + return FALSE; + } + break; + case OP_NVERIFY: + if (!xdr_NVERIFY4res (xdrs, &objp->nfs_resop4_u.opnverify)) + { + return FALSE; + } + break; + case OP_OPEN: + if (!xdr_OPEN4res (xdrs, &objp->nfs_resop4_u.opopen)) + { + return FALSE; + } + break; + case OP_OPENATTR: + if (!xdr_OPENATTR4res (xdrs, &objp->nfs_resop4_u.opopenattr)) + { + return FALSE; + } + break; + case OP_OPEN_CONFIRM: + if (!xdr_OPEN_CONFIRM4res (xdrs, &objp->nfs_resop4_u.opopen_confirm)) + { + return FALSE; + } + break; + case OP_OPEN_DOWNGRADE: + if (!xdr_OPEN_DOWNGRADE4res (xdrs, &objp->nfs_resop4_u.opopen_downgrade)) + { + return FALSE; + } + break; + case OP_PUTFH: + if (!xdr_PUTFH4res (xdrs, &objp->nfs_resop4_u.opputfh)) + { + return FALSE; + } + break; + case OP_PUTPUBFH: + if (!xdr_PUTPUBFH4res (xdrs, &objp->nfs_resop4_u.opputpubfh)) + { + return FALSE; + } + break; + case OP_PUTROOTFH: + if (!xdr_PUTROOTFH4res (xdrs, &objp->nfs_resop4_u.opputrootfh)) + { + return FALSE; + } + break; + case OP_READ: + if (!xdr_READ4res (xdrs, &objp->nfs_resop4_u.opread)) + { + return FALSE; + } + break; + case OP_READDIR: + if (!xdr_READDIR4res (xdrs, &objp->nfs_resop4_u.opreaddir)) + { + return FALSE; + } + break; + case OP_READLINK: + if (!xdr_READLINK4res (xdrs, &objp->nfs_resop4_u.opreadlink)) + { + return FALSE; + } + break; + case OP_REMOVE: + if (!xdr_REMOVE4res (xdrs, &objp->nfs_resop4_u.opremove)) + { + return FALSE; + } + break; + case OP_RENAME: + if (!xdr_RENAME4res (xdrs, &objp->nfs_resop4_u.oprename)) + { + return FALSE; + } + break; + case OP_RENEW: + if (!xdr_RENEW4res (xdrs, &objp->nfs_resop4_u.oprenew)) + { + return FALSE; + } + break; + case OP_RESTOREFH: + if (!xdr_RESTOREFH4res (xdrs, &objp->nfs_resop4_u.oprestorefh)) + { + return FALSE; + } + break; + case OP_SAVEFH: + if (!xdr_SAVEFH4res (xdrs, &objp->nfs_resop4_u.opsavefh)) + { + return FALSE; + } + break; + case OP_SECINFO: + if (!xdr_SECINFO4res (xdrs, &objp->nfs_resop4_u.opsecinfo)) + { + return FALSE; + } + break; + case OP_SETATTR: + if (!xdr_SETATTR4res (xdrs, &objp->nfs_resop4_u.opsetattr)) + { + return FALSE; + } + break; + case OP_SETCLIENTID: + if (!xdr_SETCLIENTID4res (xdrs, &objp->nfs_resop4_u.opsetclientid)) + { + return FALSE; + } + break; + case OP_SETCLIENTID_CONFIRM: + if (!xdr_SETCLIENTID_CONFIRM4res (xdrs, &objp->nfs_resop4_u.opsetclientid_confirm)) + { + return FALSE; + } + break; + case OP_VERIFY: + if (!xdr_VERIFY4res (xdrs, &objp->nfs_resop4_u.opverify)) + { + return FALSE; + } + break; + case OP_WRITE: + if (!xdr_WRITE4res (xdrs, &objp->nfs_resop4_u.opwrite)) + { + return FALSE; + } + break; + case OP_RELEASE_LOCKOWNER: + if (!xdr_RELEASE_LOCKOWNER4res (xdrs, &objp->nfs_resop4_u.oprelease_lockowner)) + { + return FALSE; + } + break; + case OP_GET_DIR_DELEGATION: + if (!xdr_GET_DIR_DELEGATION4res (xdrs, &objp->nfs_resop4_u.opget_dir_delegation)) + { + return FALSE; + } + break; + case OP_ILLEGAL: + if (!xdr_ILLEGAL4res (xdrs, &objp->nfs_resop4_u.opillegal)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMPOUND4args (XDR* xdrs, COMPOUND4args* objp) +{ + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->minorversion)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->argarray.argarray_val, (u_int*) &objp->argarray.argarray_len, ~0, + sizeof (nfs_argop4), (xdrproc_t) xdr_nfs_argop4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_COMPOUND4res (XDR* xdrs, COMPOUND4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->resarray.resarray_val, (u_int*) &objp->resarray.resarray_len, ~0, + sizeof (nfs_resop4), (xdrproc_t) xdr_nfs_resop4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_GETATTR4args (XDR* xdrs, CB_GETATTR4args* objp) +{ + if (!xdr_nfs_fh4 (xdrs, &objp->fh)) + { + return FALSE; + } + if (!xdr_bitmap4 (xdrs, &objp->attr_request)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_GETATTR4resok (XDR* xdrs, CB_GETATTR4resok* objp) +{ + if (!xdr_fattr4 (xdrs, &objp->obj_attributes)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_GETATTR4res (XDR* xdrs, CB_GETATTR4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + switch (objp->status) + { + case NFS4_OK: + if (!xdr_CB_GETATTR4resok (xdrs, &objp->CB_GETATTR4res_u.resok4)) + { + return FALSE; + } + break; + default: + break; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL4args (XDR* xdrs, CB_RECALL4args* objp) +{ + if (!xdr_stateid4 (xdrs, &objp->stateid)) + { + return FALSE; + } + if (!xdr_bool (xdrs, &objp->truncate)) + { + return FALSE; + } + if (!xdr_nfs_fh4 (xdrs, &objp->fh)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_RECALL4res (XDR* xdrs, CB_RECALL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_ILLEGAL4res (XDR* xdrs, CB_ILLEGAL4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cb_opnum4 (XDR* xdrs, nfs_cb_opnum4* objp) +{ + if (!xdr_enum (xdrs, (enum_t*) objp)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cb_argop4 (XDR* xdrs, nfs_cb_argop4* objp) +{ + if (!xdr_u_int (xdrs, &objp->argop)) + { + return FALSE; + } + switch (objp->argop) + { + case OP_CB_GETATTR: + if (!xdr_CB_GETATTR4args (xdrs, &objp->nfs_cb_argop4_u.opcbgetattr)) + { + return FALSE; + } + break; + case OP_CB_RECALL: + if (!xdr_CB_RECALL4args (xdrs, &objp->nfs_cb_argop4_u.opcbrecall)) + { + return FALSE; + } + break; + case OP_CB_ILLEGAL: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_nfs_cb_resop4 (XDR* xdrs, nfs_cb_resop4* objp) +{ + if (!xdr_u_int (xdrs, &objp->resop)) + { + return FALSE; + } + switch (objp->resop) + { + case OP_CB_GETATTR: + if (!xdr_CB_GETATTR4res (xdrs, &objp->nfs_cb_resop4_u.opcbgetattr)) + { + return FALSE; + } + break; + case OP_CB_RECALL: + if (!xdr_CB_RECALL4res (xdrs, &objp->nfs_cb_resop4_u.opcbrecall)) + { + return FALSE; + } + break; + case OP_CB_ILLEGAL: + if (!xdr_CB_ILLEGAL4res (xdrs, &objp->nfs_cb_resop4_u.opcbillegal)) + { + return FALSE; + } + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_COMPOUND4args (XDR* xdrs, CB_COMPOUND4args* objp) +{ + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->minorversion)) + { + return FALSE; + } + if (!xdr_uint32_t (xdrs, &objp->callback_ident)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->argarray.argarray_val, (u_int*) &objp->argarray.argarray_len, ~0, + sizeof (nfs_cb_argop4), (xdrproc_t) xdr_nfs_cb_argop4)) + { + return FALSE; + } + return TRUE; +} + +bool_t +xdr_CB_COMPOUND4res (XDR* xdrs, CB_COMPOUND4res* objp) +{ + if (!xdr_nfsstat4 (xdrs, &objp->status)) + { + return FALSE; + } + if (!xdr_utf8str_cs (xdrs, &objp->tag)) + { + return FALSE; + } + if (!xdr_array (xdrs, (char**)&objp->resarray.resarray_val, (u_int*) &objp->resarray.resarray_len, ~0, + sizeof (nfs_cb_resop4), (xdrproc_t) xdr_nfs_cb_resop4)) + { + return FALSE; + } + return TRUE; +} + } // namespace NFS4 } // namespace protocols } // namespace NST diff --git a/src/protocols/nfs4/nfs4_utils.h b/src/protocols/nfs4/nfs4_utils.h index 986b366..569f23f 100644 --- a/src/protocols/nfs4/nfs4_utils.h +++ b/src/protocols/nfs4/nfs4_utils.h @@ -1,7 +1,7 @@ //------------------------------------------------------------------------------ // Author: Alexey Costroma // Description: Helpers for parsing NFS structures. -// Copyright (c) 2014 EPAM Systems +// Copyright (c) 2014-2015 EPAM Systems //------------------------------------------------------------------------------ /* This file is part of Nfstrace. @@ -19,7 +19,6 @@ along with Nfstrace. If not, see <http://www.gnu.org/licenses/>. */ //------------------------------------------------------------------------------ -#define NST_PUBLIC __attribute__ ((visibility("default"))) #ifndef NFS4_UTILS_H #define NFS4_UTILS_H //------------------------------------------------------------------------------ @@ -37,6 +36,8 @@ namespace protocols namespace NFS4 { +namespace NFS4 = NST::API::NFS4; + using ProcEnumNFS4 = API::ProcEnumNFS4; using Validator = rpc::RPCProgramValidator @@ -47,84 +48,323 @@ using Validator = rpc::RPCProgramValidator ProcEnumNFS4::COMPOUND // NFSPROC4RPCGEN_COMPOUND (1) >; +bool_t xdr_nfs_ftype4 (XDR *, NFS4::nfs_ftype4*); +bool_t xdr_nfsstat4 (XDR *, NFS4::nfsstat4*); +bool_t xdr_bitmap4 (XDR *, NFS4::bitmap4*); +bool_t xdr_offset4 (XDR *, NFS4::offset4*); +bool_t xdr_count4 (XDR *, NFS4::count4*); +bool_t xdr_length4 (XDR *, NFS4::length4*); +bool_t xdr_clientid4 (XDR *, NFS4::clientid4*); +bool_t xdr_seqid4 (XDR *, NFS4::seqid4*); +bool_t xdr_utf8string (XDR *, NFS4::utf8string*); +bool_t xdr_utf8str_cis (XDR *, NFS4::utf8str_cis*); +bool_t xdr_utf8str_cs (XDR *, NFS4::utf8str_cs*); +bool_t xdr_utf8str_mixed (XDR *, NFS4::utf8str_mixed*); +bool_t xdr_component4 (XDR *, NFS4::component4*); +bool_t xdr_pathname4 (XDR *, NFS4::pathname4*); +bool_t xdr_nfs_lockid4 (XDR *, NFS4::nfs_lockid4*); +bool_t xdr_nfs_cookie4 (XDR *, NFS4::nfs_cookie4*); +bool_t xdr_linktext4 (XDR *, NFS4::linktext4*); +bool_t xdr_sec_oid4 (XDR *, NFS4::sec_oid4*); +bool_t xdr_qop4 (XDR *, NFS4::qop4*); +bool_t xdr_mode4 (XDR *, NFS4::mode4*); +bool_t xdr_changeid4 (XDR *, NFS4::changeid4*); +bool_t xdr_verifier4 (XDR *, NFS4::verifier4); +bool_t xdr_nfstime4 (XDR *, NFS4::nfstime4*); +bool_t xdr_time_how4 (XDR *, NFS4::time_how4*); +bool_t xdr_settime4 (XDR *, NFS4::settime4*); +bool_t xdr_nfs_fh4 (XDR *, NFS4::nfs_fh4*); +bool_t xdr_fsid4 (XDR *, NFS4::fsid4*); +bool_t xdr_fs_location4 (XDR *, NFS4::fs_location4*); +bool_t xdr_fs_locations4 (XDR *, NFS4::fs_locations4*); +bool_t xdr_acetype4 (XDR *, NFS4::acetype4*); +bool_t xdr_aceflag4 (XDR *, NFS4::aceflag4*); +bool_t xdr_acemask4 (XDR *, NFS4::acemask4*); +bool_t xdr_nfsace4 (XDR *, NFS4::nfsace4*); +bool_t xdr_specdata4 (XDR *, NFS4::specdata4*); +bool_t xdr_fattr4_supported_attrs (XDR *, NFS4::fattr4_supported_attrs*); +bool_t xdr_fattr4_type (XDR *, NFS4::fattr4_type*); +bool_t xdr_fattr4_fh_expire_type (XDR *, NFS4::fattr4_fh_expire_type*); +bool_t xdr_fattr4_change (XDR *, NFS4::fattr4_change*); +bool_t xdr_fattr4_size (XDR *, NFS4::fattr4_size*); +bool_t xdr_fattr4_link_support (XDR *, NFS4::fattr4_link_support*); +bool_t xdr_fattr4_symlink_support (XDR *, NFS4::fattr4_symlink_support*); +bool_t xdr_fattr4_named_attr (XDR *, NFS4::fattr4_named_attr*); +bool_t xdr_fattr4_fsid (XDR *, NFS4::fattr4_fsid*); +bool_t xdr_fattr4_unique_handles (XDR *, NFS4::fattr4_unique_handles*); +bool_t xdr_fattr4_lease_time (XDR *, NFS4::fattr4_lease_time*); +bool_t xdr_fattr4_rdattr_error (XDR *, NFS4::fattr4_rdattr_error*); +bool_t xdr_fattr4_acl (XDR *, NFS4::fattr4_acl*); +bool_t xdr_fattr4_aclsupport (XDR *, NFS4::fattr4_aclsupport*); +bool_t xdr_fattr4_archive (XDR *, NFS4::fattr4_archive*); +bool_t xdr_fattr4_cansettime (XDR *, NFS4::fattr4_cansettime*); +bool_t xdr_fattr4_case_insensitive (XDR *, NFS4::fattr4_case_insensitive*); +bool_t xdr_fattr4_case_preserving (XDR *, NFS4::fattr4_case_preserving*); +bool_t xdr_fattr4_chown_restricted (XDR *, NFS4::fattr4_chown_restricted*); +bool_t xdr_fattr4_fileid (XDR *, NFS4::fattr4_fileid*); +bool_t xdr_fattr4_files_avail (XDR *, NFS4::fattr4_files_avail*); +bool_t xdr_fattr4_filehandle (XDR *, NFS4::fattr4_filehandle*); +bool_t xdr_fattr4_files_free (XDR *, NFS4::fattr4_files_free*); +bool_t xdr_fattr4_files_total (XDR *, NFS4::fattr4_files_total*); +bool_t xdr_fattr4_fs_locations (XDR *, NFS4::fattr4_fs_locations*); +bool_t xdr_fattr4_hidden (XDR *, NFS4::fattr4_hidden*); +bool_t xdr_fattr4_homogeneous (XDR *, NFS4::fattr4_homogeneous*); +bool_t xdr_fattr4_maxfilesize (XDR *, NFS4::fattr4_maxfilesize*); +bool_t xdr_fattr4_maxlink (XDR *, NFS4::fattr4_maxlink*); +bool_t xdr_fattr4_maxname (XDR *, NFS4::fattr4_maxname*); +bool_t xdr_fattr4_maxread (XDR *, NFS4::fattr4_maxread*); +bool_t xdr_fattr4_maxwrite (XDR *, NFS4::fattr4_maxwrite*); +bool_t xdr_fattr4_mimetype (XDR *, NFS4::fattr4_mimetype*); +bool_t xdr_fattr4_mode (XDR *, NFS4::fattr4_mode*); +bool_t xdr_fattr4_mounted_on_fileid (XDR *, NFS4::fattr4_mounted_on_fileid*); +bool_t xdr_fattr4_no_trunc (XDR *, NFS4::fattr4_no_trunc*); +bool_t xdr_fattr4_numlinks (XDR *, NFS4::fattr4_numlinks*); +bool_t xdr_fattr4_owner (XDR *, NFS4::fattr4_owner*); +bool_t xdr_fattr4_owner_group (XDR *, NFS4::fattr4_owner_group*); +bool_t xdr_fattr4_quota_avail_hard (XDR *, NFS4::fattr4_quota_avail_hard*); +bool_t xdr_fattr4_quota_avail_soft (XDR *, NFS4::fattr4_quota_avail_soft*); +bool_t xdr_fattr4_quota_used (XDR *, NFS4::fattr4_quota_used*); +bool_t xdr_fattr4_rawdev (XDR *, NFS4::fattr4_rawdev*); +bool_t xdr_fattr4_space_avail (XDR *, NFS4::fattr4_space_avail*); +bool_t xdr_fattr4_space_free (XDR *, NFS4::fattr4_space_free*); +bool_t xdr_fattr4_space_total (XDR *, NFS4::fattr4_space_total*); +bool_t xdr_fattr4_space_used (XDR *, NFS4::fattr4_space_used*); +bool_t xdr_fattr4_system (XDR *, NFS4::fattr4_system*); +bool_t xdr_fattr4_time_access (XDR *, NFS4::fattr4_time_access*); +bool_t xdr_fattr4_time_access_set (XDR *, NFS4::fattr4_time_access_set*); +bool_t xdr_fattr4_time_backup (XDR *, NFS4::fattr4_time_backup*); +bool_t xdr_fattr4_time_create (XDR *, NFS4::fattr4_time_create*); +bool_t xdr_fattr4_time_delta (XDR *, NFS4::fattr4_time_delta*); +bool_t xdr_fattr4_time_metadata (XDR *, NFS4::fattr4_time_metadata*); +bool_t xdr_fattr4_time_modify (XDR *, NFS4::fattr4_time_modify*); +bool_t xdr_fattr4_time_modify_set (XDR *, NFS4::fattr4_time_modify_set*); +bool_t xdr_attrlist4 (XDR *, NFS4::attrlist4*); +bool_t xdr_fattr4 (XDR *, NFS4::fattr4*); +bool_t xdr_change_info4 (XDR *, NFS4::change_info4*); +bool_t xdr_clientaddr4 (XDR *, NFS4::clientaddr4*); +bool_t xdr_cb_client4 (XDR *, NFS4::cb_client4*); +bool_t xdr_stateid4 (XDR *, NFS4::stateid4*); +bool_t xdr_nfs_client_id4 (XDR *, NFS4::nfs_client_id4*); +bool_t xdr_open_owner4 (XDR *, NFS4::open_owner4*); +bool_t xdr_lock_owner4 (XDR *, NFS4::lock_owner4*); +bool_t xdr_nfs_lock_type4 (XDR *, NFS4::nfs_lock_type4*); +bool_t xdr_NULL4args (XDR *, NFS4::NULL4args*); // for compatibility +bool_t xdr_NULL4res (XDR *, NFS4::NULL4res*); // for compatibility +bool_t xdr_ACCESS4args (XDR *, NFS4::ACCESS4args*); +bool_t xdr_ACCESS4resok (XDR *, NFS4::ACCESS4resok*); +bool_t xdr_ACCESS4res (XDR *, NFS4::ACCESS4res*); +bool_t xdr_CLOSE4args (XDR *, NFS4::CLOSE4args*); +bool_t xdr_CLOSE4res (XDR *, NFS4::CLOSE4res*); +bool_t xdr_COMMIT4args (XDR *, NFS4::COMMIT4args*); +bool_t xdr_COMMIT4resok (XDR *, NFS4::COMMIT4resok*); +bool_t xdr_COMMIT4res (XDR *, NFS4::COMMIT4res*); +bool_t xdr_createtype4 (XDR *, NFS4::createtype4*); +bool_t xdr_CREATE4args (XDR *, NFS4::CREATE4args*); +bool_t xdr_CREATE4resok (XDR *, NFS4::CREATE4resok*); +bool_t xdr_CREATE4res (XDR *, NFS4::CREATE4res*); +bool_t xdr_DELEGPURGE4args (XDR *, NFS4::DELEGPURGE4args*); +bool_t xdr_DELEGPURGE4res (XDR *, NFS4::DELEGPURGE4res*); +bool_t xdr_DELEGRETURN4args (XDR *, NFS4::DELEGRETURN4args*); +bool_t xdr_DELEGRETURN4res (XDR *, NFS4::DELEGRETURN4res*); +bool_t xdr_GETATTR4args (XDR *, NFS4::GETATTR4args*); +bool_t xdr_GETATTR4resok (XDR *, NFS4::GETATTR4resok*); +bool_t xdr_GETATTR4res (XDR *, NFS4::GETATTR4res*); +bool_t xdr_notification_types4 (XDR *, NFS4::notification_types4*); +bool_t xdr_notification_delay4 (XDR *, NFS4::notification_delay4*); +bool_t xdr_dir_delegation_status4 (XDR *, NFS4::dir_delegation_status4*); +bool_t xdr_GET_DIR_DELEGATION4args (XDR *, NFS4::GET_DIR_DELEGATION4args*); +bool_t xdr_GET_DIR_DELEGATION4resok (XDR *, NFS4::GET_DIR_DELEGATION4resok*); +bool_t xdr_GET_DIR_DELEGATION4res (XDR *, NFS4::GET_DIR_DELEGATION4res*); +bool_t xdr_GETFH4resok (XDR *, NFS4::GETFH4resok*); +bool_t xdr_GETFH4res (XDR *, NFS4::GETFH4res*); +bool_t xdr_LINK4args (XDR *, NFS4::LINK4args*); +bool_t xdr_LINK4resok (XDR *, NFS4::LINK4resok*); +bool_t xdr_LINK4res (XDR *, NFS4::LINK4res*); +bool_t xdr_open_to_lock_owner4 (XDR *, NFS4::open_to_lock_owner4*); +bool_t xdr_exist_lock_owner4 (XDR *, NFS4::exist_lock_owner4*); +bool_t xdr_locker4 (XDR *, NFS4::locker4*); +bool_t xdr_LOCK4args (XDR *, NFS4::LOCK4args*); +bool_t xdr_LOCK4denied (XDR *, NFS4::LOCK4denied*); +bool_t xdr_LOCK4resok (XDR *, NFS4::LOCK4resok*); +bool_t xdr_LOCK4res (XDR *, NFS4::LOCK4res*); +bool_t xdr_LOCKT4args (XDR *, NFS4::LOCKT4args*); +bool_t xdr_LOCKT4res (XDR *, NFS4::LOCKT4res*); +bool_t xdr_LOCKU4args (XDR *, NFS4::LOCKU4args*); +bool_t xdr_LOCKU4res (XDR *, NFS4::LOCKU4res*); +bool_t xdr_LOOKUP4args (XDR *, NFS4::LOOKUP4args*); +bool_t xdr_LOOKUP4res (XDR *, NFS4::LOOKUP4res*); +bool_t xdr_LOOKUPP4res (XDR *, NFS4::LOOKUPP4res*); +bool_t xdr_NVERIFY4args (XDR *, NFS4::NVERIFY4args*); +bool_t xdr_NVERIFY4res (XDR *, NFS4::NVERIFY4res*); +bool_t xdr_createmode4 (XDR *, NFS4::createmode4*); +bool_t xdr_createhow4 (XDR *, NFS4::createhow4*); +bool_t xdr_opentype4 (XDR *, NFS4::opentype4*); +bool_t xdr_openflag4 (XDR *, NFS4::openflag4*); +bool_t xdr_limit_by4 (XDR *, NFS4::limit_by4*); +bool_t xdr_nfs_modified_limit4 (XDR *, NFS4::nfs_modified_limit4*); +bool_t xdr_nfs_space_limit4 (XDR *, NFS4::nfs_space_limit4*); +bool_t xdr_open_delegation_type4 (XDR *, NFS4::open_delegation_type4*); +bool_t xdr_open_claim_type4 (XDR *, NFS4::open_claim_type4*); +bool_t xdr_open_claim_delegate_cur4 (XDR *, NFS4::open_claim_delegate_cur4*); +bool_t xdr_open_claim4 (XDR *, NFS4::open_claim4*); +bool_t xdr_OPEN4args (XDR *, NFS4::OPEN4args*); +bool_t xdr_open_read_delegation4 (XDR *, NFS4::open_read_delegation4*); +bool_t xdr_open_write_delegation4 (XDR *, NFS4::open_write_delegation4*); +bool_t xdr_open_delegation4 (XDR *, NFS4::open_delegation4*); +bool_t xdr_OPEN4resok (XDR *, NFS4::OPEN4resok*); +bool_t xdr_OPEN4res (XDR *, NFS4::OPEN4res*); +bool_t xdr_OPENATTR4args (XDR *, NFS4::OPENATTR4args*); +bool_t xdr_OPENATTR4res (XDR *, NFS4::OPENATTR4res*); +bool_t xdr_OPEN_CONFIRM4args (XDR *, NFS4::OPEN_CONFIRM4args*); +bool_t xdr_OPEN_CONFIRM4resok (XDR *, NFS4::OPEN_CONFIRM4resok*); +bool_t xdr_OPEN_CONFIRM4res (XDR *, NFS4::OPEN_CONFIRM4res*); +bool_t xdr_OPEN_DOWNGRADE4args (XDR *, NFS4::OPEN_DOWNGRADE4args*); +bool_t xdr_OPEN_DOWNGRADE4resok (XDR *, NFS4::OPEN_DOWNGRADE4resok*); +bool_t xdr_OPEN_DOWNGRADE4res (XDR *, NFS4::OPEN_DOWNGRADE4res*); +bool_t xdr_PUTFH4args (XDR *, NFS4::PUTFH4args*); +bool_t xdr_PUTFH4res (XDR *, NFS4::PUTFH4res*); +bool_t xdr_PUTPUBFH4res (XDR *, NFS4::PUTPUBFH4res*); +bool_t xdr_PUTROOTFH4res (XDR *, NFS4::PUTROOTFH4res*); +bool_t xdr_READ4args (XDR *, NFS4::READ4args*); +bool_t xdr_READ4resok (XDR *, NFS4::READ4resok*); +bool_t xdr_READ4res (XDR *, NFS4::READ4res*); +bool_t xdr_READDIR4args (XDR *, NFS4::READDIR4args*); +bool_t xdr_entry4 (XDR *, NFS4::entry4*); +bool_t xdr_dirlist4 (XDR *, NFS4::dirlist4*); +bool_t xdr_READDIR4resok (XDR *, NFS4::READDIR4resok*); +bool_t xdr_READDIR4res (XDR *, NFS4::READDIR4res*); +bool_t xdr_READLINK4resok (XDR *, NFS4::READLINK4resok*); +bool_t xdr_READLINK4res (XDR *, NFS4::READLINK4res*); +bool_t xdr_REMOVE4args (XDR *, NFS4::REMOVE4args*); +bool_t xdr_REMOVE4resok (XDR *, NFS4::REMOVE4resok*); +bool_t xdr_REMOVE4res (XDR *, NFS4::REMOVE4res*); +bool_t xdr_RENAME4args (XDR *, NFS4::RENAME4args*); +bool_t xdr_RENAME4resok (XDR *, NFS4::RENAME4resok*); +bool_t xdr_RENAME4res (XDR *, NFS4::RENAME4res*); +bool_t xdr_RENEW4args (XDR *, NFS4::RENEW4args*); +bool_t xdr_RENEW4res (XDR *, NFS4::RENEW4res*); +bool_t xdr_RESTOREFH4res (XDR *, NFS4::RESTOREFH4res*); +bool_t xdr_SAVEFH4res (XDR *, NFS4::SAVEFH4res*); +bool_t xdr_SECINFO4args (XDR *, NFS4::SECINFO4args*); +bool_t xdr_rpc_gss_svc_t (XDR *, NFS4::rpc_gss_svc_t*); +bool_t xdr_rpcsec_gss_info (XDR *, NFS4::rpcsec_gss_info*); +bool_t xdr_secinfo4 (XDR *, NFS4::secinfo4*); +bool_t xdr_SECINFO4resok (XDR *, NFS4::SECINFO4resok*); +bool_t xdr_SECINFO4res (XDR *, NFS4::SECINFO4res*); +bool_t xdr_SETATTR4args (XDR *, NFS4::SETATTR4args*); +bool_t xdr_SETATTR4res (XDR *, NFS4::SETATTR4res*); +bool_t xdr_SETCLIENTID4args (XDR *, NFS4::SETCLIENTID4args*); +bool_t xdr_SETCLIENTID4resok (XDR *, NFS4::SETCLIENTID4resok*); +bool_t xdr_SETCLIENTID4res (XDR *, NFS4::SETCLIENTID4res*); +bool_t xdr_SETCLIENTID_CONFIRM4args (XDR *, NFS4::SETCLIENTID_CONFIRM4args*); +bool_t xdr_SETCLIENTID_CONFIRM4res (XDR *, NFS4::SETCLIENTID_CONFIRM4res*); +bool_t xdr_VERIFY4args (XDR *, NFS4::VERIFY4args*); +bool_t xdr_VERIFY4res (XDR *, NFS4::VERIFY4res*); +bool_t xdr_stable_how4 (XDR *, NFS4::stable_how4*); +bool_t xdr_WRITE4args (XDR *, NFS4::WRITE4args*); +bool_t xdr_WRITE4resok (XDR *, NFS4::WRITE4resok*); +bool_t xdr_WRITE4res (XDR *, NFS4::WRITE4res*); +bool_t xdr_RELEASE_LOCKOWNER4args (XDR *, NFS4::RELEASE_LOCKOWNER4args*); +bool_t xdr_RELEASE_LOCKOWNER4res (XDR *, NFS4::RELEASE_LOCKOWNER4res*); +bool_t xdr_ILLEGAL4res (XDR *, NFS4::ILLEGAL4res*); +bool_t xdr_nfs_opnum4 (XDR *, NFS4::nfs_opnum4*); +bool_t xdr_nfs_argop4 (XDR *, NFS4::nfs_argop4*); +bool_t xdr_nfs_resop4 (XDR *, NFS4::nfs_resop4*); +bool_t xdr_COMPOUND4args (XDR *, NFS4::COMPOUND4args*); +bool_t xdr_COMPOUND4res (XDR *, NFS4::COMPOUND4res*); +bool_t xdr_CB_GETATTR4args (XDR *, NFS4::CB_GETATTR4args*); +bool_t xdr_CB_GETATTR4resok (XDR *, NFS4::CB_GETATTR4resok*); +bool_t xdr_CB_GETATTR4res (XDR *, NFS4::CB_GETATTR4res*); +bool_t xdr_CB_RECALL4args (XDR *, NFS4::CB_RECALL4args*); +bool_t xdr_CB_RECALL4res (XDR *, NFS4::CB_RECALL4res*); +bool_t xdr_CB_ILLEGAL4res (XDR *, NFS4::CB_ILLEGAL4res*); +bool_t xdr_nfs_cb_opnum4 (XDR *, NFS4::nfs_cb_opnum4*); +bool_t xdr_nfs_cb_argop4 (XDR *, NFS4::nfs_cb_argop4*); +bool_t xdr_nfs_cb_resop4 (XDR *, NFS4::nfs_cb_resop4*); +bool_t xdr_CB_COMPOUND4args (XDR *, NFS4::CB_COMPOUND4args*); +bool_t xdr_CB_COMPOUND4res (XDR *, NFS4::CB_COMPOUND4res*); + + // Procedure 0: NULL - Do nothing -inline auto proc_t_of(rpcgen::NULL4args&)->decltype(&rpcgen::xdr_NULL4args) +inline auto proc_t_of(NFS4::NULL4args&)->decltype(&xdr_NULL4args) { - return &rpcgen::xdr_NULL4args; + return &xdr_NULL4args; } -inline auto proc_t_of(rpcgen::NULL4res&)->decltype(&rpcgen::xdr_NULL4res) +inline auto proc_t_of(NFS4::NULL4res&)->decltype(&xdr_NULL4res) { - return &rpcgen::xdr_NULL4res; + return &xdr_NULL4res; } // Procedure 1: COMPOUND -inline auto proc_t_of(rpcgen::COMPOUND4args&)->decltype(&rpcgen::xdr_COMPOUND4args) +inline auto proc_t_of(NFS4::COMPOUND4args&)->decltype(&xdr_COMPOUND4args) { - return &rpcgen::xdr_COMPOUND4args; + return &xdr_COMPOUND4args; } -inline auto proc_t_of(rpcgen::COMPOUND4res&)->decltype(&rpcgen::xdr_COMPOUND4res) +inline auto proc_t_of(NFS4::COMPOUND4res&)->decltype(&xdr_COMPOUND4res) { - return &rpcgen::xdr_COMPOUND4res; + return &xdr_COMPOUND4res; } +#define NST_PUBLIC __attribute__ ((visibility("default"))) + extern"C" NST_PUBLIC const char* print_nfs4_procedures(const ProcEnumNFS4::NFSProcedure proc); std::ostream& operator<<(std::ostream& out, const ProcEnumNFS4::NFSProcedure proc); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_ftype4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfsstat4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::bitmap4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::utf8string& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::pathname4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::sec_oid4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfstime4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::time_how4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::settime4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_fh4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::fsid4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::fs_location4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::fs_locations4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfsace4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::specdata4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::fattr4_acl& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::attrlist4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::fattr4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::change_info4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::clientaddr4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::cb_client4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::stateid4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_client_id4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_owner4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::lock_owner4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_lock_type4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::createtype4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::dir_delegation_status4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_to_lock_owner4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::exist_lock_owner4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::locker4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::createmode4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::opentype4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::limit_by4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_delegation_type4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim_type4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::rpc_gss_svc_t& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::stable_how4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::createhow4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::openflag4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_modified_limit4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::nfs_space_limit4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim_delegate_cur4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_claim4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_read_delegation4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_write_delegation4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::open_delegation4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::entry4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::dirlist4& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::rpcsec_gss_info& obj); -std::ostream& operator<<(std::ostream& out, const rpcgen::secinfo4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfs_ftype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfsstat4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::bitmap4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::utf8string& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::pathname4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::sec_oid4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfstime4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::time_how4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::settime4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfs_fh4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::fsid4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::fs_location4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::fs_locations4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfsace4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::specdata4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::fattr4_acl& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::attrlist4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::fattr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::change_info4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::clientaddr4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::cb_client4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::stateid4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfs_client_id4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::lock_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfs_lock_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::createtype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::dir_delegation_status4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_to_lock_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::exist_lock_owner4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::locker4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::createmode4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::opentype4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::limit_by4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_delegation_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_claim_type4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::rpc_gss_svc_t& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::stable_how4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::createhow4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::openflag4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfs_modified_limit4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::nfs_space_limit4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_claim_delegate_cur4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_claim4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_read_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_write_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::open_delegation4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::entry4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::dirlist4& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::rpcsec_gss_info& obj); +std::ostream& operator<<(std::ostream& out, const NFS4::secinfo4& obj); } // namespace NFS4 } // namespace protocols diff --git a/src/protocols/xdr/xdr_decoder.h b/src/protocols/xdr/xdr_decoder.h index 7c2e48b..c057442 100644 --- a/src/protocols/xdr/xdr_decoder.h +++ b/src/protocols/xdr/xdr_decoder.h @@ -72,4 +72,3 @@ private: //------------------------------------------------------------------------------ #endif//XDR_DECODER_H //------------------------------------------------------------------------------ - |