nfs41_xdr.c File Reference

#include <windows.h>
#include <strsafe.h>
#include "nfs41_compound.h"
#include "nfs41_ops.h"
#include "nfs41_xdr.h"
#include "util.h"
#include "daemon_debug.h"
#include "rpc/rpc.h"

Include dependency graph for nfs41_xdr.c:

Go to the source code of this file.

Classes
struct	__readdir_entry_iterator
struct	__op_table_entry

Typedefs
typedef struct __readdir_entry_iterator	readdir_entry_iterator
typedef bool_t(*	nfs_op_encode_proc) (XDR *, nfs_argop4 *)
typedef bool_t(*	nfs_op_decode_proc) (XDR *, nfs_resop4 *)
typedef struct __op_table_entry	op_table_entry

Enumerations
enum	limit_by4 { NFS_LIMIT_SIZE = 1 , NFS_LIMIT_BLOCKS = 2 }

Functions
static bool_t	encode_file_attrs (fattr4 *attrs, nfs41_file_info *info)
static __inline int	unexpected_op (uint32_t op, uint32_t expected)
bool_t	xdr_bitmap4 (XDR *xdr, bitmap4 *bitmap)
static bool_t	xdr_nfstime4 (XDR *xdr, nfstime4 *nt)
static uint32_t	settime_how (nfstime4 *newtime, const nfstime4 *time_delta)
static bool_t	xdr_settime4 (XDR *xdr, nfstime4 *nt, const nfstime4 *time_delta)
static bool_t	xdr_stateid4 (XDR *xdr, stateid4 *si)
bool_t	xdr_fattr4 (XDR *xdr, fattr4 *fattr)
static bool_t	xdr_fh (XDR *xdr, nfs41_fh *fh)
static bool_t	xdr_fsid (XDR *xdr, nfs41_fsid *fsid)
static bool_t	encode_component (XDR *xdr, const nfs41_component *component)
static bool_t	decode_component (XDR *xdr, nfs41_component *component)
static bool_t	xdr_state_owner4 (XDR *xdr, state_owner4 *so)
static bool_t	xdr_layout_types (XDR *xdr, uint32_t *layout_type)
static bool_t	xdr_threshold_item (XDR *xdr, threshold_item4 *item)
static bool_t	xdr_mdsthreshold (XDR *xdr, mdsthreshold4 *mdsthreshold)
static bool_t	xdr_nfsace4 (XDR *xdr, nfsace4 *ace)
static bool_t	xdr_nfsdacl41 (XDR *xdr, nfsacl41 *acl)
static bool_t	xdr_nfsacl41 (XDR *xdr, nfsacl41 *acl)
void	nfsacl41_free (nfsacl41 *acl)
static bool_t	decode_pathname4 (XDR *xdr, nfs41_abs_path *path)
static bool_t	decode_fs_location4 (XDR *xdr, fs_location4 *location)
static bool_t	decode_fs_locations4 (XDR *xdr, fs_locations4 *locations)
static bool_t	xdr_client_owner4 (XDR *xdr, client_owner4 *co)
static bool_t	xdr_state_protect4_a (XDR *xdr, state_protect4_a *spa)
static bool_t	xdr_nfs_impl_id4 (XDR *xdr, nfs_impl_id4 *nii)
static bool_t	encode_op_exchange_id (XDR *xdr, nfs_argop4 *argop)
static bool_t	xdr_state_protect4_r (XDR *xdr, state_protect4_r *spr)
static bool_t	xdr_server_owner4 (XDR *xdr, server_owner4 *so)
static bool_t	decode_op_exchange_id (XDR *xdr, nfs_resop4 *resop)
static bool_t	xdr_channel_attrs4 (XDR *xdr, nfs41_channel_attrs *attrs)
static bool_t	encode_backchannel_sec_parms (XDR *xdr, nfs41_callback_secparms *args)
static bool_t	encode_op_create_session (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_create_session (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_bind_conn_to_session (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_bind_conn_to_session (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_destroy_session (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_destroy_session (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_destroy_clientid (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_destroy_clientid (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_sequence (XDR *xdr, nfs_argop4 *argop)
static bool_t	xdr_sequence_res_ok (XDR *xdr, nfs41_sequence_res_ok *res)
static bool_t	decode_op_sequence (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_reclaim_complete (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_reclaim_complete (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_putfh (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_putfh (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_putrootfh (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_putrootfh (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_getfh (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_getfh (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_lookup (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_lookup (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_access (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_access (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_close (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_close (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_commit (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_commit (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_createtype4 (XDR *xdr, createtype4 *ct)
static bool_t	encode_createattrs4 (XDR *xdr, nfs41_file_info *createattrs)
static bool_t	encode_op_create (XDR *xdr, nfs_argop4 *argop)
static bool_t	xdr_change_info4 (XDR *xdr, change_info4 *cinfo)
static bool_t	decode_op_create (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_link (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_link (XDR *xdr, nfs_resop4 *resop)
static bool_t	xdr_locker4 (XDR *xdr, locker4 *locker)
static bool_t	encode_op_lock (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_lock_res_denied (XDR *xdr, lock_res_denied *denied)
static bool_t	decode_op_lock (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_lockt (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_lockt (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_locku (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_locku (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_delegpurge (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_delegpurge (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_delegreturn (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_delegreturn (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_getattr (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_file_attrs (XDR *xdr, fattr4 *attrs, nfs41_file_info *info)
static bool_t	decode_op_getattr (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_createhow4 (XDR *xdr, createhow4 *ch)
static bool_t	encode_openflag4 (XDR *xdr, openflag4 *of)
static bool_t	encode_claim_deleg_cur (XDR *xdr, stateid4 *stateid, nfs41_component *name)
static bool_t	encode_open_claim4 (XDR *xdr, open_claim4 *oc)
static bool_t	encode_op_open (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_open_none_delegation4 (XDR *xdr, open_delegation4 *delegation)
static bool_t	decode_open_read_delegation4 (XDR *xdr, open_delegation4 *delegation)
static bool_t	decode_modified_limit4 (XDR *xdr, uint64_t *filesize)
static bool_t	decode_space_limit4 (XDR *xdr, uint64_t *filesize)
static bool_t	decode_open_write_delegation4 (XDR *xdr, open_delegation4 *delegation)
static bool_t	decode_open_res_ok (XDR *xdr, nfs41_op_open_res_ok *res)
static bool_t	decode_op_open (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_openattr (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_openattr (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_read (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_read_res_ok (XDR *xdr, nfs41_read_res_ok *res)
static bool_t	decode_op_read (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_readdir (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_readdir_entry (XDR *xdr, readdir_entry_iterator *it)
static bool_t	decode_readdir_list (XDR *xdr, nfs41_readdir_list *dirs)
static bool_t	decode_op_readdir (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_readlink (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_readlink (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_remove (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_remove (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_rename (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_rename (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_restorefh (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_restorefh (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_savefh (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_savefh (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_setattr (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_setattr (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_want_delegation (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_want_delegation (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_free_stateid (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_free_stateid (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_test_stateid (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_test_stateid (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_write (XDR *xdr, nfs_argop4 *argop)
static bool_t	xdr_write_verf (XDR *xdr, nfs41_write_verf *verf)
static bool_t	xdr_write_res_ok (XDR *xdr, nfs41_write_res_ok *res)
static bool_t	decode_op_write (XDR *xdr, nfs_resop4 *resop)
static bool_t	xdr_secinfo (XDR *xdr, nfs41_secinfo_info *secinfo)
static bool_t	encode_op_secinfo_noname (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_secinfo_noname (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_secinfo (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_secinfo (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_getdeviceinfo (XDR *xdr, nfs_argop4 *argop)
static bool_t	xdr_stripe_indices (XDR *xdr, pnfs_stripe_indices *indices)
static bool_t	xdr_pnfs_addr (XDR *xdr, netaddr4 *addr)
static bool_t	xdr_multi_addr (XDR *xdr, multi_addr4 *list)
static bool_t	xdr_data_server_list (XDR *xdr, pnfs_data_server_list *servers)
static bool_t	xdr_file_device (XDR *xdr, pnfs_file_device *device)
static bool_t	decode_getdeviceinfo_ok (XDR *xdr, pnfs_getdeviceinfo_res_ok *res_ok)
static bool_t	decode_op_getdeviceinfo (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_layoutcommit (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_layoutcommit (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_layoutget (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_file_layout_handles (XDR *xdr, pnfs_file_layout_handles *handles)
static bool_t	decode_file_layout (XDR *xdr, struct list_entry *list, pnfs_layout *base)
static bool_t	decode_layout (XDR *xdr, struct list_entry *list)
static bool_t	decode_layout_res_ok (XDR *xdr, pnfs_layoutget_res_ok *res)
static bool_t	decode_op_layoutget (XDR *xdr, nfs_resop4 *resop)
static bool_t	encode_op_layoutreturn (XDR *xdr, nfs_argop4 *argop)
static bool_t	decode_op_layoutreturn (XDR *xdr, nfs_resop4 *resop)
static const op_table_entry *	op_table_find (uint32_t op)
bool_t	nfs_encode_compound (XDR *xdr, caddr_t *pargs)
bool_t	nfs_decode_compound (XDR *xdr, caddr_t *pres)

Variables
static const op_table_entry	g_op_table []
static const uint32_t	g_op_table_size = ARRAYSIZE(g_op_table)

Typedef Documentation

nfs_op_decode_proc

typedef bool_t(* nfs_op_decode_proc) (XDR *, nfs_resop4 *)

Definition at line 3507 of file nfs41_xdr.c.

nfs_op_encode_proc

typedef bool_t(* nfs_op_encode_proc) (XDR *, nfs_argop4 *)

Definition at line 3506 of file nfs41_xdr.c.

op_table_entry

typedef struct __op_table_entry op_table_entry

readdir_entry_iterator

typedef struct __readdir_entry_iterator readdir_entry_iterator

Enumeration Type Documentation

limit_by4

enum limit_by4

Enumerator
NFS_LIMIT_SIZE
NFS_LIMIT_BLOCKS

Definition at line 2069 of file nfs41_xdr.c.

               {
    NFS_LIMIT_SIZE          = 1,
    NFS_LIMIT_BLOCKS        = 2
};

Function Documentation

decode_component()

static bool_t decode_component ( XDR *  xdr, nfs41_component *  component  )

static

Definition at line 186 of file nfs41_xdr.c.

{
    bool_t result;
    uint32_t len;
 
    result = xdr_bytes(xdr, (char **)&component->name, &len, NFS4_OPAQUE_LIMIT);
    component->len = (result == FALSE) ? 0 : (unsigned short)len;
    return result;
}

decode_file_attrs()

static bool_t decode_file_attrs ( XDR *  xdr, fattr4 *  attrs, nfs41_file_info *  info  )

static

Definition at line 1706 of file nfs41_xdr.c.

{
    if (attrs->attrmask.count >= 1) {
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_SUPPORTED_ATTRS) {
            if (!xdr_bitmap4(xdr, info->supported_attrs))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_TYPE) {
            if (!xdr_u_int32_t(xdr, &info->type))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_CHANGE) {
            if (!xdr_u_hyper(xdr, &info->change))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_SIZE) {
            if (!xdr_u_hyper(xdr, &info->size))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_LINK_SUPPORT) {
            if (!xdr_bool(xdr, &info->link_support))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_SYMLINK_SUPPORT) {
            if (!xdr_bool(xdr, &info->symlink_support))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_FSID) {
            if (!xdr_fsid(xdr, &info->fsid))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_LEASE_TIME) {
            if (!xdr_u_int32_t(xdr, &info->lease_time))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_RDATTR_ERROR) {
            if (!xdr_u_int32_t(xdr, &info->rdattr_error))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_ACL) {
            nfsacl41 *acl = info->acl;
            if (!xdr_array(xdr, (char**)&acl->aces, &acl->count,
                32, sizeof(nfsace4), (xdrproc_t)xdr_nfsace4))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_ACLSUPPORT) {
            if (!xdr_u_int32_t(xdr, &info->aclsupport))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_ARCHIVE) {
            if (!xdr_bool(xdr, &info->archive))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_CANSETTIME) {
            if (!xdr_bool(xdr, &info->cansettime))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_CASE_INSENSITIVE) {
            if (!xdr_bool(xdr, &info->case_insensitive))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_CASE_PRESERVING) {
            if (!xdr_bool(xdr, &info->case_preserving))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_FILEID) {
            if (!xdr_u_hyper(xdr, &info->fileid))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_FS_LOCATIONS) {
            if (!decode_fs_locations4(xdr, info->fs_locations))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_HIDDEN) {
            if (!xdr_bool(xdr, &info->hidden))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_MAXREAD) {
            if (!xdr_u_hyper(xdr, &info->maxread))
                return FALSE;
        }
        if (attrs->attrmask.arr[0] & FATTR4_WORD0_MAXWRITE) {
            if (!xdr_u_hyper(xdr, &info->maxwrite))
                return FALSE;
        }
    }
    if (attrs->attrmask.count >= 2) {
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_MODE) {
            if (!xdr_u_int32_t(xdr, &info->mode))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_NUMLINKS) {
            if (!xdr_u_int32_t(xdr, &info->numlinks))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_OWNER) {
            char *ptr = &info->owner[0];
            uint32_t owner_len;
            if (!xdr_bytes(xdr, &ptr, &owner_len, 
                            NFS4_OPAQUE_LIMIT))
                return FALSE;
            info->owner[owner_len] = '\0';
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_OWNER_GROUP) {
            char *ptr = &info->owner_group[0];
            uint32_t owner_group_len;
            if (!xdr_bytes(xdr, &ptr, &owner_group_len, 
                            NFS4_OPAQUE_LIMIT))
                return FALSE;
            info->owner_group[owner_group_len] = '\0';
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_SPACE_AVAIL) {
            if (!xdr_u_hyper(xdr, &info->space_avail))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_SPACE_FREE) {
            if (!xdr_u_hyper(xdr, &info->space_free))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_SPACE_TOTAL) {
            if (!xdr_u_hyper(xdr, &info->space_total))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_SYSTEM) {
            if (!xdr_bool(xdr, &info->system))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_ACCESS) {
            if (!xdr_nfstime4(xdr, &info->time_access))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_CREATE) {
            if (!xdr_nfstime4(xdr, &info->time_create))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_DELTA) {
            if (!xdr_nfstime4(xdr, info->time_delta))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_TIME_MODIFY) {
            if (!xdr_nfstime4(xdr, &info->time_modify))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_DACL) {
            if (!xdr_nfsdacl41(xdr, info->acl))
                return FALSE;
        }
        if (attrs->attrmask.arr[1] & FATTR4_WORD1_FS_LAYOUT_TYPE) {
            if (!xdr_layout_types(xdr, &info->fs_layout_types))
                return FALSE;
        }
    }
    if (attrs->attrmask.count >= 3) {
        if (attrs->attrmask.arr[2] & FATTR4_WORD2_MDSTHRESHOLD) {
            if (!xdr_mdsthreshold(xdr, &info->mdsthreshold))
                return FALSE;
        }
        if (attrs->attrmask.arr[2] & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
            if (!xdr_bitmap4(xdr, info->suppattr_exclcreat))
                return FALSE;
        }
    }
    return TRUE;
}

Referenced by decode_op_getattr(), and decode_readdir_entry().

decode_file_layout()

static bool_t decode_file_layout ( XDR *  xdr, struct list_entry *  list, pnfs_layout *  base  )

static

Definition at line 3322 of file nfs41_xdr.c.

{
    pnfs_file_layout *layout;
    u_int32_t len_ignored;
 
    if (!xdr_u_int32_t(xdr, &len_ignored))
        return FALSE;
 
    layout = calloc(1, sizeof(pnfs_file_layout));
    if (layout == NULL)
        return FALSE;
 
    layout->layout.offset = base->offset;
    layout->layout.length = base->length;
    layout->layout.iomode = base->iomode;
    layout->layout.type = base->type;
    list_init(&layout->layout.entry);
 
    if (!xdr_opaque(xdr, (char *)layout->deviceid, PNFS_DEVICEID_SIZE))
        goto out_error;
 
    if (!xdr_u_int32_t(xdr, &layout->util))
        goto out_error;
 
    if (!xdr_u_int32_t(xdr, &layout->first_index))
        goto out_error;
 
    if (!xdr_u_hyper(xdr, &layout->pattern_offset))
        goto out_error;
 
    if (!decode_file_layout_handles(xdr, &layout->filehandles))
        goto out_error;
 
    list_add_tail(list, &layout->layout.entry);
    return TRUE;
 
out_error:
    free(layout);
    return FALSE;
}

Referenced by decode_layout().

decode_file_layout_handles()

static bool_t decode_file_layout_handles ( XDR *  xdr, pnfs_file_layout_handles *  handles  )

static

Definition at line 3296 of file nfs41_xdr.c.

{
    uint32_t i, count;
 
    if (!xdr_u_int32_t(xdr, &count))
        return FALSE;
 
    if (count && count != handles->count) {
        nfs41_path_fh *tmp;
        tmp = realloc(handles->arr, count * sizeof(nfs41_path_fh));
        if (tmp == NULL)
            return FALSE;
        handles->arr = tmp;
        ZeroMemory(handles->arr, count * sizeof(nfs41_path_fh));
        handles->count = count;
    }
    
    for (i = 0; i < handles->count; i++) {
        if (!xdr_fh(xdr, &handles->arr[i].fh))
            return FALSE;
    }
    return TRUE;
}

Referenced by decode_file_layout().

decode_fs_location4()

static bool_t decode_fs_location4 ( XDR *  xdr, fs_location4 *  location  )

static

Definition at line 377 of file nfs41_xdr.c.

{
    fs_location_server *arr;
    char *address;
    u_int32_t i, count, len;
 
    /* decode the number of servers */
    if (!xdr_u_int32_t(xdr, &count))
        return FALSE;
 
    /* allocate the fs_location_server array */
    if (count == 0) {
        free(location->servers);
        arr = NULL;
    } else if (count != location->server_count) {
        arr = realloc(location->servers, count * sizeof(fs_location_server));
        if (arr == NULL)
            return FALSE;
        ZeroMemory(arr, count * sizeof(fs_location_server));
    } else {
        arr = location->servers;
    }
 
    location->servers = arr;
    location->server_count = count;
 
    for (i = 0; i < count; i++) {
        len = NFS41_HOSTNAME_LEN;
        address = arr[i].address;
        if (!xdr_bytes(xdr, &address, &len, NFS41_HOSTNAME_LEN)) {
            free(arr);
            return FALSE;
        }
        arr[i].address[len] = '\0';
    }
 
    return decode_pathname4(xdr, &location->path);
}

Referenced by decode_fs_locations4().

decode_fs_locations4()

static bool_t decode_fs_locations4 ( XDR *  xdr, fs_locations4 *  locations  )

static

Definition at line 419 of file nfs41_xdr.c.

{
    u_int32_t i, count;
    fs_location4 *arr;
 
    if (!decode_pathname4(xdr, &locations->path))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &count))
        return FALSE;
 
    /* allocate the fs_location array */
    if (count == 0) {
        free(locations->locations);
        arr = NULL;
    } else if (count != locations->location_count) {
        arr = realloc(locations->locations, count * sizeof(fs_location4));
        if (arr == NULL)
            return FALSE;
        ZeroMemory(arr, count * sizeof(fs_location4));
    } else {
        arr = locations->locations;
    }
 
    locations->locations = arr;
    locations->location_count = count;
 
    for (i = 0; i < count; i++) {
        if (!decode_fs_location4(xdr, &arr[i])) {
            free(arr);
            return FALSE;
        }
    }
    return TRUE;
}

Referenced by decode_file_attrs().

decode_getdeviceinfo_ok()

static bool_t decode_getdeviceinfo_ok ( XDR *  xdr, pnfs_getdeviceinfo_res_ok *  res_ok  )

static

Definition at line 3130 of file nfs41_xdr.c.

{
    u_int32_t len_ignored;
 
    if (!xdr_enum(xdr, (enum_t *)&res_ok->device->device.type))
        return FALSE;
 
    if (res_ok->device->device.type != PNFS_LAYOUTTYPE_FILE)
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &len_ignored))
        return FALSE;
 
    if (!xdr_file_device(xdr, res_ok->device))
        return FALSE;
 
    return xdr_bitmap4(xdr, &res_ok->notification);
}

Referenced by decode_op_getdeviceinfo().

decode_layout()

static bool_t decode_layout ( XDR *  xdr, struct list_entry *  list  )

static

Definition at line 3366 of file nfs41_xdr.c.

{
    pnfs_layout layout;
 
    if (!xdr_u_hyper(xdr, &layout.offset))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &layout.length))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&layout.iomode))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&layout.type))
        return FALSE;
 
    switch (layout.type) {
    case PNFS_LAYOUTTYPE_FILE:
        return decode_file_layout(xdr, list, &layout);
 
    default:
        eprintf("%s: received non-FILE layout type, %d\n",
            "decode_file_layout", layout.type);
    }
    return FALSE;
}

Referenced by decode_layout_res_ok().

decode_layout_res_ok()

static bool_t decode_layout_res_ok ( XDR *  xdr, pnfs_layoutget_res_ok *  res  )

static

Definition at line 3395 of file nfs41_xdr.c.

{
    uint32_t i;
 
    if (!xdr_bool(xdr, &res->return_on_close))
        return FALSE;
 
    if (!xdr_stateid4(xdr, &res->stateid))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->count))
        return FALSE;
 
    for (i = 0; i < res->count; i++)
        if (!decode_layout(xdr, &res->layouts))
            return FALSE;
    return TRUE;
}

Referenced by decode_op_layoutget().

decode_lock_res_denied()

static bool_t decode_lock_res_denied ( XDR *  xdr, lock_res_denied *  denied  )

static

Definition at line 1501 of file nfs41_xdr.c.

{
    if (!xdr_u_hyper(xdr, &denied->offset))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &denied->length))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &denied->locktype))
        return FALSE;
 
    return xdr_state_owner4(xdr, &denied->owner);
}

Referenced by decode_op_lock(), and decode_op_lockt().

decode_modified_limit4()

static bool_t decode_modified_limit4 ( XDR *  xdr, uint64_t *  filesize  )

static

Definition at line 2053 of file nfs41_xdr.c.

{
    uint32_t blocks, bytes_per_block;
 
    if (!xdr_u_int32_t(xdr, &blocks))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &bytes_per_block))
        return FALSE;
 
    *filesize = blocks * bytes_per_block;
    return TRUE;
}

Referenced by decode_space_limit4().

decode_op_access()

static bool_t decode_op_access ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1207 of file nfs41_xdr.c.

{
    nfs41_access_res *res = (nfs41_access_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_ACCESS))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
    {
        if (!xdr_u_int32_t(xdr, &res->supported))
            return FALSE;
 
        return xdr_u_int32_t(xdr, &res->access);
    }
    return TRUE;
}

decode_op_bind_conn_to_session()

static bool_t decode_op_bind_conn_to_session ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 897 of file nfs41_xdr.c.

{
    unsigned char sessionid_ignored[NFS4_SESSIONID_SIZE];
    nfs41_bind_conn_to_session_res *res =
        (nfs41_bind_conn_to_session_res*)resop->res;
    bool_t use_rdma_ignored;
 
    if (unexpected_op(resop->op, OP_BIND_CONN_TO_SESSION))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&res->status))
        return FALSE;
 
    if (res->status == NFS4_OK) {
        if (!xdr_opaque(xdr, (char *)&sessionid_ignored, NFS4_SESSIONID_SIZE))
            return FALSE;
 
        if (!xdr_enum(xdr, (enum_t *)&res->dir))
            return FALSE;
 
        return xdr_bool(xdr, &use_rdma_ignored);
    }
    return TRUE;
}

decode_op_close()

static bool_t decode_op_close ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1249 of file nfs41_xdr.c.

{
    stateid4 ignored;
    nfs41_op_close_res *res = (nfs41_op_close_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_CLOSE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_stateid4(xdr, &ignored);
 
    return TRUE;
}

decode_op_commit()

static bool_t decode_op_commit ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1287 of file nfs41_xdr.c.

{
    nfs41_commit_res *res = (nfs41_commit_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_COMMIT))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_opaque(xdr, (char *)res->verf->verf, NFS4_VERIFIER_SIZE);
 
    return TRUE;
}

decode_op_create()

static bool_t decode_op_create ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1384 of file nfs41_xdr.c.

{
    nfs41_create_res *res = (nfs41_create_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_CREATE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
    {
        if (!xdr_change_info4(xdr, &res->cinfo))
            return FALSE;
        return xdr_bitmap4(xdr, &res->attrset);
    }
    return TRUE;
}

decode_op_create_session()

static bool_t decode_op_create_session ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 837 of file nfs41_xdr.c.

{
    uint32_t opstatus;
    nfs41_create_session_res *res = (nfs41_create_session_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_CREATE_SESSION))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &opstatus))
        return FALSE;
 
    if (opstatus != NFS4_OK)
        return TRUE;
 
    if (!xdr_opaque(xdr, (char *)res->csr_sessionid, NFS4_SESSIONID_SIZE))
        return FALSE;
 
    /* sequenceid4 csr_sequence */
    if (!xdr_u_int32_t(xdr, &res->csr_sequence))
        return FALSE;
 
    /* uint32_t csr_flags */
    if (!xdr_u_int32_t(xdr, &res->csr_flags))
        return FALSE;
 
    /* channel_attrs4 csr_fore_chan_attrs */
    if (!xdr_channel_attrs4(xdr, res->csr_fore_chan_attrs))
        return FALSE;
 
    /* channel_attrs4 csr_back_chan_attrs */
    return xdr_channel_attrs4(xdr, res->csr_back_chan_attrs);
}

decode_op_delegpurge()

static bool_t decode_op_delegpurge ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1650 of file nfs41_xdr.c.

{
    nfs41_delegpurge_res *res = (nfs41_delegpurge_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_DELEGPURGE))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_delegreturn()

static bool_t decode_op_delegreturn ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1678 of file nfs41_xdr.c.

{
    nfs41_delegreturn_res *res = (nfs41_delegreturn_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_DELEGRETURN))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_destroy_clientid()

static bool_t decode_op_destroy_clientid ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 967 of file nfs41_xdr.c.

{
    nfs41_destroy_clientid_res *res = (nfs41_destroy_clientid_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_DESTROY_CLIENTID))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->dcr_status);
}

decode_op_destroy_session()

static bool_t decode_op_destroy_session ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 940 of file nfs41_xdr.c.

{
    nfs41_destroy_session_res *res = (nfs41_destroy_session_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_DESTROY_SESSION))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->dsr_status);
}

decode_op_exchange_id()

static bool_t decode_op_exchange_id ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 672 of file nfs41_xdr.c.

{
    nfs41_exchange_id_res *res = (nfs41_exchange_id_res*)resop->res;
    char *server_scope = (char *)res->server_scope;
 
    if (unexpected_op(resop->op, OP_EXCHANGE_ID))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status != NFS4_OK)
        return TRUE;
 
    if (!xdr_u_hyper(xdr, &res->clientid))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->sequenceid))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->flags))
        return FALSE;
 
    if (!xdr_state_protect4_r(xdr, &res->state_protect))
        return FALSE;
 
    if (!xdr_server_owner4(xdr, &res->server_owner))
        return FALSE;
 
    return xdr_bytes(xdr, &server_scope,
        &res->server_scope_len, NFS4_OPAQUE_LIMIT);
}

decode_op_free_stateid()

static bool_t decode_op_free_stateid ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2778 of file nfs41_xdr.c.

{
    nfs41_free_stateid_res *res = (nfs41_free_stateid_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_FREE_STATEID))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_getattr()

static bool_t decode_op_getattr ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1874 of file nfs41_xdr.c.

{
    nfs41_getattr_res *res = (nfs41_getattr_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_GETATTR))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
    {
        XDR attr_xdr;
 
        if (!xdr_fattr4(xdr, &res->obj_attributes))
            return FALSE;
        xdrmem_create(&attr_xdr, (char *)res->obj_attributes.attr_vals, res->obj_attributes.attr_vals_len, XDR_DECODE);
        return  decode_file_attrs(&attr_xdr, &res->obj_attributes, res->info);
    }
    return TRUE;
}

decode_op_getdeviceinfo()

static bool_t decode_op_getdeviceinfo ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 3151 of file nfs41_xdr.c.

{
    pnfs_getdeviceinfo_res *res = (pnfs_getdeviceinfo_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_GETDEVICEINFO))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, (uint32_t *)&res->status))
        return FALSE;
 
    switch (res->status) {
    case NFS4_OK:
        return decode_getdeviceinfo_ok(xdr, &res->u.res_ok);
        break;
    case NFS4ERR_TOOSMALL:
        {
            uint32_t ignored;
            return xdr_u_int32_t(xdr, &ignored);
        }
        break;
    }
    return TRUE;
}

decode_op_getfh()

static bool_t decode_op_getfh ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1145 of file nfs41_xdr.c.

{
    nfs41_getfh_res *res = (nfs41_getfh_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_GETFH))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_fh(xdr, res->fh);
 
    return TRUE;
}

decode_op_layoutcommit()

static bool_t decode_op_layoutcommit ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 3237 of file nfs41_xdr.c.

{
    pnfs_layoutcommit_res *res = (pnfs_layoutcommit_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LAYOUTCOMMIT))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK) {
        if (!xdr_bool(xdr, &res->has_new_size))
            return FALSE;
 
        if (res->has_new_size)
            if (!xdr_u_hyper(xdr, &res->new_size))
                return FALSE;
    }
    return TRUE;
}

decode_op_layoutget()

static bool_t decode_op_layoutget ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 3416 of file nfs41_xdr.c.

{
    pnfs_layoutget_res *res = (pnfs_layoutget_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LAYOUTGET))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, (uint32_t *)&res->status))
        return FALSE;
 
    switch (res->status) {
    case NFS4_OK:
        return decode_layout_res_ok(xdr, res->u.res_ok);
    case NFS4ERR_LAYOUTTRYLATER:
        return xdr_bool(xdr, &res->u.will_signal_layout_avail);
    }
    return TRUE;
}

decode_op_layoutreturn()

static bool_t decode_op_layoutreturn ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 3482 of file nfs41_xdr.c.

{
    pnfs_layoutreturn_res *res = (pnfs_layoutreturn_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LAYOUTRETURN))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, (uint32_t *)&res->status))
        return FALSE;
 
    if (res->status == NFS4_OK) {
        if (!xdr_bool(xdr, &res->stateid_present))
            return FALSE;
 
        if (res->stateid_present)
            return xdr_stateid4(xdr, &res->stateid);
    }
    return TRUE;
}

decode_op_link()

static bool_t decode_op_link ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1421 of file nfs41_xdr.c.

{
    nfs41_link_res *res = (nfs41_link_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LINK))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_change_info4(xdr, &res->cinfo);
 
    return TRUE;
}

decode_op_lock()

static bool_t decode_op_lock ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1517 of file nfs41_xdr.c.

{
    nfs41_lock_res *res = (nfs41_lock_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LOCK))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    switch (res->status) {
    case NFS4_OK:
        return xdr_stateid4(xdr, res->u.resok4.lock_stateid);
        break;
    case NFS4ERR_DENIED:
        return decode_lock_res_denied(xdr, &res->u.denied);
        break;
    default:
        break;
    }
 
    return TRUE;
}

decode_op_lockt()

static bool_t decode_op_lockt ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1568 of file nfs41_xdr.c.

{
    nfs41_lockt_res *res = (nfs41_lockt_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LOCKT))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4ERR_DENIED)
        return decode_lock_res_denied(xdr, &res->denied);
 
    return TRUE;
}

decode_op_locku()

static bool_t decode_op_locku ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1614 of file nfs41_xdr.c.

{
    nfs41_locku_res *res = (nfs41_locku_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LOCKU))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_stateid4(xdr, res->lock_stateid);
 
    return TRUE;
}

decode_op_lookup()

static bool_t decode_op_lookup ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1179 of file nfs41_xdr.c.

{
    nfs41_lookup_res *res = (nfs41_lookup_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_LOOKUP))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_open()

static bool_t decode_op_open ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2149 of file nfs41_xdr.c.

{
    nfs41_op_open_res *res = (nfs41_op_open_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_OPEN))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return decode_open_res_ok(xdr, &res->resok4);
 
    return TRUE;
}

decode_op_openattr()

static bool_t decode_op_openattr ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2183 of file nfs41_xdr.c.

{
    nfs41_openattr_res *res = (nfs41_openattr_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_OPENATTR))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_putfh()

static bool_t decode_op_putfh ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1092 of file nfs41_xdr.c.

{
    nfs41_putfh_res *res = (nfs41_putfh_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_PUTFH))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_putrootfh()

static bool_t decode_op_putrootfh ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1118 of file nfs41_xdr.c.

{
    nfs41_putrootfh_res *res = (nfs41_putrootfh_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_PUTROOTFH))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_read()

static bool_t decode_op_read ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2229 of file nfs41_xdr.c.

{
    nfs41_read_res *res = (nfs41_read_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_READ))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return decode_read_res_ok(xdr, &res->resok4);
 
    return TRUE;
}

decode_op_readdir()

static bool_t decode_op_readdir ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2379 of file nfs41_xdr.c.

{
    nfs41_readdir_res *res = (nfs41_readdir_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_READDIR))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK) {
        if (!xdr_opaque(xdr, (char *)res->cookieverf, NFS4_VERIFIER_SIZE))
            return FALSE;
        return decode_readdir_list(xdr, &res->reply);
    }
    return TRUE;
}

decode_op_readlink()

static bool_t decode_op_readlink ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2414 of file nfs41_xdr.c.

{
    nfs41_readlink_res *res = (nfs41_readlink_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_READLINK))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK) {
        char *link = res->link;
        return xdr_bytes(xdr, &link, &res->link_len, res->link_len);
    }
 
    return TRUE;
}

decode_op_reclaim_complete()

static bool_t decode_op_reclaim_complete ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1064 of file nfs41_xdr.c.

{
    nfs41_reclaim_complete_res *res = (nfs41_reclaim_complete_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_RECLAIM_COMPLETE))
        return FALSE;
 
    return xdr_enum(xdr, (enum_t *)&res->status);
}

decode_op_remove()

static bool_t decode_op_remove ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2450 of file nfs41_xdr.c.

{
    nfs41_remove_res *res = (nfs41_remove_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_REMOVE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_change_info4(xdr, &res->cinfo);
 
    return TRUE;
}

decode_op_rename()

static bool_t decode_op_rename ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2487 of file nfs41_xdr.c.

{
    nfs41_rename_res *res = (nfs41_rename_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_RENAME))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
    {
        if (!xdr_change_info4(xdr, &res->source_cinfo))
            return FALSE;
        return xdr_change_info4(xdr, &res->target_cinfo);
    }
    return TRUE;
}

decode_op_restorefh()

static bool_t decode_op_restorefh ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2523 of file nfs41_xdr.c.

{
    nfs41_restorefh_res *res = (nfs41_restorefh_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_RESTOREFH))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_savefh()

static bool_t decode_op_savefh ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2550 of file nfs41_xdr.c.

{
    nfs41_savefh_res *res = (nfs41_savefh_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_SAVEFH))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &res->status);
}

decode_op_secinfo()

static bool_t decode_op_secinfo ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2963 of file nfs41_xdr.c.

{
    nfs41_secinfo_noname_res *res = (nfs41_secinfo_noname_res *)resop->res;
    nfs41_secinfo_info *secinfo = res->secinfo;
 
    if (unexpected_op(resop->op, OP_SECINFO))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_array(xdr, (char**)&secinfo, &res->count,
            MAX_SECINFOS, sizeof(nfs41_secinfo_info), (xdrproc_t)xdr_secinfo);
 
    return TRUE;
}

decode_op_secinfo_noname()

static bool_t decode_op_secinfo_noname ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2926 of file nfs41_xdr.c.

{
    nfs41_secinfo_noname_res *res = (nfs41_secinfo_noname_res *)resop->res;
    nfs41_secinfo_info *secinfo = res->secinfo;
    if (unexpected_op(resop->op, OP_SECINFO_NO_NAME))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_array(xdr, (char**)&secinfo, &res->count,
            MAX_SECINFOS, sizeof(nfs41_secinfo_info), (xdrproc_t)xdr_secinfo);
 
    return TRUE;
}

decode_op_sequence()

static bool_t decode_op_sequence ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 1029 of file nfs41_xdr.c.

{
    nfs41_sequence_res *res = (nfs41_sequence_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_SEQUENCE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->sr_status))
        return FALSE;
 
    if (res->sr_status == NFS4_OK)
        return xdr_sequence_res_ok(xdr, &res->sr_resok4);
 
    return TRUE;
}

decode_op_setattr()

static bool_t decode_op_setattr ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2686 of file nfs41_xdr.c.

{
    nfs41_setattr_res *res = (nfs41_setattr_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_SETATTR))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_bitmap4(xdr, &res->attrsset);
 
    return TRUE;
}

decode_op_test_stateid()

static bool_t decode_op_test_stateid ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2807 of file nfs41_xdr.c.

{
    nfs41_test_stateid_res *res = (nfs41_test_stateid_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_TEST_STATEID))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK) {
        return xdr_array(xdr, (char**)&res->resok.status, &res->resok.count,
            res->resok.count, sizeof(uint32_t), (xdrproc_t)xdr_u_int32_t);
    }
    return TRUE;
}

decode_op_want_delegation()

static bool_t decode_op_want_delegation ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2727 of file nfs41_xdr.c.

{
    nfs41_want_delegation_res *res = (nfs41_want_delegation_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_WANT_DELEGATION))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status)
        return TRUE;
 
    if (!xdr_enum(xdr, (enum_t*)&res->delegation->type))
        return FALSE;
 
    switch (res->delegation->type)
    {
    case OPEN_DELEGATE_NONE:
        return TRUE;
    case OPEN_DELEGATE_NONE_EXT:
        return decode_open_none_delegation4(xdr, res->delegation);
    case OPEN_DELEGATE_READ:
        return decode_open_read_delegation4(xdr, res->delegation);
    case OPEN_DELEGATE_WRITE:
        return decode_open_write_delegation4(xdr, res->delegation);
    default:
        eprintf("decode_open_res_ok: delegation type %d not "
            "supported.\n", res->delegation->type);
        return FALSE;
    }
}

decode_op_write()

static bool_t decode_op_write ( XDR *  xdr, nfs_resop4 *  resop  )

static

Definition at line 2872 of file nfs41_xdr.c.

{
    nfs41_write_res *res = (nfs41_write_res*)resop->res;
 
    if (unexpected_op(resop->op, OP_WRITE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (res->status == NFS4_OK)
        return xdr_write_res_ok(xdr, &res->resok4);
 
    return TRUE;
}

decode_open_none_delegation4()

static bool_t decode_open_none_delegation4 ( XDR *  xdr, open_delegation4 *  delegation  )

static

Definition at line 2020 of file nfs41_xdr.c.

{
    enum_t why_no_deleg;
    bool_t will_signal;
 
    if (!xdr_enum(xdr, (enum_t*)&why_no_deleg))
        return FALSE;
 
    switch (why_no_deleg)
    {
    case WND4_CONTENTION:
    case WND4_RESOURCE:
        return xdr_bool(xdr, &will_signal);
    default:
        return TRUE;
    }
}

Referenced by decode_op_want_delegation(), and decode_open_res_ok().

decode_open_read_delegation4()

static bool_t decode_open_read_delegation4 ( XDR *  xdr, open_delegation4 *  delegation  )

static

Definition at line 2040 of file nfs41_xdr.c.

{
    if (!xdr_stateid4(xdr, &delegation->stateid))
        return FALSE;
 
    if (!xdr_bool(xdr, &delegation->recalled))
        return FALSE;
 
    return xdr_nfsace4(xdr, &delegation->permissions);
}

Referenced by decode_op_want_delegation(), and decode_open_res_ok().

decode_open_res_ok()

static bool_t decode_open_res_ok ( XDR *  xdr, nfs41_op_open_res_ok *  res  )

static

Definition at line 2113 of file nfs41_xdr.c.

{
    if (!xdr_stateid4(xdr, res->stateid))
        return FALSE;
 
    if (!xdr_change_info4(xdr, &res->cinfo))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &res->rflags))
        return FALSE;
 
    if (!xdr_bitmap4(xdr, &res->attrset))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t*)&res->delegation->type))
        return FALSE;
 
    switch (res->delegation->type)
    {
    case OPEN_DELEGATE_NONE:
        return TRUE;
    case OPEN_DELEGATE_NONE_EXT:
        return decode_open_none_delegation4(xdr, res->delegation);
    case OPEN_DELEGATE_READ:
        return decode_open_read_delegation4(xdr, res->delegation);
    case OPEN_DELEGATE_WRITE:
        return decode_open_write_delegation4(xdr, res->delegation);
    default:
        eprintf("decode_open_res_ok: delegation type %d not "
            "supported.\n", res->delegation->type);
        return FALSE;
    }
}

Referenced by decode_op_open().

decode_open_write_delegation4()

static bool_t decode_open_write_delegation4 ( XDR *  xdr, open_delegation4 *  delegation  )

static

Definition at line 2095 of file nfs41_xdr.c.

{
    uint64_t size_limit;
 
    if (!xdr_stateid4(xdr, &delegation->stateid))
        return FALSE;
 
    if (!xdr_bool(xdr, &delegation->recalled))
        return FALSE;
 
    if (!decode_space_limit4(xdr, &size_limit))
        return FALSE;
 
    return xdr_nfsace4(xdr, &delegation->permissions);
}

Referenced by decode_op_want_delegation(), and decode_open_res_ok().

decode_pathname4()

static bool_t decode_pathname4 ( XDR *  xdr, nfs41_abs_path *  path  )

static

Definition at line 343 of file nfs41_xdr.c.

{
    char *pos;
    u_int32_t i, count, len, remaining;
 
    /* decode the number of components */
    if (!xdr_u_int32_t(xdr, &count))
        return FALSE;
 
    pos = (char *)path->path;
    remaining = NFS41_MAX_PATH_LEN;
 
    /* decode each component */
    for (i = 0; i < count; i++) {
        len = remaining;
        if (!xdr_bytes(xdr, (char **)&pos, &len, NFS41_MAX_PATH_LEN))
            return FALSE;
        remaining -= len;
        pos += len;
 
        if (i < count-1) { /* add a \ between components */
            if (remaining < 1)
                return FALSE;
            *pos++ = '\\';
            remaining--;
        }
    }
    path->len = (unsigned short)(NFS41_MAX_PATH_LEN - remaining);
    return TRUE;
}

Referenced by decode_fs_location4(), and decode_fs_locations4().

decode_read_res_ok()

static bool_t decode_read_res_ok ( XDR *  xdr, nfs41_read_res_ok *  res  )

static

Definition at line 2217 of file nfs41_xdr.c.

{
    unsigned char *data = res->data;
 
    if (!xdr_bool(xdr, &res->eof))
        return FALSE;
 
    return xdr_bytes(xdr, (char **)&data, &res->data_len, NFS41_MAX_FILEIO_SIZE);
}

Referenced by decode_op_read().

decode_readdir_entry()

static bool_t decode_readdir_entry ( XDR *  xdr, readdir_entry_iterator *  it  )

static

Definition at line 2283 of file nfs41_xdr.c.

{
    uint64_t cookie;
    unsigned char name[NFS4_OPAQUE_LIMIT];
    unsigned char *nameptr = &name[0];
    uint32_t name_len, entry_len;
    fattr4 attrs;
 
    /* decode into temporaries so we can determine if there's enough
     * room in the buffer for this entry */
    ZeroMemory(name, NFS4_OPAQUE_LIMIT);
    name_len = NFS4_OPAQUE_LIMIT;
    entry_len = (uint32_t)FIELD_OFFSET(nfs41_readdir_entry, name);
    attrs.attr_vals_len = NFS4_OPAQUE_LIMIT;
 
    if (!xdr_u_hyper(xdr, &cookie))
        return FALSE;
 
    if (!xdr_bytes(xdr, (char **)&nameptr, &name_len, NFS4_OPAQUE_LIMIT))
        return FALSE;
 
    if (!xdr_fattr4(xdr, &attrs))
        return FALSE;
 
    if (!xdr_bool(xdr, &it->has_next_entry))
        return FALSE;
 
    if (it->ignore_the_rest)
        return TRUE;
 
    name_len += 1; /* account for null terminator */
    if (entry_len + name_len <= it->remaining_len)
    {
        XDR fattr_xdr;
        nfs41_readdir_entry *entry = (nfs41_readdir_entry*)it->buf_pos;
        entry->cookie = cookie;
        entry->name_len = name_len;
 
        if (it->has_next_entry)
            entry->next_entry_offset = entry_len + name_len;
        else
            entry->next_entry_offset = 0;
 
        xdrmem_create(&fattr_xdr, (char *)attrs.attr_vals, attrs.attr_vals_len, XDR_DECODE);
        if (!(decode_file_attrs(&fattr_xdr, &attrs, &entry->attr_info)))
            entry->attr_info.rdattr_error = NFS4ERR_BADXDR;
        StringCchCopyA(entry->name, name_len, (STRSAFE_LPCSTR)name);
 
        it->buf_pos += entry_len + name_len;
        it->remaining_len -= entry_len + name_len;
        it->last_entry_offset = &entry->next_entry_offset;
    }
    else if (it->last_entry_offset)
    {
        *(it->last_entry_offset) = 0;
        it->ignore_the_rest = 1;
    }
 
    return TRUE;
}

Referenced by decode_readdir_list().

decode_readdir_list()

static bool_t decode_readdir_list ( XDR *  xdr, nfs41_readdir_list *  dirs  )

static

Definition at line 2346 of file nfs41_xdr.c.

{
    readdir_entry_iterator iter;
    iter.buf_pos = dirs->entries;
    iter.remaining_len = dirs->entries_len;
    iter.last_entry_offset = NULL;
    iter.ignore_the_rest = 0;
    iter.has_next_entry = 0;
 
    if (!xdr_bool(xdr, &dirs->has_entries))
        return FALSE;
 
    if (dirs->has_entries)
    {
        do {
            if (!decode_readdir_entry(xdr, &iter))
                return FALSE;
 
        } while (iter.has_next_entry);
    }
    dirs->entries_len -= iter.remaining_len;
 
    if (!xdr_bool(xdr, &dirs->eof))
        return FALSE;
 
    /* reset eof if we couldn't fit everything in the buffer */
    if (iter.ignore_the_rest)
        dirs->eof = 0;
    return TRUE;
}

Referenced by decode_op_readdir().

decode_space_limit4()

static bool_t decode_space_limit4 ( XDR *  xdr, uint64_t *  filesize  )

static

Definition at line 2074 of file nfs41_xdr.c.

{
    uint32_t limitby;
 
    if (!xdr_u_int32_t(xdr, &limitby))
        return FALSE;
 
    switch (limitby)
    {
    case NFS_LIMIT_SIZE:
        return xdr_u_hyper(xdr, filesize);
    case NFS_LIMIT_BLOCKS:
        return decode_modified_limit4(xdr, filesize);
    default:
        eprintf("decode_space_limit4: limitby %d invalid\n", limitby);
        return FALSE;
    }
}

Referenced by decode_open_write_delegation4().

encode_backchannel_sec_parms()

static bool_t encode_backchannel_sec_parms ( XDR *  xdr, nfs41_callback_secparms *  args  )

static

Definition at line 774 of file nfs41_xdr.c.

{
    uint32_t zero = 0;
 
    if (!xdr_u_int32_t(xdr, &args->type))
        return FALSE;
 
    switch (args->type)  {
    case AUTH_NONE: return TRUE;
    case AUTH_SYS:
        if (!xdr_u_int32_t(xdr, &args->u.auth_sys.stamp))
            return FALSE;
        if (!xdr_string(xdr, &args->u.auth_sys.machinename, NI_MAXHOST))
            return FALSE;
        return xdr_u_int32_t(xdr, &zero) && xdr_u_int32_t(xdr, &zero) && 
                xdr_u_int32_t(xdr, &zero);
    case RPCSEC_GSS:
    default:
        return FALSE;
    }
}

Referenced by encode_op_create_session().

encode_claim_deleg_cur()

static bool_t encode_claim_deleg_cur ( XDR *  xdr, stateid4 *  stateid, nfs41_component *  name  )

static

Definition at line 1950 of file nfs41_xdr.c.

{
    if (!xdr_stateid4(xdr, stateid))
        return FALSE;
    return encode_component(xdr, name);
}

Referenced by encode_open_claim4().

encode_component()

static bool_t encode_component ( XDR *  xdr, const nfs41_component *  component  )

static

Definition at line 178 of file nfs41_xdr.c.

{
    uint32_t len = component->len;
    return xdr_bytes(xdr, (char **)&component->name, &len, NFS4_OPAQUE_LIMIT);
}

Referenced by encode_claim_deleg_cur(), encode_op_create(), encode_op_link(), encode_op_lookup(), encode_op_remove(), encode_op_rename(), encode_op_secinfo(), and encode_open_claim4().

encode_createattrs4()

static bool_t encode_createattrs4 ( XDR *  xdr, nfs41_file_info *  createattrs  )

static

Definition at line 1339 of file nfs41_xdr.c.

{
    fattr4 attrs;
 
    /* encode attribute values from createattrs->info into attrs.attr_vals */
    attrs.attr_vals_len = NFS4_OPAQUE_LIMIT;
    if (!encode_file_attrs(&attrs, createattrs))
        return FALSE;
 
    return xdr_fattr4(xdr, &attrs);
}

Referenced by encode_createhow4(), and encode_op_create().

encode_createhow4()

static bool_t encode_createhow4 ( XDR *  xdr, createhow4 *  ch  )

static

Definition at line 1902 of file nfs41_xdr.c.

{
    bool_t result = TRUE;
 
    if (!xdr_u_int32_t(xdr, &ch->mode))
        return FALSE;
 
    switch (ch->mode)
    {
    case UNCHECKED4:
    case GUARDED4:
        result = encode_createattrs4(xdr, ch->createattrs);
        break;
    case EXCLUSIVE4:
        result = xdr_opaque(xdr, (char *)ch->createverf, NFS4_VERIFIER_SIZE);
        break;
    case EXCLUSIVE4_1:
        if (!xdr_opaque(xdr, (char *)ch->createverf, NFS4_VERIFIER_SIZE))
            return FALSE;
        if (!encode_createattrs4(xdr, ch->createattrs))
            return FALSE;
        break;
    }
    return result;
}

Referenced by encode_openflag4().

encode_createtype4()

static bool_t encode_createtype4 ( XDR *  xdr, createtype4 *  ct  )

static

Definition at line 1309 of file nfs41_xdr.c.

{
    bool_t result = TRUE;
    const char *linkdata;
 
    if (!xdr_u_int32_t(xdr, &ct->type))
        return FALSE;
 
    switch (ct->type)
    {
    case NF4LNK:
        linkdata = ct->u.lnk.linkdata;
        result = xdr_bytes(xdr, (char**)&linkdata, &ct->u.lnk.linkdata_len,
            NFS4_OPAQUE_LIMIT);
        break;
    case NF4BLK:
    case NF4CHR:
        result = xdr_u_int32_t(xdr, &ct->u.devdata.specdata1);
        if (result == TRUE)
            result = xdr_u_int32_t(xdr, &ct->u.devdata.specdata2);
        break;
    default:
        // Some types need no further action
        break;
    }
    return result;
}

Referenced by encode_op_create().

encode_file_attrs()

static bool_t encode_file_attrs ( fattr4 *  attrs, nfs41_file_info *  info  )

static

Definition at line 2566 of file nfs41_xdr.c.

{
    uint32_t i;
    XDR localxdr;
 
    xdrmem_create(&localxdr, (char *)attrs->attr_vals, NFS4_OPAQUE_LIMIT, XDR_ENCODE);
 
    attrs->attr_vals_len = 0;
    ZeroMemory(&attrs->attrmask, sizeof(bitmap4));
    attrs->attrmask.count = info->attrmask.count;
 
    if (info->attrmask.count > 0) {
        if (info->attrmask.arr[0] & FATTR4_WORD0_SIZE) {
            if (!xdr_u_hyper(&localxdr, &info->size))
                return FALSE;
            attrs->attrmask.arr[0] |= FATTR4_WORD0_SIZE;
        }
        if (info->attrmask.arr[0] & FATTR4_WORD0_ACL) {
            if (!xdr_nfsacl41(&localxdr, info->acl))
                return FALSE;
            attrs->attrmask.arr[0] |= FATTR4_WORD0_ACL;
        }
        if (info->attrmask.arr[0] & FATTR4_WORD0_ARCHIVE) {
            if (!xdr_bool(&localxdr, &info->archive))
                return FALSE;
            attrs->attrmask.arr[0] |= FATTR4_WORD0_ARCHIVE;
        }
        if (info->attrmask.arr[0] & FATTR4_WORD0_HIDDEN) {
            if (!xdr_bool(&localxdr, &info->hidden))
                return FALSE;
            attrs->attrmask.arr[0] |= FATTR4_WORD0_HIDDEN;
        }
    }
    if (info->attrmask.count > 1) {
        if (info->attrmask.arr[1] & FATTR4_WORD1_MODE) {
            if (!xdr_u_int32_t(&localxdr, &info->mode))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_MODE;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_SYSTEM) {
            if (!xdr_bool(&localxdr, &info->system))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_SYSTEM;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
            if (!xdr_settime4(&localxdr, &info->time_access, info->time_delta))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_TIME_ACCESS_SET;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_CREATE) {
            if (!xdr_nfstime4(&localxdr, &info->time_create))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_TIME_CREATE;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
            if (!xdr_settime4(&localxdr, &info->time_modify, info->time_delta))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_OWNER) {
            char *ptr = &info->owner[0];
            uint32_t owner_len = (uint32_t)strlen(info->owner);
            if (!xdr_bytes(&localxdr, &ptr, &owner_len, 
                            NFS4_OPAQUE_LIMIT))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_OWNER;
        }
        if (info->attrmask.arr[1] & FATTR4_WORD1_OWNER_GROUP) {
            char *ptr = &info->owner_group[0];
            uint32_t owner_group_len = (uint32_t)strlen(info->owner_group);
            if (!xdr_bytes(&localxdr, &ptr, &owner_group_len, 
                            NFS4_OPAQUE_LIMIT))
                return FALSE;
            attrs->attrmask.arr[1] |= FATTR4_WORD1_OWNER_GROUP;
        }
    }
    if (info->attrmask.count > 2) {
        if (info->attrmask.arr[2] & FATTR4_WORD2_MODE_SET_MASKED) {
            if (!xdr_u_int32_t(&localxdr, &info->mode))
                return FALSE;
            if (!xdr_u_int32_t(&localxdr, &info->mode_mask))
                return FALSE;
            attrs->attrmask.arr[2] |= FATTR4_WORD2_MODE_SET_MASKED;
        }
    }
 
    /* warn if we try to set attributes that aren't handled */
    for (i = 0; i < info->attrmask.count; i++)
        if (attrs->attrmask.arr[i] != info->attrmask.arr[i])
            eprintf("encode_file_attrs() attempted to encode extra "
                "attributes in arr[%d]: encoded %d, but wanted %d.\n",
                i, attrs->attrmask.arr[i], info->attrmask.arr[i]);
 
    attrs->attr_vals_len = xdr_getpos(&localxdr);
    return TRUE;
}

Referenced by encode_createattrs4(), and encode_op_setattr().

encode_op_access()

static bool_t encode_op_access ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1195 of file nfs41_xdr.c.

{
    nfs41_access_args *args = (nfs41_access_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_ACCESS))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &args->access);
}

encode_op_bind_conn_to_session()

static bool_t encode_op_bind_conn_to_session ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 876 of file nfs41_xdr.c.

{
    uint32_t zero = 0;
 
    nfs41_bind_conn_to_session_args *args =
        (nfs41_bind_conn_to_session_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_BIND_CONN_TO_SESSION))
        return FALSE;
 
    if (!xdr_opaque(xdr, (char *)args->sessionid, NFS4_SESSIONID_SIZE))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&args->dir))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &zero); /* bctsa_use_conn_in_rdma_mode = false */
}

encode_op_close()

static bool_t encode_op_close ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1233 of file nfs41_xdr.c.

{
    nfs41_op_close_args *args = (nfs41_op_close_args*)argop->arg;
    uint32_t zero = 0;
 
    if (unexpected_op(argop->op, OP_CLOSE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &zero)) // This should be ignored by server
        return FALSE;
 
    return xdr_stateid4(xdr, &args->stateid->stateid);
}

encode_op_commit()

static bool_t encode_op_commit ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1272 of file nfs41_xdr.c.

{
    nfs41_commit_args *args = (nfs41_commit_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_COMMIT))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &args->count);
}

encode_op_create()

static bool_t encode_op_create ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1353 of file nfs41_xdr.c.

{
    nfs41_create_args *args = (nfs41_create_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_CREATE))
        return FALSE;
 
    if (!encode_createtype4(xdr, &args->objtype))
        return FALSE;
 
    if (!encode_component(xdr, args->name))
        return FALSE;
 
    return encode_createattrs4(xdr, args->createattrs);
}

encode_op_create_session()

static bool_t encode_op_create_session ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 798 of file nfs41_xdr.c.

{
    nfs41_create_session_args *args = (nfs41_create_session_args*)argop->arg;
    nfs41_callback_secparms *cb_secparams = args->csa_cb_secparams;
    uint32_t cb_count = 2;
 
    if (unexpected_op(argop->op, OP_CREATE_SESSION))
        return FALSE;
 
    /* clientid4 csa_clientid */
    if (!xdr_u_hyper(xdr, &args->csa_clientid))
        return FALSE;
 
    /* sequenceid4 csa_sequence */
    if (!xdr_u_int32_t(xdr, &args->csa_sequence))
        return FALSE;
 
    /* TODO: uint32_t csa_flags = 0 */
    if (!xdr_u_int32_t(xdr, &args->csa_flags))
        return FALSE;
 
    /* channel_attrs4 csa_fore_chan_attrs */
    if (!xdr_channel_attrs4(xdr, &args->csa_fore_chan_attrs))
        return FALSE;
 
    /* channel_attrs4 csa_back_chan_attrs */
    if (!xdr_channel_attrs4(xdr, &args->csa_back_chan_attrs))
        return FALSE;
 
    /* TODO: uint32_t csa_cb_program = 1234 */
    if (!xdr_u_int32_t(xdr, &args->csa_cb_program))
        return FALSE;
 
    return xdr_array(xdr, (char **)&cb_secparams, &cb_count,
        3, sizeof(nfs41_callback_secparms), (xdrproc_t) encode_backchannel_sec_parms);
}

encode_op_delegpurge()

static bool_t encode_op_delegpurge ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1636 of file nfs41_xdr.c.

{
    uint64_t zero = 0;
 
    if (unexpected_op(argop->op, OP_DELEGPURGE))
        return FALSE;
 
    /* The client SHOULD set the client field to zero,
     * and the server MUST ignore the clientid field. */
    return xdr_u_int64_t(xdr, &zero);
}

encode_op_delegreturn()

static bool_t encode_op_delegreturn ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1666 of file nfs41_xdr.c.

{
    nfs41_delegreturn_args *args = (nfs41_delegreturn_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_DELEGRETURN))
        return FALSE;
 
    return xdr_stateid4(xdr, &args->stateid->stateid);
}

encode_op_destroy_clientid()

static bool_t encode_op_destroy_clientid ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 955 of file nfs41_xdr.c.

{
    nfs41_destroy_clientid_args *args = (nfs41_destroy_clientid_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_DESTROY_CLIENTID))
        return FALSE;
 
    return xdr_u_hyper(xdr, &args->dca_clientid);
}

encode_op_destroy_session()

static bool_t encode_op_destroy_session ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 928 of file nfs41_xdr.c.

{
    nfs41_destroy_session_args *args = (nfs41_destroy_session_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_DESTROY_SESSION))
        return FALSE;
 
    return xdr_opaque(xdr, (char *)args->dsa_sessionid, NFS4_SESSIONID_SIZE);
}

encode_op_exchange_id()

static bool_t encode_op_exchange_id ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 551 of file nfs41_xdr.c.

{
    uint32_t zero = 0;
    uint32_t one = 1;
 
    nfs41_exchange_id_args *args = (nfs41_exchange_id_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_EXCHANGE_ID))
        return FALSE;
 
    if (!xdr_client_owner4(xdr, args->eia_clientowner))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->eia_flags))
        return FALSE;
 
    if (!xdr_state_protect4_a(xdr, &args->eia_state_protect))
        return FALSE;
 
    if (args->eia_client_impl_id)
    {
        if (!xdr_u_int32_t(xdr, &one))
            return FALSE;
        return xdr_nfs_impl_id4(xdr, args->eia_client_impl_id);
    }
    else
        return xdr_u_int32_t(xdr, &zero);
}

encode_op_free_stateid()

static bool_t encode_op_free_stateid ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2766 of file nfs41_xdr.c.

{
    nfs41_free_stateid_args *args = (nfs41_free_stateid_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_FREE_STATEID))
        return FALSE;
 
    return xdr_stateid4(xdr, args->stateid);
}

encode_op_getattr()

static bool_t encode_op_getattr ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1694 of file nfs41_xdr.c.

{
    nfs41_getattr_args *args = (nfs41_getattr_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_GETATTR))
        return FALSE;
 
    return xdr_bitmap4(xdr, args->attr_request);
}

encode_op_getdeviceinfo()

static bool_t encode_op_getdeviceinfo ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2985 of file nfs41_xdr.c.

{
    pnfs_getdeviceinfo_args *args = (pnfs_getdeviceinfo_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_GETDEVICEINFO))
        return FALSE;
 
    if (!xdr_opaque(xdr, (char *)args->deviceid, PNFS_DEVICEID_SIZE))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&args->layout_type))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->maxcount))
        return FALSE;
 
    return xdr_bitmap4(xdr, &args->notify_types);
}

encode_op_getfh()

static bool_t encode_op_getfh ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1134 of file nfs41_xdr.c.

{
    if (unexpected_op(argop->op, OP_GETFH))
        return FALSE;
 
    /* void */
    return TRUE;
}

encode_op_layoutcommit()

static bool_t encode_op_layoutcommit ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 3181 of file nfs41_xdr.c.

{
    pnfs_layoutcommit_args *args = (pnfs_layoutcommit_args*)argop->arg;
    bool_t false_bool = FALSE;
    bool_t true_bool = TRUE;
    enum_t pnfs_layout = PNFS_LAYOUTTYPE_FILE;
    uint32_t zero = 0;
 
    if (unexpected_op(argop->op, OP_LAYOUTCOMMIT))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->length))
        return FALSE;
 
    if (!xdr_bool(xdr, &false_bool)) /* loca_reclaim = 0 */
        return FALSE;
 
    if (!xdr_stateid4(xdr, args->stateid))
        return FALSE;
 
    /* loca_last_write_offset */
    if (args->new_offset) {
        if (!xdr_bool(xdr, &true_bool))
            return FALSE;
 
        if (!xdr_u_hyper(xdr, args->new_offset))
            return FALSE;
    } else {
        if (!xdr_bool(xdr, &false_bool))
            return FALSE;
    }
 
    /* loca_time_modify */
    if (args->new_time) {
        if (!xdr_bool(xdr, &true_bool))
            return FALSE;
 
        if (!xdr_nfstime4(xdr, args->new_time))
            return FALSE;
    } else {
        if (!xdr_bool(xdr, &false_bool))
            return FALSE;
    }
 
    /* loca_layoutupdate */
    if (!xdr_enum(xdr, &pnfs_layout))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &zero);
}

encode_op_layoutget()

static bool_t encode_op_layoutget ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 3263 of file nfs41_xdr.c.

{
    pnfs_layoutget_args *args = (pnfs_layoutget_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LAYOUTGET))
        return FALSE;
 
    if (!xdr_bool(xdr, &args->signal_layout_avail))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, (u_int32_t *)&args->layout_type))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, (u_int32_t *)&args->iomode))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->length))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->minlength))
        return FALSE;
 
    if (!xdr_stateid4(xdr, &args->stateid->stateid))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &args->maxcount);
}

encode_op_layoutreturn()

static bool_t encode_op_layoutreturn ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 3441 of file nfs41_xdr.c.

{
    pnfs_layoutreturn_args *args = (pnfs_layoutreturn_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LAYOUTRETURN))
        return FALSE;
 
    if (!xdr_bool(xdr, &args->reclaim))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&args->type))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&args->iomode))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&args->return_type))
        return FALSE;
 
    if (args->return_type == PNFS_RETURN_FILE) {
        u_int32_t zero = 0;
 
        if (!xdr_u_hyper(xdr, &args->offset))
            return FALSE;
 
        if (!xdr_u_hyper(xdr, &args->length))
            return FALSE;
 
        if (!xdr_stateid4(xdr, args->stateid))
            return FALSE;
 
        return xdr_u_int32_t(xdr, &zero); /* size of lrf_body is 0 */
    } else {
        eprintf("%s: layout type (%d) is not PNFS_RETURN_FILE!\n",
            "encode_op_layoutreturn", args->return_type);
        return FALSE;
    }
}

encode_op_link()

static bool_t encode_op_link ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1409 of file nfs41_xdr.c.

{
    nfs41_link_args *args = (nfs41_link_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LINK))
        return FALSE;
 
    return encode_component(xdr, args->newname);
}

encode_op_lock()

static bool_t encode_op_lock ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1477 of file nfs41_xdr.c.

{
    nfs41_lock_args *args = (nfs41_lock_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LOCK))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->locktype))
        return FALSE;
 
    if (!xdr_bool(xdr, &args->reclaim))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->length))
        return FALSE;
 
    return xdr_locker4(xdr, &args->locker);
}

encode_op_lockt()

static bool_t encode_op_lockt ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1547 of file nfs41_xdr.c.

{
    nfs41_lockt_args *args = (nfs41_lockt_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LOCKT))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->locktype))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->length))
        return FALSE;
 
    return xdr_state_owner4(xdr, args->owner);
}

encode_op_locku()

static bool_t encode_op_locku ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1590 of file nfs41_xdr.c.

{
    nfs41_locku_args *args = (nfs41_locku_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LOCKU))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->locktype))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->seqid))
        return FALSE;
 
    if (!xdr_stateid4(xdr, &args->lock_stateid->stateid))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    return xdr_u_hyper(xdr, &args->length);
}

encode_op_lookup()

static bool_t encode_op_lookup ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1167 of file nfs41_xdr.c.

{
    nfs41_lookup_args *args = (nfs41_lookup_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_LOOKUP))
        return FALSE;
 
    return encode_component(xdr, args->name);
}

encode_op_open()

static bool_t encode_op_open ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1993 of file nfs41_xdr.c.

{
    nfs41_op_open_args *args = (nfs41_op_open_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_OPEN))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->seqid))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->share_access))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->share_deny))
        return FALSE;
 
    if (!xdr_state_owner4(xdr, args->owner))
        return FALSE;
 
    if (!encode_openflag4(xdr, &args->openhow))
        return FALSE;
 
    return encode_open_claim4(xdr, args->claim);
}

encode_op_openattr()

static bool_t encode_op_openattr ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2171 of file nfs41_xdr.c.

{
    nfs41_openattr_args *args = (nfs41_openattr_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_OPENATTR))
        return FALSE;
 
    return xdr_bool(xdr, &args->createdir);
}

encode_op_putfh()

static bool_t encode_op_putfh ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1080 of file nfs41_xdr.c.

{
    nfs41_putfh_args *args = (nfs41_putfh_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_PUTFH))
        return FALSE;
 
    return xdr_fh(xdr, &args->file->fh);
}

encode_op_putrootfh()

static bool_t encode_op_putrootfh ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1108 of file nfs41_xdr.c.

{
    if (unexpected_op(argop->op, OP_PUTROOTFH))
        return FALSE;
    /* void */
    return TRUE;
}

encode_op_read()

static bool_t encode_op_read ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2199 of file nfs41_xdr.c.

{
    nfs41_read_args *args = (nfs41_read_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_READ))
        return FALSE;
 
    if (!xdr_stateid4(xdr, &args->stateid->stateid))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    return xdr_u_int32_t(xdr, &args->count);
}

encode_op_readdir()

static bool_t encode_op_readdir ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2251 of file nfs41_xdr.c.

{
    nfs41_readdir_args *args = (nfs41_readdir_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_READDIR))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->cookie.cookie))
        return FALSE;
 
    if (!xdr_opaque(xdr, (char *)args->cookie.verf, NFS4_VERIFIER_SIZE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->dircount))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->maxcount))
        return FALSE;
 
    return xdr_bitmap4(xdr, args->attr_request);
}

encode_op_readlink()

static bool_t encode_op_readlink ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2403 of file nfs41_xdr.c.

{
    if (unexpected_op(argop->op, OP_READLINK))
        return FALSE;
 
    /* void */
    return TRUE;
}

encode_op_reclaim_complete()

static bool_t encode_op_reclaim_complete ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 1051 of file nfs41_xdr.c.

{
    bool_t zero = FALSE;
 
    if (unexpected_op(argop->op, OP_RECLAIM_COMPLETE))
        return FALSE;
 
    /* rca_one_fs = 0 indicates that the reclaim applies to all filesystems */
    return xdr_bool(xdr, &zero);
}

encode_op_remove()

static bool_t encode_op_remove ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2438 of file nfs41_xdr.c.

{
    nfs41_remove_args *args = (nfs41_remove_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_REMOVE))
        return FALSE;
 
    return encode_component(xdr, args->target);
}

encode_op_rename()

static bool_t encode_op_rename ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2472 of file nfs41_xdr.c.

{
    nfs41_rename_args *args = (nfs41_rename_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_RENAME))
        return FALSE;
 
    if (!encode_component(xdr, args->oldname))
        return FALSE;
 
    return encode_component(xdr, args->newname);
}

encode_op_restorefh()

static bool_t encode_op_restorefh ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2512 of file nfs41_xdr.c.

{
    if (unexpected_op(argop->op, OP_RESTOREFH))
        return FALSE;
 
    /* void */
    return TRUE;
}

encode_op_savefh()

static bool_t encode_op_savefh ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2539 of file nfs41_xdr.c.

{
    if (unexpected_op(argop->op, OP_SAVEFH))
        return FALSE;
 
    /* void */
    return TRUE;
}

encode_op_secinfo()

static bool_t encode_op_secinfo ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2948 of file nfs41_xdr.c.

{
    nfs41_secinfo_args *args = (nfs41_secinfo_args *)argop->arg;
 
    if (unexpected_op(argop->op, OP_SECINFO))
        return FALSE;
 
    if (!encode_component(xdr, args->name))
        return FALSE;
 
    return TRUE;
}

encode_op_secinfo_noname()

static bool_t encode_op_secinfo_noname ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2911 of file nfs41_xdr.c.

{
    nfs41_secinfo_noname_args *args = (nfs41_secinfo_noname_args *)argop->arg;
 
    if (unexpected_op(argop->op, OP_SECINFO_NO_NAME))
        return FALSE;
 
    if (!xdr_enum(xdr, (enum_t *)&args->type))
        return FALSE;
 
    return TRUE;
}

encode_op_sequence()

static bool_t encode_op_sequence ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 983 of file nfs41_xdr.c.

{
    nfs41_sequence_args *args = (nfs41_sequence_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_SEQUENCE))
        return FALSE;
 
    if (!xdr_opaque(xdr, (char *)args->sa_sessionid, NFS4_SESSIONID_SIZE))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->sa_sequenceid))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->sa_slotid))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->sa_highest_slotid))
        return FALSE;
 
    return xdr_bool(xdr, &args->sa_cachethis);
}

encode_op_setattr()

static bool_t encode_op_setattr ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2665 of file nfs41_xdr.c.

{
    nfs41_setattr_args *args = (nfs41_setattr_args*)argop->arg;
    fattr4 attrs;
 
    if (unexpected_op(argop->op, OP_SETATTR))
        return FALSE;
 
    if (!xdr_stateid4(xdr, &args->stateid->stateid))
        return FALSE;
 
    /* encode attribute values from args->info into attrs.attr_vals */
    attrs.attr_vals_len = NFS4_OPAQUE_LIMIT;
    if (!encode_file_attrs(&attrs, args->info))
        return FALSE;
 
    return xdr_fattr4(xdr, &attrs);
}

encode_op_test_stateid()

static bool_t encode_op_test_stateid ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2794 of file nfs41_xdr.c.

{
    nfs41_test_stateid_args *args = (nfs41_test_stateid_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_TEST_STATEID))
        return FALSE;
 
    return xdr_array(xdr, (char**)&args->stateids, &args->count,
        args->count, sizeof(stateid_arg), (xdrproc_t)xdr_stateid4);
}

encode_op_want_delegation()

static bool_t encode_op_want_delegation ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2708 of file nfs41_xdr.c.

{
    nfs41_want_delegation_args *args = (nfs41_want_delegation_args*)argop->arg;
 
    if (unexpected_op(argop->op, OP_WANT_DELEGATION))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->want))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->claim->claim))
        return FALSE;
 
    return args->claim->claim != CLAIM_PREVIOUS ||
        xdr_u_int32_t(xdr, &args->claim->prev_delegate_type);
}

encode_op_write()

static bool_t encode_op_write ( XDR *  xdr, nfs_argop4 *  argop  )

static

Definition at line 2830 of file nfs41_xdr.c.

{
    nfs41_write_args *args = (nfs41_write_args*)argop->arg;
    unsigned char *data = args->data;
 
    if (unexpected_op(argop->op, OP_WRITE))
        return FALSE;
 
    if (!xdr_stateid4(xdr, &args->stateid->stateid))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &args->offset))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->stable))
        return FALSE;
 
    return xdr_bytes(xdr, (char **)&data, &args->data_len, NFS41_MAX_FILEIO_SIZE);
}

encode_open_claim4()

static bool_t encode_open_claim4 ( XDR *  xdr, open_claim4 *  oc  )

static

Definition at line 1960 of file nfs41_xdr.c.

{
    if (!xdr_u_int32_t(xdr, &oc->claim))
        return FALSE;
 
    switch (oc->claim)
    {
    case CLAIM_NULL:
        return encode_component(xdr, oc->u.null.filename);
    case CLAIM_PREVIOUS:
        return xdr_u_int32_t(xdr, &oc->u.prev.delegate_type);
    case CLAIM_FH:
        return TRUE; /* use current file handle */
    case CLAIM_DELEGATE_CUR:
        return encode_claim_deleg_cur(xdr,
            &oc->u.deleg_cur.delegate_stateid->stateid,
            oc->u.deleg_cur.name);
    case CLAIM_DELEG_CUR_FH:
        return xdr_stateid4(xdr,
            &oc->u.deleg_cur_fh.delegate_stateid->stateid);
    case CLAIM_DELEGATE_PREV:
        return encode_component(xdr, oc->u.deleg_prev.filename);
    case CLAIM_DELEG_PREV_FH:
        return TRUE; /* use current file handle */
    default:
        eprintf("encode_open_claim4: unsupported claim %d.\n",
            oc->claim);
        return FALSE;
    }
}

Referenced by encode_op_open().

encode_openflag4()

static bool_t encode_openflag4 ( XDR *  xdr, openflag4 *  of  )

static

Definition at line 1930 of file nfs41_xdr.c.

{
    bool_t result = TRUE;
 
    if (!xdr_u_int32_t(xdr, &of->opentype))
        return FALSE;
 
    switch (of->opentype)
    {
    case OPEN4_CREATE:
        result = encode_createhow4(xdr, &of->how);
        break;
    default:
        break;
    }
    return result;
}

Referenced by encode_op_open().

nfs_decode_compound()

bool_t nfs_decode_compound	(	XDR *	xdr,
		caddr_t *	pres
	)

Definition at line 3625 of file nfs41_xdr.c.

{
    nfs41_compound_res *res = (nfs41_compound_res*)pres;
    uint32_t i, expected_count, expected_op;
    const op_table_entry *entry;
    unsigned char *tag = res->tag;
 
    if (!xdr_u_int32_t(xdr, &res->status))
        return FALSE;
 
    if (!xdr_bytes(xdr, (char **)&tag, &res->tag_len, NFS4_OPAQUE_LIMIT))
        return FALSE;
 
    expected_count = res->resarray_count;
    if (!xdr_u_int32_t(xdr, &res->resarray_count))
        return FALSE;
 
    /* validate the number of operations against what we sent */
    if (res->resarray_count > expected_count) {
        eprintf("reply with %u operations, only sent %u!\n",
            res->resarray_count, expected_count);
        return FALSE;
    } else if (res->resarray_count < expected_count &&
        res->status == NFS4_OK) {
        /* illegal for a server to reply with less operations,
         * unless one of them fails */
        eprintf("successful reply with only %u operations, sent %u!\n",
            res->resarray_count, expected_count);
        return FALSE;
    }
 
    for (i = 0; i < res->resarray_count; i++)
    {
        expected_op = res->resarray[i].op;
        if (!xdr_u_int32_t(xdr, &res->resarray[i].op))
            return FALSE;
 
        /* validate each operation number against what we sent */
        if (res->resarray[i].op != expected_op) {
            eprintf("reply with %s in operation %u, expected %s!\n",
                nfs_opnum_to_string(res->resarray[i].op), i+1,
                nfs_opnum_to_string(expected_op));
            return FALSE;
        }
 
        entry = op_table_find(res->resarray[i].op);
        if (entry == NULL || entry->decode == NULL)
            return FALSE;
        if (!entry->decode(xdr, &res->resarray[i]))
            return FALSE;
    }
    return TRUE;
}

Referenced by nfs41_send_compound().

nfs_encode_compound()

bool_t nfs_encode_compound	(	XDR *	xdr,
		caddr_t *	pargs
	)

Definition at line 3591 of file nfs41_xdr.c.

{
    unsigned char *tag;
 
    nfs41_compound_args *args = (nfs41_compound_args*)pargs;
    uint32_t i;
    const op_table_entry *entry;
 
    tag = args->tag;
    if (!xdr_bytes(xdr, (char **)&tag, &args->tag_len, NFS4_OPAQUE_LIMIT))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->minorversion))
        return FALSE;
 
    if (!xdr_u_int32_t(xdr, &args->argarray_count))
        return FALSE;
 
    for (i = 0; i < args->argarray_count; i++)
    {
        entry = op_table_find(args->argarray[i].op);
        if (entry == NULL || entry->encode == NULL)
            return FALSE;
 
        if (!xdr_u_int32_t(xdr, &args->argarray[i].op))
            return FALSE;
        if (!entry->encode(xdr, &args->argarray[i]))
            return FALSE;
    }
    return TRUE;
}

Referenced by nfs41_send_compound().

nfsacl41_free()

void nfsacl41_free

(

nfsacl41 *

acl

)

Definition at line 335 of file nfs41_xdr.c.

{
    XDR xdr = { XDR_FREE };
    xdr_nfsacl41(&xdr, acl);
}

Referenced by handle_getacl().

op_table_find()

static const op_table_entry * op_table_find ( uint32_t  op )

static

Definition at line 3582 of file nfs41_xdr.c.

{
    return op >= g_op_table_size ? NULL : &g_op_table[op];
}

Referenced by nfs_decode_compound(), and nfs_encode_compound().

settime_how()

static uint32_t settime_how ( nfstime4 *  newtime, const nfstime4 *  time_delta  )

static

Definition at line 98 of file nfs41_xdr.c.

{
    nfstime4 current;
    get_nfs_time(&current);
    /* get the absolute difference between current and newtime */
    nfstime_diff(&current, newtime, &current);
    nfstime_abs(&current, &current);
    /* compare the difference with time_delta */
    nfstime_diff(time_delta, &current, &current);
    /* use client time if diff > delta (i.e. time_delta - current < 0) */
    return current.seconds < 0 ? SET_TO_CLIENT_TIME4 : SET_TO_SERVER_TIME4;
}

Referenced by xdr_settime4().

unexpected_op()

static __inline int unexpected_op ( uint32_t  op, uint32_t  expected  )

static

Definition at line 36 of file nfs41_xdr.c.

{
    if (op == expected)
        return 0;
 
    eprintf("Op table mismatch. Got %s (%d), expected %s (%d).\n",
        nfs_opnum_to_string(op), op,
        nfs_opnum_to_string(expected), expected);
    return 1;
}

Referenced by decode_op_access(), decode_op_bind_conn_to_session(), decode_op_close(), decode_op_commit(), decode_op_create(), decode_op_create_session(), decode_op_delegpurge(), decode_op_delegreturn(), decode_op_destroy_clientid(), decode_op_destroy_session(), decode_op_exchange_id(), decode_op_free_stateid(), decode_op_getattr(), decode_op_getdeviceinfo(), decode_op_getfh(), decode_op_layoutcommit(), decode_op_layoutget(), decode_op_layoutreturn(), decode_op_link(), decode_op_lock(), decode_op_lockt(), decode_op_locku(), decode_op_lookup(), decode_op_open(), decode_op_openattr(), decode_op_putfh(), decode_op_putrootfh(), decode_op_read(), decode_op_readdir(), decode_op_readlink(), decode_op_reclaim_complete(), decode_op_remove(), decode_op_rename(), decode_op_restorefh(), decode_op_savefh(), decode_op_secinfo(), decode_op_secinfo_noname(), decode_op_sequence(), decode_op_setattr(), decode_op_test_stateid(), decode_op_want_delegation(), decode_op_write(), encode_op_access(), encode_op_bind_conn_to_session(), encode_op_close(), encode_op_commit(), encode_op_create(), encode_op_create_session(), encode_op_delegpurge(), encode_op_delegreturn(), encode_op_destroy_clientid(), encode_op_destroy_session(), encode_op_exchange_id(), encode_op_free_stateid(), encode_op_getattr(), encode_op_getdeviceinfo(), encode_op_getfh(), encode_op_layoutcommit(), encode_op_layoutget(), encode_op_layoutreturn(), encode_op_link(), encode_op_lock(), encode_op_lockt(), encode_op_locku(), encode_op_lookup(), encode_op_open(), encode_op_openattr(), encode_op_putfh(), encode_op_putrootfh(), encode_op_read(), encode_op_readdir(), encode_op_readlink(), encode_op_reclaim_complete(), encode_op_remove(), encode_op_rename(), encode_op_restorefh(), encode_op_savefh(), encode_op_secinfo(), encode_op_secinfo_noname(), encode_op_sequence(), encode_op_setattr(), encode_op_test_stateid(), encode_op_want_delegation(), and encode_op_write().

xdr_bitmap4()

bool_t xdr_bitmap4	(	XDR *	xdr,
		bitmap4 *	bitmap
	)

Definition at line 48 of file nfs41_xdr.c.

{
    uint32_t i;
 
    if (xdr->x_op == XDR_ENCODE) {
        if (bitmap->count > 3) {
            eprintf("encode_bitmap4: count (%d) must be <= 3\n",
                bitmap->count);
            return FALSE;
        }
        if (!xdr_u_int32_t(xdr, &bitmap->count))
            return FALSE;
 
        for (i = 0; i < bitmap->count; i++)
            if (!xdr_u_int32_t(xdr, &bitmap->arr[i]))
                return FALSE;
 
    } else if (xdr->x_op == XDR_DECODE) {
        if (!xdr_u_int32_t(xdr, &bitmap->count))
            return FALSE;
        if (bitmap->count > 3) {
            eprintf("decode_bitmap4: count (%d) must be <= 3\n",
                bitmap->count);
            return FALSE;
        }
 
        for (i = 0; i < bitmap->count; i++)
            if (!xdr_u_int32_t(xdr, &bitmap->arr[i]))
                return FALSE;
    } else 
        return FALSE;
 
    return TRUE;
}

Referenced by common_notify4(), decode_file_attrs(), decode_getdeviceinfo_ok(), decode_op_create(), decode_op_setattr(), decode_open_res_ok(), encode_op_getattr(), encode_op_getdeviceinfo(), encode_op_readdir(), op_cb_getattr_args(), xdr_fattr4(), and xdr_threshold_item().

xdr_change_info4()

static bool_t xdr_change_info4 ( XDR *  xdr, change_info4 *  cinfo  )

static

Definition at line 1371 of file nfs41_xdr.c.

{
    if (!xdr_bool(xdr, &cinfo->atomic))
        return FALSE;
 
    if (!xdr_u_hyper(xdr, &cinfo->before))
        return FALSE;
 
    return xdr_u_hyper(xdr, &cinfo->after);
}

Referenced by decode_op_create(), decode_op_link(), decode_op_remove(), decode_op_rename(), and decode_open_res_ok().

xdr_channel_attrs4()

static bool_t xdr_channel_attrs4 ( XDR *  xdr, nfs41_channel_attrs *  attrs  )

static

Definition at line 710 of file nfs41_xdr.c.

{
    uint32_t zero = 0;
    uint32_t one = 1;
 
    /* count4 ca_headerpadsize */
    if (!xdr_u_int32_t(xdr, &attrs->ca_headerpadsize))
        return FALSE;
 
    /* count4 ca_maxrequestsize */
    if (!xdr_u_int32_t(xdr, &attrs->ca_maxrequestsize))
        return FALSE;
 
    /* count4 ca_maxresponsesize */
    if (!xdr_u_int32_t(xdr, &attrs->ca_maxresponsesize))
        return FALSE;
 
    /* count4 ca_maxresponsesize_cached */
    if (!xdr_u_int32_t(xdr, &attrs->ca_maxresponsesize_cached))
        return FALSE;
 
    /* count4 ca_maxoperations */
    if (!xdr_u_int32_t(xdr, &attrs->ca_maxoperations))
        return FALSE;
 
    /* count4 ca_maxrequests */
    if (!xdr_u_int32_t(xdr, &attrs->ca_maxrequests))
        return FALSE;
 
    if (xdr->x_op == XDR_ENCODE) {
        /* uint32_t ca_rdma_ird<1> */
        if (attrs->ca_rdma_ird)
        {
            if (!xdr_u_int32_t(xdr, &one))
                return FALSE;
            return xdr_u_int32_t(xdr, attrs->ca_rdma_ird);
        }
        else {
            return xdr_u_int32_t(xdr, &zero);
        }
    }
    else if (xdr->x_op == XDR_DECODE) {
#if 0
        u_int32_t count;
        /* uint32_t ca_rdma_ird<1> */
        if (!xdr_u_int32_t(xdr, &count))
            return FALSE;
        if (count > 1)
            return FALSE;
        if (count)
            return xdr_u_int32_t(xdr, attrs->ca_rdma_ird);
        else
#endif
            return TRUE;
    }
    else {
        eprintf("%s: xdr->x_op %d not supported.\n",
            "xdr_channel_attrs4", xdr->x_op);
        return FALSE;
    }
}

Referenced by decode_op_create_session(), and encode_op_create_session().

xdr_client_owner4()

static bool_t xdr_client_owner4 ( XDR *  xdr, client_owner4 *  co  )

static

Definition at line 460 of file nfs41_xdr.c.

{
    unsigned char *co_ownerid = co->co_ownerid;
    if (!xdr_opaque(xdr, (char *)&co->co_verifier[0], NFS4_VERIFIER_SIZE))
        return FALSE;
 
    return xdr_bytes(xdr, (char **)&co_ownerid, &co->co_ownerid_le