← Back to branch summary

~ubuntu-branches/ubuntu/karmic/scilab/karmic

« back to all changes in this revision

Viewing changes to pvm3/xdr/xdr_mem.c

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2002-03-21 16:57:43 UTC
  • Revision ID: james.westby@ubuntu.com-20020321165743-e9mv12c1tb1plztg
Tags: upstream-2.6
Import upstream version 2.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
pvm3/xdr/xdr_mem.c
 
1
/* @(#)xdr_mem.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_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro";
 
32
#endif
 
33
 
 
34
/*
 
35
 * xdr_mem.h, XDR implementation using memory buffers.
 
36
 *
 
37
 * Copyright (C) 1984, Sun Microsystems, Inc.
 
38
 *
 
39
 * If you have some data to be interpreted as external data representation
 
40
 * or to be converted to external data representation in a memory buffer,
 
41
 * then this is the package for you.
 
42
 *
 
43
 */
 
44
 
 
45
 
 
46
#ifdef WIN32
 
47
#define bcopy(a,b,c) memcpy(a,b,c)
 
48
#include <winsock.h>
 
49
 
 
50
#include "..\xdr\types.h"
 
51
#include "..\xdr\xdr.h"
 
52
#else
 
53
#include <rpc/types.h>
 
54
#include <rpc/xdr.h>
 
55
#include <netinet/in.h>
 
56
#endif
 
57
 
 
58
static bool_t   xdrmem_getlong();
 
59
static bool_t   xdrmem_putlong();
 
60
static bool_t   xdrmem_getbytes();
 
61
static bool_t   xdrmem_putbytes();
 
62
static u_int    xdrmem_getpos();
 
63
static bool_t   xdrmem_setpos();
 
64
static long *   xdrmem_inline();
 
65
static void     xdrmem_destroy();
 
66
 
 
67
static struct   xdr_ops xdrmem_ops = {
 
68
        xdrmem_getlong,
 
69
        xdrmem_putlong,
 
70
        xdrmem_getbytes,
 
71
        xdrmem_putbytes,
 
72
        xdrmem_getpos,
 
73
        xdrmem_setpos,
 
74
        xdrmem_inline,
 
75
        xdrmem_destroy
 
76
};
 
77
 
 
78
/*
 
79
 * The procedure xdrmem_create initializes a stream descriptor for a
 
80
 * memory buffer.  
 
81
 */
 
82
void
 
83
xdrmem_create(xdrs, addr, size, op)
 
84
        register XDR *xdrs;
 
85
        caddr_t addr;
 
86
        u_int size;
 
87
        enum xdr_op op;
 
88
{
 
89
 
 
90
        xdrs->x_op = op;
 
91
        xdrs->x_ops = &xdrmem_ops;
 
92
        xdrs->x_private = xdrs->x_base = addr;
 
93
        xdrs->x_handy = size;
 
94
}
 
95
 
 
96
static void
 
97
xdrmem_destroy(/*xdrs*/)
 
98
        /*XDR *xdrs;*/
 
99
{
 
100
}
 
101
 
 
102
static bool_t
 
103
xdrmem_getlong(xdrs, lp)
 
104
        register XDR *xdrs;
 
105
        long *lp;
 
106
{
 
107
 
 
108
        if ((xdrs->x_handy -= sizeof(long)) < 0)
 
109
                return (FALSE);
 
110
        *lp = (long)ntohl((u_long)(*((long *)(xdrs->x_private))));
 
111
        xdrs->x_private += sizeof(long);
 
112
        return (TRUE);
 
113
}
 
114
 
 
115
static bool_t
 
116
xdrmem_putlong(xdrs, lp)
 
117
        register XDR *xdrs;
 
118
        long *lp;
 
119
{
 
120
 
 
121
        if ((xdrs->x_handy -= sizeof(long)) < 0)
 
122
                return (FALSE);
 
123
        *(long *)xdrs->x_private = (long)htonl((u_long)(*lp));
 
124
        xdrs->x_private += sizeof(long);
 
125
        return (TRUE);
 
126
}
 
127
 
 
128
static bool_t
 
129
xdrmem_getbytes(xdrs, addr, len)
 
130
        register XDR *xdrs;
 
131
        caddr_t addr;
 
132
        register u_int len;
 
133
{
 
134
 
 
135
        if ((xdrs->x_handy -= len) < 0)
 
136
                return (FALSE);
 
137
        bcopy(xdrs->x_private, addr, len);
 
138
        xdrs->x_private += len;
 
139
        return (TRUE);
 
140
}
 
141
 
 
142
static bool_t
 
143
xdrmem_putbytes(xdrs, addr, len)
 
144
        register XDR *xdrs;
 
145
        caddr_t addr;
 
146
        register u_int len;
 
147
{
 
148
 
 
149
        if ((xdrs->x_handy -= len) < 0)
 
150
                return (FALSE);
 
151
        bcopy(addr, xdrs->x_private, len);
 
152
        xdrs->x_private += len;
 
153
        return (TRUE);
 
154
}
 
155
 
 
156
static u_int
 
157
xdrmem_getpos(xdrs)
 
158
        register XDR *xdrs;
 
159
{
 
160
 
 
161
        return ((u_int)xdrs->x_private - (u_int)xdrs->x_base);
 
162
}
 
163
 
 
164
static bool_t
 
165
xdrmem_setpos(xdrs, pos)
 
166
        register XDR *xdrs;
 
167
        u_int pos;
 
168
{
 
169
        register caddr_t newaddr = xdrs->x_base + pos;
 
170
        register caddr_t lastaddr = xdrs->x_private + xdrs->x_handy;
 
171
 
 
172
        if ((long)newaddr > (long)lastaddr)
 
173
                return (FALSE);
 
174
        xdrs->x_private = newaddr;
 
175
        xdrs->x_handy = (int)lastaddr - (int)newaddr;
 
176
        return (TRUE);
 
177
}
 
178
 
 
179
static long *
 
180
xdrmem_inline(xdrs, len)
 
181
        register XDR *xdrs;
 
182
        int len;
 
183
{
 
184
        long *buf = 0;
 
185
 
 
186
        if (xdrs->x_handy >= len) {
 
187
                xdrs->x_handy -= len;
 
188
                buf = (long *) xdrs->x_private;
 
189
                xdrs->x_private += len;
 
190
        }
 
191
        return (buf);
 
192
}