xdr.c File Reference

#include <wintirpc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <rpc/types.h>
#include <rpc/xdr.h>

Include dependency graph for xdr.c:

Go to the source code of this file.

Macros
#define	XDR_FALSE   ((long) 0)
#define	XDR_TRUE   ((long) 1)
#define	LASTUNSIGNED   ((u_int) 0-1)

Typedefs
typedef quad_t	longlong_t
typedef u_quad_t	u_longlong_t

Functions
void	xdr_free (xdrproc_t proc, void *objp)
bool_t	xdr_void (void)
bool_t	xdr_int (XDR *xdrs, int *ip)
bool_t	xdr_u_int (XDR *xdrs, u_int *up)
bool_t	xdr_long (XDR *xdrs, long *lp)
bool_t	xdr_u_long (XDR *xdrs, u_long *ulp)
bool_t	xdr_int32_t (XDR *xdrs, int32_t *int32_p)
bool_t	xdr_u_int32_t (XDR *xdrs, u_int32_t *u_int32_p)
bool_t	xdr_short (XDR *xdrs, short *sp)
bool_t	xdr_u_short (XDR *xdrs, u_short *usp)
bool_t	xdr_int16_t (XDR *xdrs, int16_t *int16_p)
bool_t	xdr_u_int16_t (XDR *xdrs, u_int16_t *u_int16_p)
bool_t	xdr_char (XDR *xdrs, char *cp)
bool_t	xdr_u_char (XDR *xdrs, u_char *cp)
bool_t	xdr_bool (XDR *xdrs, bool_t *bp)
bool_t	xdr_enum (XDR *xdrs, enum_t *ep)
bool_t	xdr_opaque (XDR *xdrs, caddr_t cp, u_int cnt)
bool_t	xdr_bytes (XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize)
bool_t	xdr_netobj (XDR *xdrs, struct netobj *np)
bool_t	xdr_union (XDR *xdrs, enum_t *dscmp, char *unp, const struct xdr_discrim *choices, xdrproc_t dfault)
bool_t	xdr_string (XDR *xdrs, char **cpp, u_int maxsize)
bool_t	xdr_wrapstring (XDR *xdrs, char **cpp)
bool_t	xdr_int64_t (XDR *xdrs, int64_t *llp)
bool_t	xdr_u_int64_t (XDR *xdrs, u_int64_t *ullp)
bool_t	xdr_hyper (XDR *xdrs, longlong_t *llp)
bool_t	xdr_u_hyper (XDR *xdrs, u_longlong_t *ullp)
bool_t	xdr_longlong_t (XDR *xdrs, longlong_t *llp)
bool_t	xdr_u_longlong_t (XDR *xdrs, u_longlong_t *ullp)

Variables
static const char	xdr_zero [BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }

Macro Definition Documentation

LASTUNSIGNED

#define LASTUNSIGNED   ((u_int) 0-1)

Definition at line 65 of file xdr.c.

XDR_FALSE

#define XDR_FALSE   ((long) 0)

Definition at line 62 of file xdr.c.

XDR_TRUE

#define XDR_TRUE   ((long) 1)

Definition at line 63 of file xdr.c.

Typedef Documentation

longlong_t

typedef quad_t longlong_t

Definition at line 56 of file xdr.c.

u_longlong_t

typedef u_quad_t u_longlong_t

Definition at line 57 of file xdr.c.

Function Documentation

xdr_bool()

bool_t xdr_bool	(	XDR *	xdrs,
		bool_t *	bp
	)

Definition at line 428 of file xdr.c.

{
    long lb;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        lb = *bp ? XDR_TRUE : XDR_FALSE;
        return (XDR_PUTLONG(xdrs, &lb));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, &lb)) {
            return (FALSE);
        }
        *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by cb_notify_deviceid_change(), decode_file_attrs(), decode_layout_res_ok(), decode_op_bind_conn_to_session(), decode_op_layoutcommit(), decode_op_layoutget(), decode_op_layoutreturn(), decode_open_none_delegation4(), decode_open_read_delegation4(), decode_open_write_delegation4(), decode_read_res_ok(), decode_readdir_entry(), decode_readdir_list(), encode_file_attrs(), encode_op_layoutcommit(), encode_op_layoutget(), encode_op_layoutreturn(), encode_op_lock(), encode_op_openattr(), encode_op_reclaim_complete(), encode_op_sequence(), op_cb_layoutrecall_args(), op_cb_recall_args(), op_cb_sequence_args(), rpcb_set(), rpcb_unset(), xdr_change_info4(), xdr_locker4(), xdr_pmaplist(), xdr_pointer(), xdr_rpcb_entry_list_ptr(), and xdr_rpcblist_ptr().

xdr_bytes()

bool_t xdr_bytes	(	XDR *	xdrs,
		char **	cpp,
		u_int *	sizep,
		u_int	maxsize
	)

Definition at line 536 of file xdr.c.

{
    char *sp = *cpp;  /* sp is the actual string pointer */
    u_int nodesize;
#ifdef __REACTOS__ // CVE-2017-8779
    bool_t ret, allocated = FALSE;
#endif
 
    /*
     * first deal with the length since xdr bytes are counted
     */
    if (! xdr_u_int(xdrs, sizep)) {
        return (FALSE);
    }
    nodesize = *sizep;
    if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
        return (FALSE);
    }
 
    /*
     * now deal with the actual bytes
     */
    switch (xdrs->x_op) {
 
    case XDR_DECODE:
        if (nodesize == 0) {
            return (TRUE);
        }
        if (sp == NULL) {
            *cpp = sp = mem_alloc(nodesize);
#ifdef __REACTOS__ // CVE-2017-8779
            allocated = TRUE;
#endif
        }
        if (sp == NULL) {
            //warnx("xdr_bytes: out of memory");
            return (FALSE);
        }
        /* FALLTHROUGH */
 
    case XDR_ENCODE:
#ifndef __REACTOS__ // CVE-2017-8779
        return (xdr_opaque(xdrs, sp, nodesize));
#else
        ret = xdr_opaque(xdrs, sp, nodesize);
        if ((xdrs->x_op == XDR_DECODE) && (ret == FALSE)) {
            if (allocated == TRUE) {
                free(sp);
                *cpp = NULL;
            }
        }
        return (ret);
#endif
 
    case XDR_FREE:
        if (sp != NULL) {
            mem_free(sp, nodesize);
            *cpp = NULL;
        }
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by common_notify4(), decode_component(), decode_file_attrs(), decode_fs_location4(), decode_op_exchange_id(), decode_op_readlink(), decode_pathname4(), decode_read_res_ok(), decode_readdir_entry(), encode_component(), encode_createtype4(), encode_file_attrs(), encode_op_write(), nfs_decode_compound(), nfs_encode_compound(), xdr_client_owner4(), xdr_fattr4(), xdr_fh(), xdr_netbuf(), xdr_netobj(), xdr_nfs_impl_id4(), xdr_opaque_auth(), xdr_pnfs_addr(), xdr_rpc_gss_cred(), xdr_rpc_gss_init_args(), xdr_rpc_gss_init_res(), xdr_rpc_gss_unwrap_data(), xdr_rpc_gss_wrap_data(), xdr_rpc_sspi_cred(), xdr_rpc_sspi_init_args(), xdr_rpc_sspi_init_res(), xdr_rpc_sspi_unwrap_data(), xdr_rpc_sspi_wrap_data(), xdr_secinfo(), xdr_server_owner4(), and xdr_state_owner4().

xdr_char()

bool_t xdr_char	(	XDR *	xdrs,
		char *	cp
	)

Definition at line 392 of file xdr.c.

{
    int i;
 
    i = (*cp);
    if (!xdr_int(xdrs, &i)) {
        return (FALSE);
    }
    *cp = (char)i;
    return (TRUE);
}

xdr_enum()

bool_t xdr_enum	(	XDR *	xdrs,
		enum_t *	ep
	)

Definition at line 458 of file xdr.c.

{
    enum sizecheck { SIZEVAL }; /* used to find the size of an enum */
 
    /*
     * enums are treated as ints
     */
    /* LINTED */ if (sizeof (enum sizecheck) == sizeof (long)) {
        return (xdr_long(xdrs, (long *)(void *)ep));
    } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (int)) {
        return (xdr_int(xdrs, (int *)(void *)ep));
    } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (short)) {
        return (xdr_short(xdrs, (short *)(void *)ep));
    } else {
        return (FALSE);
    }
}

Referenced by decode_getdeviceinfo_ok(), decode_layout(), decode_op_bind_conn_to_session(), decode_op_reclaim_complete(), decode_op_want_delegation(), decode_open_none_delegation4(), decode_open_res_ok(), encode_op_bind_conn_to_session(), encode_op_getdeviceinfo(), encode_op_layoutcommit(), encode_op_layoutreturn(), encode_op_secinfo_noname(), op_cb_getattr_res(), op_cb_layoutrecall_args(), op_cb_layoutrecall_res(), op_cb_notify_deviceid_res(), op_cb_notify_lock_res(), op_cb_notify_res(), op_cb_push_deleg_res(), op_cb_recall_any_res(), op_cb_recall_res(), op_cb_recall_slot_res(), op_cb_recallable_obj_avail_res(), op_cb_wants_cancelled_res(), proc_cb_compound_res(), xdr_accepted_reply(), xdr_authdes_cred(), xdr_callhdr(), xdr_callmsg(), xdr_getxiddir(), xdr_keystatus(), xdr_opaque_auth(), xdr_rejected_reply(), xdr_replymsg(), xdr_rpc_gss_cred(), xdr_rpc_sspi_cred(), xdr_secinfo(), xdr_union(), and xdr_write_verf().

xdr_free()

void xdr_free	(	xdrproc_t	proc,
		void *	objp
	)

Definition at line 78 of file xdr.c.

{
    XDR x;
    
    x.x_op = XDR_FREE;
    (*proc)(&x, objp);
}

Referenced by __rpcb_findaddr_timed().

xdr_hyper()

bool_t xdr_hyper	(	XDR *	xdrs,
		longlong_t *	llp
	)

Definition at line 861 of file xdr.c.

{
 
    /*
     * Don't bother open-coding this; it's a fair amount of code.  Just
     * call xdr_int64_t().
     */
    return (xdr_int64_t(xdrs, (int64_t *)llp));
}

Referenced by xdr_nfstime4().

xdr_int()

bool_t xdr_int	(	XDR *	xdrs,
		int *	ip
	)

Definition at line 103 of file xdr.c.

{
    long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (long) *ip;
        return (XDR_PUTLONG(xdrs, &l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, &l)) {
            return (FALSE);
        }
        *ip = (int) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by rpcb_gettime(), xdr_authunix_parms(), xdr_char(), xdr_enum(), xdr_rpcb_stat(), xdr_rpcbs_addrlist(), xdr_rpcbs_proc(), and xdr_rpcbs_rmtcalllist().

xdr_int16_t()

bool_t xdr_int16_t	(	XDR *	xdrs,
		int16_t *	int16_p
	)

Definition at line 331 of file xdr.c.

{
    long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (long) *int16_p;
        return (XDR_PUTLONG(xdrs, &l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, &l)) {
            return (FALSE);
        }
        *int16_p = (int16_t) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

xdr_int32_t()

bool_t xdr_int32_t	(	XDR *	xdrs,
		int32_t *	int32_p
	)

Definition at line 208 of file xdr.c.

{
    long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (long) *int32_p;
        return (XDR_PUTLONG(xdrs, &l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, &l)) {
            return (FALSE);
        }
        *int32_p = (int32_t) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

xdr_int64_t()

bool_t xdr_int64_t	(	XDR *	xdrs,
		int64_t *	llp
	)

Definition at line 795 of file xdr.c.

{
    u_long ul[2];
 
    switch (xdrs->x_op) {
    case XDR_ENCODE:
        ul[0] = (u_long)((u_int64_t)*llp >> 32) & 0xffffffff;
        ul[1] = (u_long)((u_int64_t)*llp) & 0xffffffff;
        if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
            return (FALSE);
        return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
    case XDR_DECODE:
        if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
            return (FALSE);
        if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
            return (FALSE);
        *llp = (int64_t)
            (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
        return (TRUE);
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by xdr_hyper(), and xdr_longlong_t().

xdr_long()

bool_t xdr_long	(	XDR *	xdrs,
		long *	lp
	)

Definition at line 165 of file xdr.c.

{
    switch (xdrs->x_op) {
    case XDR_ENCODE:
        return (XDR_PUTLONG(xdrs, lp));
    case XDR_DECODE:
        return (XDR_GETLONG(xdrs, lp));
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by xdr_enum().

xdr_longlong_t()

bool_t xdr_longlong_t	(	XDR *	xdrs,
		longlong_t *	llp
	)

Definition at line 895 of file xdr.c.

{
 
    /*
     * Don't bother open-coding this; it's a fair amount of code.  Just
     * call xdr_int64_t().
     */
    return (xdr_int64_t(xdrs, (int64_t *)llp));
}

xdr_netobj()

bool_t xdr_netobj	(	XDR *	xdrs,
		struct netobj *	np
	)

Definition at line 609 of file xdr.c.

{
 
    return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ));
}

Referenced by xdr_cryptkeyarg2().

xdr_opaque()

bool_t xdr_opaque	(	XDR *	xdrs,
		caddr_t	cp,
		u_int	cnt
	)

Definition at line 484 of file xdr.c.

{
    u_int rndup;
    static int crud[BYTES_PER_XDR_UNIT];
 
    /*
     * if no data we are done
     */
    if (cnt == 0)
        return (TRUE);
 
    /*
     * round byte count to full xdr units
     */
    rndup = cnt % BYTES_PER_XDR_UNIT;
    if (rndup > 0)
        rndup = BYTES_PER_XDR_UNIT - rndup;
 
    if (xdrs->x_op == XDR_DECODE) {
        if (!XDR_GETBYTES(xdrs, cp, cnt)) {
            return (FALSE);
        }
        if (rndup == 0)
            return (TRUE);
        return (XDR_GETBYTES(xdrs, (caddr_t)(void *)crud, rndup));
    }
 
    if (xdrs->x_op == XDR_ENCODE) {
        if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
            return (FALSE);
        }
        if (rndup == 0)
            return (TRUE);
        return (XDR_PUTBYTES(xdrs, xdr_zero, rndup));
    }
 
    if (xdrs->x_op == XDR_FREE) {
        return (TRUE);
    }
 
    return (FALSE);
}

Referenced by cb_compound_tag(), cb_notify_deviceid_change(), cb_notify_deviceid_delete(), common_fh(), common_stateid(), decode_file_layout(), decode_op_bind_conn_to_session(), decode_op_commit(), decode_op_create_session(), decode_op_readdir(), encode_createhow4(), encode_op_bind_conn_to_session(), encode_op_destroy_session(), encode_op_getdeviceinfo(), encode_op_readdir(), encode_op_sequence(), op_cb_sequence_args(), op_cb_sequence_ref_list(), op_cb_sequence_res_ok(), xdr_authdes_cred(), xdr_authdes_verf(), xdr_bytes(), xdr_callmsg(), xdr_client_owner4(), xdr_des_block(), xdr_keybuf(), xdr_sequence_res_ok(), xdr_stateid4(), xdr_string(), and xdr_write_verf().

xdr_short()

bool_t xdr_short	(	XDR *	xdrs,
		short *	sp
	)

Definition at line 270 of file xdr.c.

{
    long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (long) *sp;
        return (XDR_PUTLONG(xdrs, &l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, &l)) {
            return (FALSE);
        }
        *sp = (short) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by xdr_enum().

xdr_string()

bool_t xdr_string	(	XDR *	xdrs,
		char **	cpp,
		u_int	maxsize
	)

Definition at line 678 of file xdr.c.

{
    char *sp = *cpp;  /* sp is the actual string pointer */
    u_int size;
    u_int nodesize;
#ifdef __REACTOS__ // CVE-2017-8779
    bool_t ret, allocated = FALSE;
#endif
 
    /*
     * first deal with the length since xdr strings are counted-strings
     */
    switch (xdrs->x_op) {
    case XDR_FREE:
        if (sp == NULL) {
            return(TRUE);   /* already free */
        }
        /* FALLTHROUGH */
    case XDR_ENCODE:
        if (sp == NULL)
            return FALSE;
        size = strlen(sp);
        break;
    case XDR_DECODE:
        break;
    }
    if (! xdr_u_int(xdrs, &size)) {
        return (FALSE);
    }
    if (size > maxsize) {
        return (FALSE);
    }
    nodesize = size + 1;
    if (nodesize == 0) {
        /* This means an overflow.  It a bug in the caller which
         * provided a too large maxsize but nevertheless catch it
         * here.
         */
        return FALSE;
    }
 
    /*
     * now deal with the actual bytes
     */
    switch (xdrs->x_op) {
 
    case XDR_DECODE:
#ifndef __REACTOS__ // CVE-2017-8779
        if (sp == NULL)
            *cpp = sp = mem_alloc(nodesize);
#else
        if (sp == NULL) {
            *cpp = sp = mem_alloc(nodesize);
            allocated = TRUE;
        }
#endif
        if (sp == NULL) {
            //warnx("xdr_string: out of memory");
            return (FALSE);
        }
        sp[size] = 0;
        /* FALLTHROUGH */
 
    case XDR_ENCODE:
#ifndef __REACTOS__ // CVE-2017-8779
        return (xdr_opaque(xdrs, sp, size));
#else
        ret = xdr_opaque(xdrs, sp, size);
        if ((xdrs->x_op == XDR_DECODE) && (ret == FALSE)) {
            if (allocated == TRUE) {
                free(sp);
                *cpp = NULL;
            }
        }
        return (ret);
#endif
 
    case XDR_FREE:
        mem_free(sp, nodesize);
        *cpp = NULL;
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by encode_backchannel_sec_parms(), xdr_authdes_cred(), xdr_authunix_parms(), xdr_netnamestr(), xdr_nfsace4(), xdr_rpcb(), xdr_rpcb_entry(), xdr_rpcb_rmtcallres(), xdr_rpcbs_addrlist(), xdr_rpcbs_rmtcalllist(), and xdr_wrapstring().

xdr_u_char()

bool_t xdr_u_char	(	XDR *	xdrs,
		u_char *	cp
	)

Definition at line 410 of file xdr.c.

{
    u_int u;
 
    u = (*cp);
    if (!xdr_u_int(xdrs, &u)) {
        return (FALSE);
    }
    *cp = (u_char)u;
    return (TRUE);
}

xdr_u_hyper()

bool_t xdr_u_hyper	(	XDR *	xdrs,
		u_longlong_t *	ullp
	)

Definition at line 878 of file xdr.c.

{
 
    /*
     * Don't bother open-coding this; it's a fair amount of code.  Just
     * call xdr_u_int64_t().
     */
    return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
}

Referenced by decode_file_attrs(), decode_file_layout(), decode_layout(), decode_lock_res_denied(), decode_op_exchange_id(), decode_op_layoutcommit(), decode_readdir_entry(), decode_space_limit4(), encode_file_attrs(), encode_op_commit(), encode_op_create_session(), encode_op_destroy_clientid(), encode_op_layoutcommit(), encode_op_layoutget(), encode_op_layoutreturn(), encode_op_lock(), encode_op_lockt(), encode_op_locku(), encode_op_read(), encode_op_readdir(), encode_op_write(), info_to_fattr4(), xdr_change_info4(), xdr_fsid(), xdr_server_owner4(), xdr_state_owner4(), and xdr_threshold_item().

xdr_u_int()

bool_t xdr_u_int	(	XDR *	xdrs,
		u_int *	up
	)

Definition at line 133 of file xdr.c.

{
    u_long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (u_long) *up;
        return (XDR_PUTLONG(xdrs, (long *)&l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, (long *)&l)) {
            return (FALSE);
        }
        *up = (u_int) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by xdr_array(), xdr_authunix_parms(), xdr_bytes(), xdr_callmsg(), xdr_rpc_gss_cred(), xdr_rpc_gss_init_res(), xdr_rpc_gss_unwrap_data(), xdr_rpc_gss_wrap_data(), xdr_rpc_sspi_cred(), xdr_rpc_sspi_init_res(), xdr_rpc_sspi_unwrap_data(), xdr_rpc_sspi_wrap_data(), xdr_rpcb_rmtcallargs(), xdr_rpcb_rmtcallres(), xdr_string(), xdr_u_char(), and xdr_unixcred().

xdr_u_int16_t()

bool_t xdr_u_int16_t	(	XDR *	xdrs,
		u_int16_t *	u_int16_p
	)

Definition at line 361 of file xdr.c.

{
    u_long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (u_long) *u_int16_p;
        return (XDR_PUTLONG(xdrs, (long *)&l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, (long *)&l)) {
            return (FALSE);
        }
        *u_int16_p = (u_int16_t) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

xdr_u_int32_t()

bool_t xdr_u_int32_t	(	XDR *	xdrs,
		u_int32_t *	u_int32_p
	)

Definition at line 239 of file xdr.c.

{
    u_long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (u_long) *u_int32_p;
        return (XDR_PUTLONG(xdrs, (long *)&l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, (long *)&l)) {
            return (FALSE);
        }
        *u_int32_p = (u_int32_t) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by cb_compound_tag(), cb_notify_deviceid_change(), cb_notify_deviceid_delete(), common_fh(), common_stateid(), decode_file_attrs(), decode_file_layout(), decode_file_layout_handles(), decode_fs_location4(), decode_fs_locations4(), decode_getdeviceinfo_ok(), decode_layout_res_ok(), decode_lock_res_denied(), decode_modified_limit4(), decode_op_access(), 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_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(), decode_open_res_ok(), decode_pathname4(), decode_space_limit4(), encode_backchannel_sec_parms(), encode_createhow4(), encode_createtype4(), encode_file_attrs(), encode_op_access(), encode_op_bind_conn_to_session(), encode_op_close(), encode_op_commit(), encode_op_create_session(), encode_op_exchange_id(), encode_op_getdeviceinfo(), encode_op_layoutcommit(), encode_op_layoutget(), encode_op_layoutreturn(), encode_op_lock(), encode_op_lockt(), encode_op_locku(), encode_op_open(), encode_op_read(), encode_op_readdir(), encode_op_sequence(), encode_op_want_delegation(), encode_op_write(), encode_open_claim4(), encode_openflag4(), nfs_decode_compound(), nfs_encode_compound(), op_cb_notify_args(), op_cb_notify_lock_args(), op_cb_push_deleg_args(), op_cb_recall_any_args(), op_cb_recall_slot_args(), op_cb_recallable_obj_avail_args(), op_cb_sequence_args(), op_cb_sequence_ref(), op_cb_sequence_res_ok(), op_cb_wants_cancelled_args(), proc_cb_compound_args(), xdr_accepted_reply(), xdr_bitmap4(), xdr_callhdr(), xdr_callmsg(), xdr_channel_attrs4(), xdr_data_server_list(), xdr_getcallbody(), xdr_getxiddir(), xdr_layout_types(), xdr_locker4(), xdr_mdsthreshold(), xdr_multi_addr(), xdr_netbuf(), xdr_nfsace4(), xdr_nfsdacl41(), xdr_nfstime4(), xdr_rejected_reply(), xdr_replymsg(), xdr_rpcb(), xdr_rpcb_entry(), xdr_rpcb_rmtcallargs(), xdr_rpcbs_addrlist(), xdr_rpcbs_rmtcalllist(), xdr_secinfo(), xdr_sequence_res_ok(), xdr_settime4(), xdr_state_protect4_a(), xdr_state_protect4_r(), xdr_stateid4(), xdr_stripe_indices(), xdr_threshold_item(), and xdr_write_res_ok().

xdr_u_int64_t()

bool_t xdr_u_int64_t	(	XDR *	xdrs,
		u_int64_t *	ullp
	)

Definition at line 828 of file xdr.c.

{
    u_long ul[2];
 
    switch (xdrs->x_op) {
    case XDR_ENCODE:
        ul[0] = (u_long)(*ullp >> 32) & 0xffffffff;
        ul[1] = (u_long)(*ullp) & 0xffffffff;
        if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE)
            return (FALSE);
        return (XDR_PUTLONG(xdrs, (long *)&ul[1]));
    case XDR_DECODE:
        if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE)
            return (FALSE);
        if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE)
            return (FALSE);
        *ullp = (u_int64_t)
            (((u_int64_t)ul[0] << 32) | ((u_int64_t)ul[1]));
        return (TRUE);
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by common_fsid(), encode_op_delegpurge(), op_cb_layoutrecall_file(), xdr_u_hyper(), and xdr_u_longlong_t().

xdr_u_long()

bool_t xdr_u_long	(	XDR *	xdrs,
		u_long *	ulp
	)

Definition at line 186 of file xdr.c.

{
    switch (xdrs->x_op) {
    case XDR_ENCODE:
        return (XDR_PUTLONG(xdrs, (long *)ulp));
    case XDR_DECODE:
        return (XDR_GETLONG(xdrs, (long *)ulp));
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by __rpc_get_time_offset(), xdr_authunix_parms(), xdr_pmap(), xdr_rmtcall_args(), and xdr_rmtcallres().

xdr_u_longlong_t()

bool_t xdr_u_longlong_t	(	XDR *	xdrs,
		u_longlong_t *	ullp
	)

Definition at line 912 of file xdr.c.

{
 
    /*
     * Don't bother open-coding this; it's a fair amount of code.  Just
     * call xdr_u_int64_t().
     */
    return (xdr_u_int64_t(xdrs, (u_int64_t *)ullp));
}

xdr_u_short()

bool_t xdr_u_short	(	XDR *	xdrs,
		u_short *	usp
	)

Definition at line 300 of file xdr.c.

{
    u_long l;
 
    switch (xdrs->x_op) {
 
    case XDR_ENCODE:
        l = (u_long) *usp;
        return (XDR_PUTLONG(xdrs, (long *)&l));
 
    case XDR_DECODE:
        if (!XDR_GETLONG(xdrs, (long *)&l)) {
            return (FALSE);
        }
        *usp = (u_short) l;
        return (TRUE);
 
    case XDR_FREE:
        return (TRUE);
    }
    /* NOTREACHED */
    return (FALSE);
}

Referenced by __rpcb_findaddr_timed(), and pmap_getport().

xdr_union()

bool_t xdr_union	(	XDR *	xdrs,
		enum_t *	dscmp,
		char *	unp,
		const struct xdr_discrim *	choices,
		xdrproc_t	dfault
	)

Definition at line 629 of file xdr.c.

{
    enum_t dscm;
 
    /*
     * we deal with the discriminator;  it's an enum
     */
    if (! xdr_enum(xdrs, dscmp)) {
        return (FALSE);
    }
    dscm = *dscmp;
 
    /*
     * search choices for a value that matches the discriminator.
     * if we find one, execute the xdr routine for that value.
     */
    for (; choices->proc != NULL_xdrproc_t; choices++) {
        if (choices->value == dscm)
            return ((*(choices->proc))(xdrs, unp));
    }
 
    /*
     * no match - execute the default xdr routine if there is one
     */
    return ((dfault == NULL_xdrproc_t) ? FALSE :
        (*dfault)(xdrs, unp));
}

Referenced by cb_compound_argop(), cb_compound_resop(), op_cb_layoutrecall_args(), op_cb_sequence_res(), xdr_getreplyunion(), and xdr_replymsg().

xdr_void()

bool_t xdr_void

(

void

)

Definition at line 92 of file xdr.c.

{
 
    return (TRUE);
}

Referenced by __rpc_get_time_offset(), authgss_destroy_context(), authsspi_destroy_context(), clnt_cb_thread(), clnt_create_vers_timed(), key_gendes(), key_secretkey_is_set(), op_cb_sequence_res(), pmap_getmaps(), rpc_broadcast_exp(), rpc_nullproc(), rpcb_getmaps(), rpcb_gettime(), send_null(), universal(), xdr_rpc_gss_unwrap_data(), and xdr_rpc_sspi_unwrap_data().

xdr_wrapstring()

bool_t xdr_wrapstring	(	XDR *	xdrs,
		char **	cpp
	)

Definition at line 772 of file xdr.c.

{
#ifdef __REACTOS__ // CVE-2017-8779
    return xdr_string(xdrs, cpp, RPC_MAXDATASIZE);
#else
    return xdr_string(xdrs, cpp, LASTUNSIGNED);
#endif
}

Referenced by __rpcb_findaddr_timed(), rpcb_taddr2uaddr(), and rpcb_uaddr2taddr().

Variable Documentation

xdr_zero

const char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }

static

Definition at line 71 of file xdr.c.

Referenced by xdr_opaque().