tfs_xdr.c

操作系统SunOS 4.1.3版本的源码

#ifndef lint
static char sccsid[] = "@(#)tfs_xdr.c 1.1 92/07/30 Copyr 1988 Sun Micro";
#endif

/*
 * Copyright (c) 1987 Sun Microsystems, Inc.
 */

#include "headers.h"
#include "vnode.h"
#include "tfs.h"
#include "subr.h"

#ifdef TFSDEBUG
char           *xdropnames[] = {"encode", "decode", "free"};
#endif

#ifdef SUN_OS_4
#define RROK_MAP rrok_map
#else
#define RROK_MAP rrok_bp
#endif

/*
 * These are the XDR routines used to serialize and deserialize
 * the various structures passed as parameters accross the network
 * between NFS clients and servers.
 */



/*
 * Arguments to remote write and writecache
 */
bool_t
xdr_writeargs(xdrs, wa)
	XDR            *xdrs;
	struct nfswriteargs *wa;
{
	if (xdr_fhandle(xdrs, &wa->wa_fhandle) &&
	    xdr_long(xdrs, (long *) &wa->wa_begoff) &&
	    xdr_long(xdrs, (long *) &wa->wa_offset) &&
	    xdr_long(xdrs, (long *) &wa->wa_totcount) &&
	    xdr_bytes(xdrs, &wa->wa_data, (u_int *) & wa->wa_count,
		      NFS_MAXDATA)) {
#ifdef TFSDEBUG
		dprint(tfsdebug, 6, "xdr_writeargs: %s off %d ct %d\n",
		       xdropnames[(int) xdrs->x_op],
		       wa->wa_offset, wa->wa_totcount);
#endif
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_writeargs: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}


/*
 * File attributes
 */
bool_t
xdr_fattr(xdrs, na)
	XDR            *xdrs;
	register struct nfsfattr *na;
{
	register long  *ptr;

#ifdef TFSDEBUG
	dprint(tfsdebug, 6, "xdr_fattr: %s\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	if (xdrs->x_op == XDR_ENCODE) {
		ptr = XDR_INLINE(xdrs, 17 * BYTES_PER_XDR_UNIT);
		if (ptr != NULL) {
			IXDR_PUT_ENUM(ptr, na->na_type);
			IXDR_PUT_LONG(ptr, na->na_mode);
			IXDR_PUT_LONG(ptr, na->na_nlink);
			IXDR_PUT_LONG(ptr, na->na_uid);
			IXDR_PUT_LONG(ptr, na->na_gid);
			IXDR_PUT_LONG(ptr, na->na_size);
			IXDR_PUT_LONG(ptr, na->na_blocksize);
			IXDR_PUT_LONG(ptr, na->na_rdev);
			IXDR_PUT_LONG(ptr, na->na_blocks);
			IXDR_PUT_LONG(ptr, na->na_fsid);
			IXDR_PUT_LONG(ptr, na->na_nodeid);
			IXDR_PUT_LONG(ptr, na->na_atime.tv_sec);
			IXDR_PUT_LONG(ptr, na->na_atime.tv_usec);
			IXDR_PUT_LONG(ptr, na->na_mtime.tv_sec);
			IXDR_PUT_LONG(ptr, na->na_mtime.tv_usec);
			IXDR_PUT_LONG(ptr, na->na_ctime.tv_sec);
			IXDR_PUT_LONG(ptr, na->na_ctime.tv_usec);
			return (TRUE);
		}
	} else {
		ptr = XDR_INLINE(xdrs, 17 * BYTES_PER_XDR_UNIT);
		if (ptr != NULL) {
			na->na_type = IXDR_GET_ENUM(ptr, enum nfsftype);
			na->na_mode = IXDR_GET_LONG(ptr);
			na->na_nlink = IXDR_GET_LONG(ptr);
			na->na_uid = IXDR_GET_LONG(ptr);
			na->na_gid = IXDR_GET_LONG(ptr);
			na->na_size = IXDR_GET_LONG(ptr);
			na->na_blocksize = IXDR_GET_LONG(ptr);
			na->na_rdev = IXDR_GET_LONG(ptr);
			na->na_blocks = IXDR_GET_LONG(ptr);
			na->na_fsid = IXDR_GET_LONG(ptr);
			na->na_nodeid = IXDR_GET_LONG(ptr);
			na->na_atime.tv_sec = IXDR_GET_LONG(ptr);
			na->na_atime.tv_usec = IXDR_GET_LONG(ptr);
			na->na_mtime.tv_sec = IXDR_GET_LONG(ptr);
			na->na_mtime.tv_usec = IXDR_GET_LONG(ptr);
			na->na_ctime.tv_sec = IXDR_GET_LONG(ptr);
			na->na_ctime.tv_usec = IXDR_GET_LONG(ptr);
			return (TRUE);
		}
	}
	if (xdr_enum(xdrs, (enum_t *) & na->na_type) &&
	    xdr_u_long(xdrs, &na->na_mode) &&
	    xdr_u_long(xdrs, &na->na_nlink) &&
	    xdr_u_long(xdrs, &na->na_uid) &&
	    xdr_u_long(xdrs, &na->na_gid) &&
	    xdr_u_long(xdrs, &na->na_size) &&
	    xdr_u_long(xdrs, &na->na_blocksize) &&
	    xdr_u_long(xdrs, &na->na_rdev) &&
	    xdr_u_long(xdrs, &na->na_blocks) &&
	    xdr_u_long(xdrs, &na->na_fsid) &&
	    xdr_u_long(xdrs, &na->na_nodeid) &&
	    xdr_timeval(xdrs, &na->na_atime) &&
	    xdr_timeval(xdrs, &na->na_mtime) &&
	    xdr_timeval(xdrs, &na->na_ctime)) {
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_fattr: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

/*
 * Arguments to remote read
 */
bool_t
xdr_readargs(xdrs, ra)
	XDR            *xdrs;
	struct nfsreadargs *ra;
{

	if (xdr_fhandle(xdrs, &ra->ra_fhandle) &&
	    xdr_long(xdrs, (long *) &ra->ra_offset) &&
	    xdr_long(xdrs, (long *) &ra->ra_count) &&
	    xdr_long(xdrs, (long *) &ra->ra_totcount)) {
#ifdef TFSDEBUG
		dprint(tfsdebug, 6, "xdr_readargs: %s off %d ct %d\n",
		       xdropnames[(int) xdrs->x_op],
		       ra->ra_offset, ra->ra_totcount);
#endif
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_raedargs: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}


/*
 * Status OK portion of remote read reply
 */
bool_t
xdr_rrok(xdrs, rrok)
	XDR            *xdrs;
	struct nfsrrok *rrok;
{

	if (xdr_fattr(xdrs, &rrok->rrok_attr)) {
		if (xdrs->x_op == XDR_ENCODE && rrok->RROK_MAP) {
		} else {		/* client side */
			if (xdr_bytes(xdrs, &rrok->rrok_data,
				 (u_int *) & rrok->rrok_count, NFS_MAXDATA)) {
#ifdef TFSDEBUG
				dprint(tfsdebug, 6, "xdr_rrok: %s %d addr %x\n",
				       xdropnames[(int) xdrs->x_op],
				       rrok->rrok_count, rrok->rrok_data);
#endif
				return (TRUE);
			}
		}
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_rrok: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

struct xdr_discrim rdres_discrim[2] = {
				       {(int) NFS_OK, xdr_rrok},
				       {__dontcare__, NULL_xdrproc_t}
};

/*
 * Reply from remote read
 */
bool_t
xdr_rdresult(xdrs, rr)
	XDR            *xdrs;
	struct nfsrdresult *rr;
{

#ifdef TFSDEBUG
	dprint(tfsdebug, 6, "xdr_rdresult: %s\n", xdropnames[(int) xdrs->x_op]);
#endif
	if (xdr_union(xdrs, (enum_t *) & (rr->rr_status),
		      (caddr_t) & (rr->rr_ok), rdres_discrim, xdr_void)) {
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_rdresult: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

/*
 * File attributes which can be set
 */
bool_t
xdr_sattr(xdrs, sa)
	XDR            *xdrs;
	struct nfssattr *sa;
{

	if (xdr_u_long(xdrs, &sa->sa_mode) &&
	    xdr_u_long(xdrs, &sa->sa_uid) &&
	    xdr_u_long(xdrs, &sa->sa_gid) &&
	    xdr_u_long(xdrs, &sa->sa_size) &&
	    xdr_timeval(xdrs, &sa->sa_atime) &&
	    xdr_timeval(xdrs, &sa->sa_mtime)) {
#ifdef TFSDEBUG
		dprint(tfsdebug, 6,
		       "xdr_sattr: %s mode %o uid %d gid %d size %d\n",
		       xdropnames[(int) xdrs->x_op], sa->sa_mode, sa->sa_uid,
		       sa->sa_gid, sa->sa_size);
#endif
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_sattr: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

struct xdr_discrim attrstat_discrim[2] = {
					  {(int) NFS_OK, xdr_fattr},
					  {__dontcare__, NULL_xdrproc_t}
};

/*
 * Reply status with file attributes
 */
bool_t
xdr_attrstat(xdrs, ns)
	XDR            *xdrs;
	struct nfsattrstat *ns;
{

	if (xdr_union(xdrs, (enum_t *) & (ns->ns_status),
		      (caddr_t) & (ns->ns_attr), attrstat_discrim, xdr_void)) {
#ifdef TFSDEBUG
		dprint(tfsdebug, 6, "xdr_attrstat: %s stat %d\n",
		       xdropnames[(int) xdrs->x_op], ns->ns_status);
#endif
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_attrstat: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

/*
 * NFS_OK part of read sym link reply union
 */
bool_t
xdr_srok(xdrs, srok)
	XDR            *xdrs;
	struct nfssrok *srok;
{

	if (xdr_bytes(xdrs, &srok->srok_data, (u_int *) & srok->srok_count,
		      NFS_MAXPATHLEN)) {
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_srok: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

struct xdr_discrim rdlnres_discrim[2] = {
					 {(int) NFS_OK, xdr_srok},
					 {__dontcare__, NULL_xdrproc_t}
};

/*
 * Result of reading symbolic link
 */
bool_t
xdr_rdlnres(xdrs, rl)
	XDR            *xdrs;
	struct nfsrdlnres *rl;
{

#ifdef TFSDEBUG
	dprint(tfsdebug, 6, "xdr_rdlnres: %s\n", xdropnames[(int) xdrs->x_op]);
#endif
	if (xdr_union(xdrs, (enum_t *) & (rl->rl_status),
		      (caddr_t) & (rl->rl_srok), rdlnres_discrim, xdr_void)) {
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_rdlnres: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

/*
 * Arguments to readdir
 */
bool_t
xdr_rddirargs(xdrs, rda)
	XDR            *xdrs;
	struct nfsrddirargs *rda;
{

	if (xdr_fhandle(xdrs, &rda->rda_fh) &&
	    xdr_u_long(xdrs, &rda->rda_offset) &&
	    xdr_u_long(xdrs, &rda->rda_count)) {
#ifdef TFSDEBUG
		dprint(tfsdebug, 6,
		       "xdr_rddirargs: %s fh %d, off %d, cnt %d\n",
		       xdropnames[(int) xdrs->x_op],
		       TFS_FH(&rda->rda_fh)->fh_id, rda->rda_offset,
		       rda->rda_count);
#endif
		return (TRUE);
	}
#ifdef TFSDEBUG
	dprint(tfsdebug, 2, "xdr_rddirargs: %s FAILED\n",
	       xdropnames[(int) xdrs->x_op]);
#endif
	return (FALSE);
}

/*
 * Directory read reply:
 * union (enum status) {
 *	NFS_OK: entlist;
 *		boolean eof;
 *	default:
 * }
 *
 * Directory entries
 *	struct  direct {
 *		u_long  d_fileno;	       * inode number of entry *
 *		u_short d_reclen;	       * length of this record *
 *		u_short d_namlen;	       * length of string in d_name *
 *		char    d_name[MAXNAMLEN + 1];  * name no longer than this *
 *	};
 * are on the wire as:
 * union entlist (boolean valid) {
 * 	TRUE: struct dirent;
 *	      u_long nxtoffset;
 * 	      union entlist;
 *	FALSE:
 * }
 * where dirent is:
 * 	struct dirent {
 *		u_long	de_fid;
 *		string	de_name<NFS_MAXNAMELEN>;
 *	}
 */

#define	nextdp(udp)	((struct udirect *)((int)(udp) + (udp)->d_reclen))

/*
 * ENCODE ONLY
 */
bool_t
xdr_putrddirres(xdrs, rd)
	XDR            *xdrs;
	struct nfsreaddirres *rd;
{
	struct udirect *udp;
	char           *name;
	int             size;
	int             xdrpos;
	u_int           namlen;
	u_long          offset;
	bool_t          true = TRUE;
	bool_t          false = FALSE;

#ifdef TFSDEBUG
	dprint(tfsdebug, 6, "xdr_putrddirres: %s size %d offset %d\n",
	       xdropnames[(int) xdrs->x_op], rd->rd_size, rd->rd_offset);
#endif
	if (xdrs->x_op != XDR_ENCODE) {
		return (FALSE);
	}
	if (!xdr_enum(xdrs, (enum_t *) & rd->rd_status)) {