]> CyberLeo.Net >> Repos - FreeBSD/stable/10.git/blob - lib/libc/rpc/svc_simple.c
MFC r368207,368607:
[FreeBSD/stable/10.git] / lib / libc / rpc / svc_simple.c
1 /*      $NetBSD: svc_simple.c,v 1.20 2000/07/06 03:10:35 christos Exp $ */
2
3 /*-
4  * Copyright (c) 2009, Sun Microsystems, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without 
8  * modification, are permitted provided that the following conditions are met:
9  * - Redistributions of source code must retain the above copyright notice, 
10  *   this list of conditions and the following disclaimer.
11  * - Redistributions in binary form must reproduce the above copyright notice, 
12  *   this list of conditions and the following disclaimer in the documentation 
13  *   and/or other materials provided with the distribution.
14  * - Neither the name of Sun Microsystems, Inc. nor the names of its 
15  *   contributors may be used to endorse or promote products derived 
16  *   from this software without specific prior written permission.
17  * 
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
28  * POSSIBILITY OF SUCH DAMAGE.
29  */
30 /*
31  * Copyright (c) 1986-1991 by Sun Microsystems Inc. 
32  */
33
34 /* #pragma ident        "@(#)svc_simple.c       1.18    94/04/24 SMI" */
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
37
38 /*
39  * svc_simple.c
40  * Simplified front end to rpc.
41  */
42
43 /*
44  * This interface creates a virtual listener for all the services
45  * started thru rpc_reg(). It listens on the same endpoint for
46  * all the services and then executes the corresponding service
47  * for the given prognum and procnum.
48  */
49
50 #include "namespace.h"
51 #include "reentrant.h"
52 #include <sys/types.h>
53 #include <rpc/rpc.h>
54 #include <rpc/nettype.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <string.h>
58 #include <err.h>
59 #include "un-namespace.h"
60
61 #include "rpc_com.h"
62 #include "mt_misc.h"
63
64 static void universal(struct svc_req *, SVCXPRT *);
65
66 static struct proglst {
67         char *(*p_progname)(char *);
68         rpcprog_t p_prognum;
69         rpcvers_t p_versnum;
70         rpcproc_t p_procnum;
71         SVCXPRT *p_transp;
72         char *p_netid;
73         char *p_xdrbuf;
74         int p_recvsz;
75         xdrproc_t p_inproc, p_outproc;
76         struct proglst *p_nxt;
77 } *proglst;
78
79 static const char rpc_reg_err[] = "%s: %s";
80 static const char rpc_reg_msg[] = "rpc_reg: ";
81 static const char __reg_err1[] = "can't find appropriate transport";
82 static const char __reg_err2[] = "can't get protocol info";
83 static const char __reg_err3[] = "unsupported transport size";
84 static const char __no_mem_str[] = "out of memory";
85
86 /*
87  * For simplified, easy to use kind of rpc interfaces.
88  * nettype indicates the type of transport on which the service will be
89  * listening. Used for conservation of the system resource. Only one
90  * handle is created for all the services (actually one of each netid)
91  * and same xdrbuf is used for same netid. The size of the arguments
92  * is also limited by the recvsize for that transport, even if it is
93  * a COTS transport. This may be wrong, but for cases like these, they
94  * should not use the simplified interfaces like this.
95  *
96  * prognum - program number
97  * versnum - version number
98  * procnum - procedure number
99  * progname - Server routine
100  * inproc, outproc - in/out XDR procedures
101  * nettype - nettype
102  */
103 int
104 rpc_reg(rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum,
105     char *(*progname)(char *), xdrproc_t inproc, xdrproc_t outproc,
106     char *nettype)
107 {
108         struct netconfig *nconf;
109         int done = FALSE;
110         void *handle;
111
112
113         if (procnum == NULLPROC) {
114                 warnx("%s can't reassign procedure number %u", rpc_reg_msg,
115                         NULLPROC);
116                 return (-1);
117         }
118
119         if (nettype == NULL)
120                 nettype = "netpath";            /* The default behavior */
121         if ((handle = __rpc_setconf(nettype)) == NULL) {
122                 warnx(rpc_reg_err, rpc_reg_msg, __reg_err1);
123                 return (-1);
124         }
125 /* VARIABLES PROTECTED BY proglst_lock: proglst */
126         mutex_lock(&proglst_lock);
127         while ((nconf = __rpc_getconf(handle)) != NULL) {
128                 struct proglst *pl;
129                 SVCXPRT *svcxprt;
130                 int madenow;
131                 u_int recvsz;
132                 char *xdrbuf;
133                 char *netid;
134
135                 madenow = FALSE;
136                 svcxprt = NULL;
137                 recvsz = 0;
138                 xdrbuf = netid = NULL;
139                 for (pl = proglst; pl; pl = pl->p_nxt) {
140                         if (strcmp(pl->p_netid, nconf->nc_netid) == 0) {
141                                 svcxprt = pl->p_transp;
142                                 xdrbuf = pl->p_xdrbuf;
143                                 recvsz = pl->p_recvsz;
144                                 netid = pl->p_netid;
145                                 break;
146                         }
147                 }
148
149                 if (svcxprt == NULL) {
150                         struct __rpc_sockinfo si;
151
152                         svcxprt = svc_tli_create(RPC_ANYFD, nconf, NULL, 0, 0);
153                         if (svcxprt == NULL)
154                                 continue;
155                         if (!__rpc_fd2sockinfo(svcxprt->xp_fd, &si)) {
156                                 warnx(rpc_reg_err, rpc_reg_msg, __reg_err2);
157                                 SVC_DESTROY(svcxprt);
158                                 continue;
159                         }
160                         recvsz = __rpc_get_t_size(si.si_af, si.si_proto, 0);
161                         if (recvsz == 0) {
162                                 warnx(rpc_reg_err, rpc_reg_msg, __reg_err3);
163                                 SVC_DESTROY(svcxprt);
164                                 continue;
165                         }
166                         if (((xdrbuf = malloc((unsigned)recvsz)) == NULL) ||
167                                 ((netid = strdup(nconf->nc_netid)) == NULL)) {
168                                 warnx(rpc_reg_err, rpc_reg_msg, __no_mem_str);
169                                 free(xdrbuf);
170                                 free(netid);
171                                 SVC_DESTROY(svcxprt);
172                                 break;
173                         }
174                         madenow = TRUE;
175                 }
176                 /*
177                  * Check if this (program, version, netid) had already been
178                  * registered.  The check may save a few RPC calls to rpcbind
179                  */
180                 for (pl = proglst; pl; pl = pl->p_nxt)
181                         if ((pl->p_prognum == prognum) &&
182                                 (pl->p_versnum == versnum) &&
183                                 (strcmp(pl->p_netid, netid) == 0))
184                                 break;
185                 if (pl == NULL) { /* Not yet */
186                         (void) rpcb_unset(prognum, versnum, nconf);
187                 } else {
188                         /* so that svc_reg does not call rpcb_set() */
189                         nconf = NULL;
190                 }
191
192                 if (!svc_reg(svcxprt, prognum, versnum, universal, nconf)) {
193                         warnx("%s couldn't register prog %u vers %u for %s",
194                                 rpc_reg_msg, (unsigned)prognum,
195                                 (unsigned)versnum, netid);
196                         if (madenow) {
197                                 SVC_DESTROY(svcxprt);
198                                 free(xdrbuf);
199                                 free(netid);
200                         }
201                         continue;
202                 }
203
204                 pl = malloc(sizeof (struct proglst));
205                 if (pl == NULL) {
206                         warnx(rpc_reg_err, rpc_reg_msg, __no_mem_str);
207                         if (madenow) {
208                                 SVC_DESTROY(svcxprt);
209                                 free(xdrbuf);
210                                 free(netid);
211                         }
212                         break;
213                 }
214                 pl->p_progname = progname;
215                 pl->p_prognum = prognum;
216                 pl->p_versnum = versnum;
217                 pl->p_procnum = procnum;
218                 pl->p_inproc = inproc;
219                 pl->p_outproc = outproc;
220                 pl->p_transp = svcxprt;
221                 pl->p_xdrbuf = xdrbuf;
222                 pl->p_recvsz = recvsz;
223                 pl->p_netid = netid;
224                 pl->p_nxt = proglst;
225                 proglst = pl;
226                 done = TRUE;
227         }
228         __rpc_endconf(handle);
229         mutex_unlock(&proglst_lock);
230
231         if (done == FALSE) {
232                 warnx("%s cant find suitable transport for %s",
233                         rpc_reg_msg, nettype);
234                 return (-1);
235         }
236         return (0);
237 }
238
239 /*
240  * The universal handler for the services registered using registerrpc.
241  * It handles both the connectionless and the connection oriented cases.
242  */
243
244 static void
245 universal(struct svc_req *rqstp, SVCXPRT *transp)
246 {
247         rpcprog_t prog;
248         rpcvers_t vers;
249         rpcproc_t proc;
250         char *outdata;
251         char *xdrbuf;
252         struct proglst *pl;
253
254         /*
255          * enforce "procnum 0 is echo" convention
256          */
257         if (rqstp->rq_proc == NULLPROC) {
258                 if (svc_sendreply(transp, (xdrproc_t) xdr_void, NULL) ==
259                     FALSE) {
260                         warnx("svc_sendreply failed");
261                 }
262                 return;
263         }
264         prog = rqstp->rq_prog;
265         vers = rqstp->rq_vers;
266         proc = rqstp->rq_proc;
267         mutex_lock(&proglst_lock);
268         for (pl = proglst; pl; pl = pl->p_nxt)
269                 if (pl->p_prognum == prog && pl->p_procnum == proc &&
270                         pl->p_versnum == vers &&
271                         (strcmp(pl->p_netid, transp->xp_netid) == 0)) {
272                         /* decode arguments into a CLEAN buffer */
273                         xdrbuf = pl->p_xdrbuf;
274                         /* Zero the arguments: reqd ! */
275                         (void) memset(xdrbuf, 0, (size_t)pl->p_recvsz);
276                         /*
277                          * Assuming that sizeof (xdrbuf) would be enough
278                          * for the arguments; if not then the program
279                          * may bomb. BEWARE!
280                          */
281                         if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) {
282                                 svcerr_decode(transp);
283                                 mutex_unlock(&proglst_lock);
284                                 return;
285                         }
286                         outdata = (*(pl->p_progname))(xdrbuf);
287                         if (outdata == NULL &&
288                                 pl->p_outproc != (xdrproc_t) xdr_void){
289                                 /* there was an error */
290                                 mutex_unlock(&proglst_lock);
291                                 return;
292                         }
293                         if (!svc_sendreply(transp, pl->p_outproc, outdata)) {
294                                 warnx(
295                         "rpc: rpc_reg trouble replying to prog %u vers %u",
296                                 (unsigned)prog, (unsigned)vers);
297                                 mutex_unlock(&proglst_lock);
298                                 return;
299                         }
300                         /* free the decoded arguments */
301                         (void)svc_freeargs(transp, pl->p_inproc, xdrbuf);
302                         mutex_unlock(&proglst_lock);
303                         return;
304                 }
305         mutex_unlock(&proglst_lock);
306         /* This should never happen */
307         warnx("rpc: rpc_reg: never registered prog %u vers %u",
308                 (unsigned)prog, (unsigned)vers);
309         return;
310 }