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