Return to xdr_stdio.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / sunrpc

Annotation of 43BSD/contrib/sunrpc/xdr_stdio.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
        !             3:  * unrestricted use provided that this legend is included on all tape
        !             4:  * media and as a part of the software program in whole or part.  Users
        !             5:  * may copy or modify Sun RPC without charge, but are not authorized
        !             6:  * to license or distribute it to anyone else except as part of a product or
        !             7:  * program developed by the user.
        !             8:  * 
        !             9:  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
        !            10:  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
        !            11:  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
        !            12:  * 
        !            13:  * Sun RPC is provided with no support and without any obligation on the
        !            14:  * part of Sun Microsystems, Inc. to assist in its use, correction,
        !            15:  * modification or enhancement.
        !            16:  * 
        !            17:  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
        !            18:  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
        !            19:  * OR ANY PART THEREOF.
        !            20:  * 
        !            21:  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
        !            22:  * or profits or other special, indirect and consequential damages, even if
        !            23:  * Sun has been advised of the possibility of such damages.
        !            24:  * 
        !            25:  * Sun Microsystems, Inc.
        !            26:  * 2550 Garcia Avenue
        !            27:  * Mountain View, California  94043
        !            28:  */
        !            29: #ifndef lint
        !            30: static char sccsid[] = "@(#)xdr_stdio.c 1.4 85/03/14 Copyr 1984 Sun Micro";
        !            31: #endif
        !            32: 
        !            33: /*
        !            34:  * xdr_stdio.c, XDR implementation on standard i/o file.
        !            35:  *
        !            36:  * Copyright (C) 1984, Sun Microsystems, Inc.
        !            37:  *
        !            38:  * This set of routines implements a XDR on a stdio stream.
        !            39:  * XDR_ENCODE serializes onto the stream, XDR_DECODE de-serializes
        !            40:  * from the stream.
        !            41:  */
        !            42: 
        !            43: #include "types.h"
        !            44: #include <stdio.h>
        !            45: #include "xdr.h"
        !            46: 
        !            47: static bool_t  xdrstdio_getlong();
        !            48: static bool_t  xdrstdio_putlong();
        !            49: static bool_t  xdrstdio_getbytes();
        !            50: static bool_t  xdrstdio_putbytes();
        !            51: static u_int   xdrstdio_getpos();
        !            52: static bool_t  xdrstdio_setpos();
        !            53: static long *  xdrstdio_inline();
        !            54: static void    xdrstdio_destroy();
        !            55: 
        !            56: /*
        !            57:  * Ops vector for stdio type XDR
        !            58:  */
        !            59: static struct xdr_ops  xdrstdio_ops = {
        !            60:        xdrstdio_getlong,       /* deseraialize a long int */
        !            61:        xdrstdio_putlong,       /* seraialize a long int */
        !            62:        xdrstdio_getbytes,      /* deserialize counted bytes */
        !            63:        xdrstdio_putbytes,      /* serialize counted bytes */
        !            64:        xdrstdio_getpos,        /* get offset in the stream */
        !            65:        xdrstdio_setpos,        /* set offset in the stream */
        !            66:        xdrstdio_inline,        /* prime stream for inline macros */
        !            67:        xdrstdio_destroy        /* destroy stream */
        !            68: };
        !            69: 
        !            70: /*
        !            71:  * Initialize a stdio xdr stream.
        !            72:  * Sets the xdr stream handle xdrs for use on the stream file.
        !            73:  * Operation flag is set to op.
        !            74:  */
        !            75: void
        !            76: xdrstdio_create(xdrs, file, op)
        !            77:        register XDR *xdrs;
        !            78:        FILE *file;
        !            79:        enum xdr_op op;
        !            80: {
        !            81: 
        !            82:        xdrs->x_op = op;
        !            83:        xdrs->x_ops = &xdrstdio_ops;
        !            84:        xdrs->x_private = (caddr_t)file;
        !            85:        xdrs->x_handy = 0;
        !            86:        xdrs->x_base = 0;
        !            87: }
        !            88: 
        !            89: /*
        !            90:  * Destroy a stdio xdr stream.
        !            91:  * Cleans up the xdr stream handle xdrs previously set up by xdrstdio_create.
        !            92:  */
        !            93: static void
        !            94: xdrstdio_destroy(xdrs)
        !            95:        register XDR *xdrs;
        !            96: {
        !            97:        (void)fflush((FILE *)xdrs->x_private);
        !            98:        /* xx should we close the file ?? */
        !            99: };
        !           100: 
        !           101: static bool_t
        !           102: xdrstdio_getlong(xdrs, lp)
        !           103:        XDR *xdrs;
        !           104:        register long *lp;
        !           105: {
        !           106: 
        !           107:        if (fread((caddr_t)lp, sizeof(long), 1, (FILE *)xdrs->x_private) != 1)
        !           108:                return (FALSE);
        !           109: #ifndef mc68000
        !           110:        *lp = ntohl(*lp);
        !           111: #endif
        !           112:        return (TRUE);
        !           113: }
        !           114: 
        !           115: static bool_t
        !           116: xdrstdio_putlong(xdrs, lp)
        !           117:        XDR *xdrs;
        !           118:        long *lp;
        !           119: {
        !           120: 
        !           121: #ifndef mc68000
        !           122:        long mycopy = htonl(*lp);
        !           123:        lp = &mycopy;
        !           124: #endif
        !           125:        if (fwrite((caddr_t)lp, sizeof(long), 1, (FILE *)xdrs->x_private) != 1)
        !           126:                return (FALSE);
        !           127:        return (TRUE);
        !           128: }
        !           129: 
        !           130: static bool_t
        !           131: xdrstdio_getbytes(xdrs, addr, len)
        !           132:        XDR *xdrs;
        !           133:        caddr_t addr;
        !           134:        u_int len;
        !           135: {
        !           136: 
        !           137:        if ((len != 0) && (fread(addr, (int)len, 1, (FILE *)xdrs->x_private) != 1))
        !           138:                return (FALSE);
        !           139:        return (TRUE);
        !           140: }
        !           141: 
        !           142: static bool_t
        !           143: xdrstdio_putbytes(xdrs, addr, len)
        !           144:        XDR *xdrs;
        !           145:        caddr_t addr;
        !           146:        u_int len;
        !           147: {
        !           148: 
        !           149:        if ((len != 0) && (fwrite(addr, (int)len, 1, (FILE *)xdrs->x_private) != 1))
        !           150:                return (FALSE);
        !           151:        return (TRUE);
        !           152: }
        !           153: 
        !           154: static u_int
        !           155: xdrstdio_getpos(xdrs)
        !           156:        XDR *xdrs;
        !           157: {
        !           158: 
        !           159:        return ((u_int) ftell((FILE *)xdrs->x_private));
        !           160: }
        !           161: 
        !           162: static bool_t
        !           163: xdrstdio_setpos(xdrs, pos) 
        !           164:        XDR *xdrs;
        !           165:        u_int pos;
        !           166: { 
        !           167: 
        !           168:        return ((fseek((FILE *)xdrs->x_private, (long)pos, 0) < 0) ?
        !           169:                FALSE : TRUE);
        !           170: }
        !           171: 
        !           172: static long *
        !           173: xdrstdio_inline(xdrs, len)
        !           174:        XDR *xdrs;
        !           175:        u_int len;
        !           176: {
        !           177: 
        !           178:        /*
        !           179:         * Must do some work to implement this: must insure
        !           180:         * enough data in the underlying stdio buffer,
        !           181:         * that the buffer is aligned so that we can indirect through a
        !           182:         * long *, and stuff this pointer in xdrs->x_buf.  Doing
        !           183:         * a fread or fwrite to a scratch buffer would defeat
        !           184:         * most of the gains to be had here and require storage
        !           185:         * management on this buffer, so we don't do this.
        !           186:         */
        !           187:        return (NULL);
        !           188: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.