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
30 /* fixincludes should not add extern "C" to this file */
31 /*
32 * Rpc additions to <sys/types.h>
33 */
34
35 #ifndef RPCXDRTYPES_H
36 #define RPCXDRTYPES_H
37
38 /*
39 * XDR provides a conventional way for converting between C data
40 * types and an external bit-string representation. Library supplied
41 * routines provide for the conversion on built-in C data types. These
42 * routines and utility routines defined here are used to help implement
43 * a type encode/decode routine for each user-defined type.
44 *
45 * Each data type provides a single procedure which takes two arguments:
46 *
47 * bool_t
48 * xdrproc(xdrs, argresp)
49 * XDR *xdrs;
50 * <type> *argresp;
51 *
52 * xdrs is an instance of a XDR handle, to which or from which the data
53 * type is to be converted. argresp is a pointer to the structure to be
54 * converted. The XDR handle contains an operation field which indicates
55 * which of the operations (ENCODE, DECODE * or FREE) is to be performed.
56 *
57 * XDR_DECODE may allocate space if the pointer argresp is null. This
58 * data can be freed with the XDR_FREE operation.
59 *
60 * We write only one procedure per data type to make it easy
61 * to keep the encode and decode procedures for a data type consistent.
62 * In many cases the same code performs all operations on a user defined type,
63 * because all the hard work is done in the component type routines.
64 * decode as a series of calls on the nested data types.
65 */
66
67 #ifdef __cplusplus
68 extern "C" {
69 #endif
70
71 /* The version of ONCRPC supported */
72 #define RPC_MSG_VERSION ((u_long) 2)
73
74 #include <inttypes.h>
75 #include <string.h>
76 #include <pthread.h>
77
78 typedef int bool_t; /* This has to be a long, as it is used for XDR boolean too, which is a 4-byte value */
79 typedef unsigned long rpcprog_t;
80 typedef unsigned long rpcproc_t;
81 typedef unsigned long rpcvers_t;
82 typedef unsigned long rpcprot_t;
83 typedef uint64_t uint64;
84 typedef uint32_t uint32;
85 typedef uint16_t uint16;
86 typedef uint8_t uint8;
87 typedef int32_t int32;
88 typedef int16_t int16;
89 typedef int8_t int8;
90 typedef int32_t enum_t;
91 typedef int64_t quad_t;
92 typedef uint64_t u_quad_t;
93 //typedef uint16_t u_short; /* defined in kernel_headers */
94 #define TRUE 1
95 #define FALSE 0
mem_alloc(size_t size)96 static inline void* mem_alloc(size_t size) { return malloc(size); }
mem_free(void * ptr)97 static inline void mem_free(void* ptr) { free(ptr); }
98
99 /*
100 * Xdr operations. XDR_ENCODE causes the type to be encoded into the
101 * stream. XDR_DECODE causes the type to be extracted from the stream.
102 * XDR_FREE can be used to release the space allocated by an XDR_DECODE
103 * request.
104 */
105 enum xdr_op {
106 XDR_ENCODE = 0,
107 XDR_DECODE = 1,
108 XDR_FREE = 2
109 };
110
111 /*
112 * This is the number of bytes per unit of external data.
113 */
114 #define BYTES_PER_XDR_UNIT (4)
115
116 /*
117 * The XDR handle.
118 * Contains operation which is being applied to the stream,
119 * an operations vector for the particular implementation (e.g. see xdr_mem.c),
120 * and two private fields for the use of the particular implementation.
121 */
122 typedef struct xdr_struct XDR;
123 /*
124 * A xdrproc_t exists for each data type which is to be encoded or decoded.
125 *
126 * The second argument to the xdrproc_t is a pointer to an opaque pointer.
127 * The opaque pointer generally points to a structure of the data type
128 * to be decoded. If this pointer is 0, then the type routines should
129 * allocate dynamic storage of the appropriate size and return it.
130 * bool_t (*xdrproc_t)(XDR *, caddr_t *);
131 */
132 typedef bool_t (*xdrproc_t) (XDR *, void *,...);
133
134
135 #define ONCRPC_CONTROL_GET_MTU (1)
136 #define ONCRPC_CONTROL_GET_TX_QUOTA (2)
137 #define ONCRPC_CONTROL_GET_RX_BUFFER_SIZE (3)
138 #define ONCRPC_CONTROL_REGISTER_SERVER (4)
139 #define ONCRPC_CONTROL_UNREGISTER_SERVER (5)
140 #define ONCRPC_CONTROL_GET_DEST (6)
141 #define ONCRPC_CONTROL_OPEN_XPORT (7)
142 #define ONCRPC_CONTROL_CLOSE_XPORT (8)
143 #define ONCRPC_CONTROL_SET_DEST (9)
144 #define ONCRPC_CONTROL_GET_SOURCE_ADDR (10)
145
146 typedef struct oncrpc_prog_ver_struct
147 {
148 rpcprog_t prog;
149 rpcvers_t ver;
150 void (*dispatch)();
151 } oncrpc_prog_ver_type;
152
153 typedef uint64 oncrpc_addr_type;
154
155 typedef struct {
156 oncrpc_addr_type addr;
157 oncrpc_prog_ver_type prog_ver;
158 } oncrpc_control_get_dest_type;
159
160 typedef struct {
161 oncrpc_addr_type addr;
162 } oncrpc_control_get_source_type;
163
164 typedef struct{
165 oncrpc_prog_ver_type prog_ver;
166 } oncrpc_control_register_server_type;
167
168 typedef struct{
169 oncrpc_prog_ver_type prog_ver;
170 } oncrpc_control_unregister_server_type;
171
172 typedef struct{
173 oncrpc_addr_type dest;
174 } oncrpc_control_set_dest_type;
175
176 typedef struct{
177 unsigned int xp;
178 unsigned int port;
179 } oncrpc_control_open_xport_type;
180
181 #define NULL_xdrproc_t ((xdrproc_t)0)
182
183 /*
184 * Support struct for discriminated unions.
185 * You create an array of xdrdiscrim structures, terminated with
186 * a entry with a null procedure pointer. The xdr_union routine gets
187 * the discriminant value and then searches the array of structures
188 * for a matching value. If a match is found the associated xdr routine
189 * is called to handle that part of the union. If there is
190 * no match, then a default routine may be called.
191 * If there is no match and no default routine it is an error.
192 */
193 struct xdr_discrim
194 {
195 int value;
196 xdrproc_t proc;
197 };
198
199 /* Message enums */
200 typedef enum {
201 RPC_MSG_CALL=0,
202 RPC_MSG_REPLY=1,
203 RPC_MSG_UNDEF = 2,
204 } rpc_msg_e_type;
205
206 typedef enum {
207 RPC_MSG_ACCEPTED=0,
208 RPC_MSG_DENIED=1
209 } rpc_reply_stat_e_type;
210
211 typedef enum {
212 RPC_ACCEPT_SUCCESS = 0,
213 RPC_PROG_UNAVAIL = 1,
214 RPC_PROG_MISMATCH = 2,
215 RPC_PROC_UNAVAIL = 3,
216 RPC_GARBAGE_ARGS = 4,
217 RPC_SYSTEM_ERR = 5,
218 RPC_PROG_LOCKED = 6
219 } rpc_accept_stat_e_type;
220
221 typedef enum {
222 RPC_MISMATCH=0,
223 RPC_AUTH_ERROR=1
224 } rpc_reject_stat_e_type ;
225
226 /* Auth types */
227
228 /*
229 * Status returned from authentication check
230 */
231 typedef enum {
232 AUTH_OK=0,
233 /*
234 * failed at remote end
235 */
236 AUTH_BADCRED=1, /* bogus credentials (seal broken) */
237 AUTH_REJECTEDCRED=2, /* client should begin new session */
238 AUTH_BADVERF=3, /* bogus verifier (seal broken) */
239 AUTH_REJECTEDVERF=4, /* verifier expired or was replayed */
240 AUTH_TOOWEAK=5, /* rejected due to security reasons */
241 /*
242 * failed locally
243 */
244 AUTH_INVALIDRESP=6, /* bogus response verifier */
245 AUTH_FAILED=7 /* some unknown reason */
246 } auth_stat;
247
248 typedef enum {
249 AUTH_NONE =0, /* no authentication */
250 AUTH_NULL =0, /* backward compatibility */
251 AUTH_SYS =1, /* unix style (uid, gids) */
252 AUTH_UNIX =1,
253 AUTH_SHORT =2 /* short hand unix style */
254 } oncrpc_auth_types;
255 /*
256 * Authentication info. Opaque to client.
257 */
258 typedef struct opaque_auth {
259 oncrpc_auth_types oa_flavor; /* flavor of auth */
260 caddr_t oa_base; /* address of more auth stuff */
261 u_int oa_length; /* not to exceed MAX_AUTH_BYTES */
262 } opaque_auth;
263
264 #define MAX_AUTH_BYTES 400
265 #define MAXNETNAMELEN 255 /* maximum length of network user's name */
266
267 /* Error types */
268 /*
269 * Reply header to an rpc request that was accepted by the server.
270 * Note: there could be an error even though the request was
271 * accepted.
272 */
273 struct rpc_accepted_reply_header
274 {
275 opaque_auth verf;
276 rpc_accept_stat_e_type stat;
277 union
278 {
279 struct
280 {
281 uint32 low;
282 uint32 high;
283 } versions;
284 } u;
285 };
286
287 /*
288 * Reply to an rpc request that was denied by the server.
289 */
290 struct rpc_denied_reply
291 {
292 rpc_reject_stat_e_type stat;
293 union
294 {
295 struct
296 {
297 uint32 low;
298 uint32 high;
299 } versions;
300 auth_stat why; /* why authentication did not work */
301 } u;
302 };
303
304 /*
305 * RPC reply header structure. The reply header contains error codes in
306 * case of errors in the server side or the RPC call being rejected.
307 */
308 typedef struct rpc_reply_header
309 {
310 rpc_reply_stat_e_type stat;
311 union
312 {
313 struct rpc_accepted_reply_header ar;
314 struct rpc_denied_reply dr;
315 } u;
316 } rpc_reply_header;
317
318 /* XDR memory wrapper structure */
319 typedef struct oncrpcxdr_mem_struct {
320 struct oncrpcxdr_mem_struct *next;
321
322 #ifdef IMAGE_APPS_PROC
323 /* make structure size 8-bytes so we
324 keep 8-byte alignment */
325 uint32 padding;
326 #endif
327 } oncrpcxdr_mem_s_type;
328
329 // TODO - keep XPORT objects on queue to help track down memory leaks
330
331 /*===========================================================================
332 Defining the XPORT structure
333 ===========================================================================*/
334
335 #define XPORT_FLAG_XPORT_ALLOCED 0x0001
336
337 /*===========================================================================
338 Defining the XDR structure
339 ===========================================================================*/
340
341 typedef struct xdr_struct xdr_s_type;
342
343 /* Call back definition for non-blocking RPC calls */
344 typedef void (*rpc_reply_cb_type)(xdr_s_type *xdr, void *data);
345
346 /* Entry points that must be provided by xdr */
347 struct xdr_ops_struct {
348 /* Transport control functions */
349 void (*xdr_destroy) (xdr_s_type *xdr);
350 bool_t (*xdr_control) (xdr_s_type *xdr, int request, void *info);
351
352 /* Incoming message control functions */
353 bool_t (*read) (xdr_s_type *xdr);
354 bool_t (*msg_done) (xdr_s_type *xdr);
355
356 /* Outgoing message control functions */
357 bool_t (*msg_start) (xdr_s_type *xdr, rpc_msg_e_type rpc_msg_type);
358 bool_t (*msg_abort) (xdr_s_type *xdr);
359 bool_t (*msg_send) (xdr_s_type *xdr);
360
361 /* Message data functions */
362 bool_t (*send_int8) (xdr_s_type *xdr, const int8 *value);
363 bool_t (*send_uint8) (xdr_s_type *xdr, const uint8 *value);
364 bool_t (*send_int16) (xdr_s_type *xdr, const int16 *value);
365 bool_t (*send_uint16) (xdr_s_type *xdr, const uint16 *value);
366 bool_t (*send_int32) (xdr_s_type *xdr, const int32 *value);
367 bool_t (*send_uint32) (xdr_s_type *xdr, const uint32 *value);
368 bool_t (*send_bytes) (xdr_s_type *xdr, const uint8 *buf, uint32 len);
369
370 bool_t (*recv_int8) (xdr_s_type *xdr, int8 *value);
371 bool_t (*recv_uint8) (xdr_s_type *xdr, uint8 *value);
372 bool_t (*recv_int16) (xdr_s_type *xdr, int16 *value);
373 bool_t (*recv_uint16) (xdr_s_type *xdr, uint16 *value);
374 bool_t (*recv_int32) (xdr_s_type *xdr, int32 *value);
375 bool_t (*recv_uint32) (xdr_s_type *xdr, uint32 *value);
376 bool_t (*recv_bytes) (xdr_s_type *xdr, uint8 *buf, uint32 len);
377 };
378
379 typedef struct xdr_ops_struct xdr_ops_s_type;
380
381 /*===========================================================================
382 XDR structure definition - provides a generic interface to each
383 supported transport. The xdr structure is used both for clients and
384 for servers.
385 ===========================================================================*/
386
387 #define RPCROUTER_MSGSIZE_MAX (2048)
388
389 struct xdr_struct {
390 const xdr_ops_s_type *xops;
391 enum xdr_op x_op; /* used for ENCODE and DECODE */
392 uint32 x_prog; /* program number */
393 uint32 x_vers; /* program version */
394 uint32 x_proc; /* for debug output */
395
396 opaque_auth verf; /* verf to send back */
397 uint32 xid;
398 int fd;
399 int is_client;
400
401 /* RPC-call message (if XDR is a client) or RPC-reply message (if
402 XDR is a server). */
403
404 uint8 out_msg[RPCROUTER_MSGSIZE_MAX];
405 int out_next;
406
407 /* Reply message or incoming-call message. For a client XDR, this
408 buffer always contains the reply received in response to an RPC
409 call. For a server XDR, this buffer always contains an incoming
410 RPC call.
411 */
412 uint8 in_msg[RPCROUTER_MSGSIZE_MAX];
413 int in_next;
414 int in_len;
415 };
416
417 // Transport flag definitions
418 #define XDR_FLAG_XDR_ALLOCED 0x0001
419 #define XDR_FLAG_DEDICATED 0x0002
420 #define XDR_FLAG_DESTROYING 0x0004
421 #define XDR_FLAG_RETRY 0x0008
422
423
424 /// @todo FIXME this goes with the callback stuff in oncrpcxdr.c. Move
425 /// elsewhere and pick better symbol names.
426 typedef struct rpc_cb_data_type {
427 void * cb_handler;
428 uint32 cb_id;
429 rpcprot_t protocol;
430 oncrpc_addr_type cb_source;
431 } rpc_cb_data_type;
432
433 #ifdef __cplusplus
434 }
435 #endif
436
437 #endif /* _RPC_XDR_TYPES_H */
438