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