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