OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [librpc/] [include/] [rpc/] [clnt.h] - Blame information for rev 30

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 30 unneback
/*
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, MERCHANTABILITY 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
 *      from: @(#)clnt.h 1.31 88/02/08 SMI
30
 *      from: @(#)clnt.h        2.1 88/07/29 4.0 RPCSRC
31
 * $FreeBSD: src/include/rpc/clnt.h,v 1.11 1999/08/27 23:45:03 peter Exp $
32
 */
33
 
34
/*
35
 * clnt.h - Client side remote procedure call interface.
36
 *
37
 * Copyright (C) 1984, Sun Microsystems, Inc.
38
 */
39
 
40
#ifndef _RPC_CLNT_H_
41
#define _RPC_CLNT_H_
42
#include <sys/cdefs.h>
43
#include <sys/un.h>
44
 
45
/*
46
 * Rpc calls return an enum clnt_stat.  This should be looked at more,
47
 * since each implementation is required to live with this (implementation
48
 * independent) list of errors.
49
 */
50
enum clnt_stat {
51
        RPC_SUCCESS=0,                   /* call succeeded */
52
        /*
53
         * local errors
54
         */
55
        RPC_CANTENCODEARGS=1,           /* can't encode arguments */
56
        RPC_CANTDECODERES=2,            /* can't decode results */
57
        RPC_CANTSEND=3,                 /* failure in sending call */
58
        RPC_CANTRECV=4,                 /* failure in receiving result */
59
        RPC_TIMEDOUT=5,                 /* call timed out */
60
        /*
61
         * remote errors
62
         */
63
        RPC_VERSMISMATCH=6,             /* rpc versions not compatible */
64
        RPC_AUTHERROR=7,                /* authentication error */
65
        RPC_PROGUNAVAIL=8,              /* program not available */
66
        RPC_PROGVERSMISMATCH=9,         /* program version mismatched */
67
        RPC_PROCUNAVAIL=10,             /* procedure unavailable */
68
        RPC_CANTDECODEARGS=11,          /* decode arguments error */
69
        RPC_SYSTEMERROR=12,             /* generic "other problem" */
70
 
71
        /*
72
         * callrpc & clnt_create errors
73
         */
74
        RPC_UNKNOWNHOST=13,             /* unknown host name */
75
        RPC_UNKNOWNPROTO=17,            /* unkown protocol */
76
 
77
        /*
78
         * _ create errors
79
         */
80
        RPC_PMAPFAILURE=14,             /* the pmapper failed in its call */
81
        RPC_PROGNOTREGISTERED=15,       /* remote program is not registered */
82
        /*
83
         * unspecified error
84
         */
85
        RPC_FAILED=16
86
};
87
 
88
 
89
/*
90
 * Error info.
91
 */
92
struct rpc_err {
93
        enum clnt_stat re_status;
94
        union {
95
                int RE_errno;           /* related system error */
96
                enum auth_stat RE_why;  /* why the auth error occurred */
97
                struct {
98
                        u_int32_t low;  /* lowest verion supported */
99
                        u_int32_t high; /* highest verion supported */
100
                } RE_vers;
101
                struct {                /* maybe meaningful if RPC_FAILED */
102
                        int32_t s1;
103
                        int32_t s2;
104
                } RE_lb;                /* life boot & debugging only */
105
        } ru;
106
#define re_errno        ru.RE_errno
107
#define re_why          ru.RE_why
108
#define re_vers         ru.RE_vers
109
#define re_lb           ru.RE_lb
110
};
111
 
112
 
113
/*
114
 * Client rpc handle.
115
 * Created by individual implementations, see e.g. rpc_udp.c.
116
 * Client is responsible for initializing auth, see e.g. auth_none.c.
117
 */
118
typedef struct __rpc_client {
119
        AUTH    *cl_auth;                       /* authenticator */
120
        struct clnt_ops {
121
                /* call remote procedure */
122
                enum clnt_stat  (*cl_call) __P((struct __rpc_client *,
123
                                        u_long, xdrproc_t, caddr_t, xdrproc_t,
124
                                        caddr_t, struct timeval));
125
                /* abort a call */
126
                void            (*cl_abort) __P((struct __rpc_client *));
127
                /* get specific error code */
128
                void            (*cl_geterr) __P((struct __rpc_client *,
129
                                        struct rpc_err *));
130
                /* frees results */
131
                bool_t          (*cl_freeres) __P((struct __rpc_client *,
132
                                        xdrproc_t, caddr_t));
133
                /* destroy this structure */
134
                void            (*cl_destroy) __P((struct __rpc_client *));
135
                /* the ioctl() of rpc */
136
                bool_t          (*cl_control) __P((struct __rpc_client *, u_int,
137
                                        void *));
138
        } *cl_ops;
139
        caddr_t                 cl_private;     /* private stuff */
140
} CLIENT;
141
 
142
 
143
/*
144
 * client side rpc interface ops
145
 *
146
 * Parameter types are:
147
 *
148
 */
149
 
150
/*
151
 * enum clnt_stat
152
 * CLNT_CALL(rh, proc, xargs, argsp, xres, resp, timeout)
153
 *      CLIENT *rh;
154
 *      u_long proc;
155
 *      xdrproc_t xargs;
156
 *      caddr_t argsp;
157
 *      xdrproc_t xres;
158
 *      caddr_t resp;
159
 *      struct timeval timeout;
160
 */
161
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)     \
162
        ((*(rh)->cl_ops->cl_call)(rh, proc, xargs, (caddr_t)argsp, \
163
                xres, (caddr_t)resp, secs))
164
#define clnt_call(rh, proc, xargs, argsp, xres, resp, secs)     \
165
        ((*(rh)->cl_ops->cl_call)(rh, proc, xargs, (caddr_t)argsp, \
166
                xres, (caddr_t)resp, secs))
167
 
168
/*
169
 * void
170
 * CLNT_ABORT(rh);
171
 *      CLIENT *rh;
172
 */
173
#define CLNT_ABORT(rh)  ((*(rh)->cl_ops->cl_abort)(rh))
174
#define clnt_abort(rh)  ((*(rh)->cl_ops->cl_abort)(rh))
175
 
176
/*
177
 * struct rpc_err
178
 * CLNT_GETERR(rh);
179
 *      CLIENT *rh;
180
 */
181
#define CLNT_GETERR(rh,errp)    ((*(rh)->cl_ops->cl_geterr)(rh, errp))
182
#define clnt_geterr(rh,errp)    ((*(rh)->cl_ops->cl_geterr)(rh, errp))
183
 
184
 
185
/*
186
 * bool_t
187
 * CLNT_FREERES(rh, xres, resp);
188
 *      CLIENT *rh;
189
 *      xdrproc_t xres;
190
 *      caddr_t resp;
191
 */
192
#define CLNT_FREERES(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
193
#define clnt_freeres(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
194
 
195
/*
196
 * bool_t
197
 * CLNT_CONTROL(cl, request, info)
198
 *      CLIENT *cl;
199
 *      u_int request;
200
 *      char *info;
201
 */
202
#define CLNT_CONTROL(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
203
#define clnt_control(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
204
 
205
/*
206
 * control operations that apply to udp, tcp and unix transports
207
 *
208
 * Note: options marked XXX are no-ops in this implementation of RPC.
209
 * The are present in TI-RPC but can't be implemented here since they
210
 * depend on the presence of STREAMS/TLI, which we don't have.
211
 *
212
 */
213
#define CLSET_TIMEOUT       1   /* set timeout (timeval) */
214
#define CLGET_TIMEOUT       2   /* get timeout (timeval) */
215
#define CLGET_SERVER_ADDR   3   /* get server's address (sockaddr) */
216
#define CLGET_FD            6   /* get connections file descriptor */
217
#define CLGET_SVC_ADDR      7   /* get server's address (netbuf)         XXX */
218
#define CLSET_FD_CLOSE      8   /* close fd while clnt_destroy */
219
#define CLSET_FD_NCLOSE     9   /* Do not close fd while clnt_destroy */
220
#define CLGET_XID           10  /* Get xid */
221
#define CLSET_XID           11  /* Set xid */
222
#define CLGET_VERS          12  /* Get version number */
223
#define CLSET_VERS          13  /* Set version number */
224
#define CLGET_PROG          14  /* Get program number */
225
#define CLSET_PROG          15  /* Set program number */
226
#define CLSET_SVC_ADDR      16  /* get server's address (netbuf)         XXX */
227
#define CLSET_PUSH_TIMOD    17  /* push timod if not already present     XXX */
228
#define CLSET_POP_TIMOD     18  /* pop timod                             XXX */
229
 
230
/*
231
 * udp only control operations
232
 */
233
#define CLSET_RETRY_TIMEOUT 4   /* set retry timeout (timeval) */
234
#define CLGET_RETRY_TIMEOUT 5   /* get retry timeout (timeval) */
235
 
236
/*
237
 * Operations which GSSAPI needs. (Bletch.)
238
 */
239
#define CLGET_LOCAL_ADDR    19  /* get local addr (sockaddr) */
240
 
241
 
242
/*
243
 * void
244
 * CLNT_DESTROY(rh);
245
 *      CLIENT *rh;
246
 */
247
#define CLNT_DESTROY(rh)        ((*(rh)->cl_ops->cl_destroy)(rh))
248
#define clnt_destroy(rh)        ((*(rh)->cl_ops->cl_destroy)(rh))
249
 
250
 
251
/*
252
 * RPCTEST is a test program which is accessible on every rpc
253
 * transport/port.  It is used for testing, performance evaluation,
254
 * and network administration.
255
 */
256
 
257
#define RPCTEST_PROGRAM         ((u_long)1)
258
#define RPCTEST_VERSION         ((u_long)1)
259
#define RPCTEST_NULL_PROC       ((u_long)2)
260
#define RPCTEST_NULL_BATCH_PROC ((u_long)3)
261
 
262
/*
263
 * By convention, procedure 0 takes null arguments and returns them
264
 */
265
 
266
#define NULLPROC ((u_long)0)
267
 
268
/*
269
 * Below are the client handle creation routines for the various
270
 * implementations of client side rpc.  They can return NULL if a
271
 * creation failure occurs.
272
 */
273
 
274
/*
275
 * Memory based rpc (for speed check and testing)
276
 * CLIENT *
277
 * clntraw_create(prog, vers)
278
 *      u_long prog;
279
 *      u_long vers;
280
 */
281
__BEGIN_DECLS
282
extern CLIENT *clntraw_create   __P((u_long, u_long));
283
__END_DECLS
284
 
285
 
286
/*
287
 * Generic client creation routine. Supported protocols are "udp", "tcp"
288
 * and "unix".
289
 * CLIENT *
290
 * clnt_create(host, prog, vers, prot);
291
 *      char *host;     -- hostname
292
 *      u_long prog;    -- program number
293
 *      u_long vers;    -- version number
294
 *      char *prot;     -- protocol
295
 */
296
__BEGIN_DECLS
297
extern CLIENT *clnt_create      __P((char *, u_long, u_long, char *));
298
__END_DECLS
299
 
300
 
301
/*
302
 * TCP based rpc
303
 * CLIENT *
304
 * clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz)
305
 *      struct sockaddr_in *raddr;
306
 *      u_long prog;
307
 *      u_long version;
308
 *      register int *sockp;
309
 *      u_int sendsz;
310
 *      u_int recvsz;
311
 */
312
__BEGIN_DECLS
313
extern CLIENT *clnttcp_create   __P((struct sockaddr_in *,
314
                                     u_long,
315
                                     u_long,
316
                                     int *,
317
                                     u_int,
318
                                     u_int));
319
__END_DECLS
320
 
321
 
322
/*
323
 * UDP based rpc.
324
 * CLIENT *
325
 * clntudp_create(raddr, program, version, wait, sockp)
326
 *      struct sockaddr_in *raddr;
327
 *      u_long program;
328
 *      u_long version;
329
 *      struct timeval wait;
330
 *      int *sockp;
331
 *
332
 * Same as above, but you specify max packet sizes.
333
 * CLIENT *
334
 * clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz)
335
 *      struct sockaddr_in *raddr;
336
 *      u_long program;
337
 *      u_long version;
338
 *      struct timeval wait;
339
 *      int *sockp;
340
 *      u_int sendsz;
341
 *      u_int recvsz;
342
 */
343
__BEGIN_DECLS
344
extern CLIENT *clntudp_create   __P((struct sockaddr_in *,
345
                                     u_long,
346
                                     u_long,
347
                                     struct timeval,
348
                                     int *));
349
extern CLIENT *clntudp_bufcreate __P((struct sockaddr_in *,
350
                                     u_long,
351
                                     u_long,
352
                                     struct timeval,
353
                                     int *,
354
                                     u_int,
355
                                     u_int));
356
__END_DECLS
357
 
358
 
359
/*
360
 * AF_UNIX based rpc
361
 * CLIENT *
362
 * clntunix_create(raddr, prog, vers, sockp, sendsz, recvsz)
363
 *      struct sockaddr_un *raddr;
364
 *      u_long prog;
365
 *      u_long version;
366
 *      register int *sockp;
367
 *      u_int sendsz;
368
 *      u_int recvsz;
369
 */
370
__BEGIN_DECLS
371
extern CLIENT *clntunix_create  __P((struct sockaddr_un *,
372
                                     u_long,
373
                                     u_long,
374
                                     int *,
375
                                     u_int,
376
                                     u_int));
377
__END_DECLS
378
 
379
 
380
/*
381
 * Print why creation failed
382
 */
383
__BEGIN_DECLS
384
extern void clnt_pcreateerror   __P((char *));                  /* stderr */
385
extern char *clnt_spcreateerror __P((char *));                  /* string */
386
__END_DECLS
387
 
388
/*
389
 * Like clnt_perror(), but is more verbose in its output
390
 */
391
__BEGIN_DECLS
392
extern void clnt_perrno         __P((enum clnt_stat));          /* stderr */
393
extern char *clnt_sperrno       __P((enum clnt_stat));          /* string */
394
__END_DECLS
395
 
396
/*
397
 * Print an English error message, given the client error code
398
 */
399
__BEGIN_DECLS
400
extern void clnt_perror         __P((CLIENT *, char *));        /* stderr */
401
extern char *clnt_sperror       __P((CLIENT *, char *));        /* string */
402
__END_DECLS
403
 
404
 
405
/*
406
 * If a creation fails, the following allows the user to figure out why.
407
 */
408
struct rpc_createerr {
409
        enum clnt_stat cf_stat;
410
        struct rpc_err cf_error; /* useful when cf_stat == RPC_PMAPFAILURE */
411
};
412
 
413
extern struct rpc_createerr rpc_createerr;
414
 
415
 
416
#define UDPMSGSIZE      8800    /* rpc imposed limit on udp msg size */
417
#define RPCSMALLMSGSIZE 400     /* a more reasonable packet size */
418
 
419
#endif /* !_RPC_CLNT_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.