home *** CD-ROM | disk | FTP | other *** search
/ Serving the Web / ServingTheWeb1995.disc1of1.iso / linux / slacksrce / d / libc / libc-4.6 / libc-4 / libc-linux / rpc / svc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-29  |  11.3 KB  |  490 lines
  1. /* @(#)svc.c    2.4 88/08/11 4.0 RPCSRC; from 1.44 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. #if !defined(lint) && defined(SCCSIDS)
  31. static char sccsid[] = "@(#)svc.c 1.41 87/10/13 Copyr 1984 Sun Micro";
  32. #endif
  33.  
  34. /*
  35.  * svc.c, Server-side remote procedure call interface.
  36.  *
  37.  * There are two sets of procedures here.  The xprt routines are
  38.  * for handling transport handles.  The svc routines handle the
  39.  * list of service routines.
  40.  *
  41.  * Copyright (C) 1984, Sun Microsystems, Inc.
  42.  */
  43.  
  44. #include <sys/errno.h>
  45. #include <rpc/rpc.h>
  46. #include <rpc/pmap_clnt.h>
  47. #include <strings.h>
  48. #ifdef linux
  49. #include <errno.h>
  50. #include <sys/types.h>
  51. #else
  52. extern int errno;
  53. #endif
  54.  
  55. #ifdef __STDC__
  56. #include <stdlib.h>
  57. #endif
  58.  
  59.  
  60. #ifdef FD_SETSIZE
  61. static SVCXPRT **xports;
  62. #else
  63. #define NOFILE 32
  64.  
  65. static SVCXPRT *xports[NOFILE];
  66. #endif /* def FD_SETSIZE */
  67.  
  68. #define NULL_SVC ((struct svc_callout *)0)
  69. #define    RQCRED_SIZE    400        /* this size is excessive */
  70.  
  71. /*
  72.  * The services list
  73.  * Each entry represents a set of procedures (an rpc program).
  74.  * The dispatch routine takes request structs and runs the
  75.  * apropriate procedure.
  76.  */
  77. static struct svc_callout {
  78.     struct svc_callout *sc_next;
  79.     u_long            sc_prog;
  80.     u_long            sc_vers;
  81.     void            (*sc_dispatch)();
  82. } *svc_head;
  83.  
  84. static struct svc_callout *svc_find();
  85.  
  86. /* ***************  SVCXPRT related stuff **************** */
  87.  
  88. /*
  89.  * Activate a transport handle.
  90.  */
  91. void
  92. xprt_register(xprt)
  93.     SVCXPRT *xprt;
  94. {
  95.     register int sock = xprt->xp_sock;
  96.  
  97. #ifdef FD_SETSIZE
  98.     if (xports == NULL) {
  99.         xports = (SVCXPRT **)
  100.             mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *));
  101.     }
  102.     if (sock < _rpc_dtablesize()) {
  103.         xports[sock] = xprt;
  104.         FD_SET(sock, &svc_fdset);
  105.     }
  106. #else
  107.     if (sock < NOFILE) {
  108.         xports[sock] = xprt;
  109.         svc_fds |= (1 << sock);
  110.     }
  111. #endif /* def FD_SETSIZE */
  112.  
  113. }
  114.  
  115. /*
  116.  * De-activate a transport handle. 
  117.  */
  118. void
  119. xprt_unregister(xprt) 
  120.     SVCXPRT *xprt;
  121. { 
  122.     register int sock = xprt->xp_sock;
  123.  
  124. #ifdef FD_SETSIZE
  125.     if ((sock < _rpc_dtablesize()) && (xports[sock] == xprt)) {
  126.         xports[sock] = (SVCXPRT *)0;
  127.         FD_CLR(sock, &svc_fdset);
  128.     }
  129. #else
  130.     if ((sock < NOFILE) && (xports[sock] == xprt)) {
  131.         xports[sock] = (SVCXPRT *)0;
  132.         svc_fds &= ~(1 << sock);
  133.     }
  134. #endif /* def FD_SETSIZE */
  135. }
  136.  
  137.  
  138. /* ********************** CALLOUT list related stuff ************* */
  139.  
  140. /*
  141.  * Add a service program to the callout list.
  142.  * The dispatch routine will be called when a rpc request for this
  143.  * program number comes in.
  144.  */
  145. bool_t
  146. svc_register(xprt, prog, vers, dispatch, protocol)
  147.     SVCXPRT *xprt;
  148.     u_long prog;
  149.     u_long vers;
  150.     void (*dispatch)();
  151.     u_long protocol;
  152. {
  153.     struct svc_callout *prev;
  154.     register struct svc_callout *s;
  155.  
  156.     if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) {
  157.         if (s->sc_dispatch == dispatch)
  158.             goto pmap_it;  /* he is registering another xptr */
  159.         return (FALSE);
  160.     }
  161.     s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout));
  162.     if (s == (struct svc_callout *)0) {
  163.         return (FALSE);
  164.     }
  165.     s->sc_prog = prog;
  166.     s->sc_vers = vers;
  167.     s->sc_dispatch = dispatch;
  168.     s->sc_next = svc_head;
  169.     svc_head = s;
  170. pmap_it:
  171.     /* now register the information with the local binder service */
  172.     if (protocol) {
  173.         return (pmap_set(prog, vers, protocol, xprt->xp_port));
  174.     }
  175.     return (TRUE);
  176. }
  177.  
  178. /*
  179.  * Remove a service program from the callout list.
  180.  */
  181. void
  182. svc_unregister(prog, vers)
  183.     u_long prog;
  184.     u_long vers;
  185. {
  186.     struct svc_callout *prev;
  187.     register struct svc_callout *s;
  188.  
  189.     if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
  190.         return;
  191.     if (prev == NULL_SVC) {
  192.         svc_head = s->sc_next;
  193.     } else {
  194.         prev->sc_next = s->sc_next;
  195.     }
  196.     s->sc_next = NULL_SVC;
  197.     mem_free((char *) s, (u_int) sizeof(struct svc_callout));
  198.     /* now unregister the information with the local binder service */
  199.     (void)pmap_unset(prog, vers);
  200. }
  201.  
  202. /*
  203.  * Search the callout list for a program number, return the callout
  204.  * struct.
  205.  */
  206. static struct svc_callout *
  207. svc_find(prog, vers, prev)
  208.     u_long prog;
  209.     u_long vers;
  210.     struct svc_callout **prev;
  211. {
  212.     register struct svc_callout *s, *p;
  213.  
  214.     p = NULL_SVC;
  215.     for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  216.         if ((s->sc_prog == prog) && (s->sc_vers == vers))
  217.             goto done;
  218.         p = s;
  219.     }
  220. done:
  221.     *prev = p;
  222.     return (s);
  223. }
  224.  
  225. /* ******************* REPLY GENERATION ROUTINES  ************ */
  226.  
  227. /*
  228.  * Send a reply to an rpc request
  229.  */
  230. bool_t
  231. svc_sendreply(xprt, xdr_results, xdr_location)
  232.     register SVCXPRT *xprt;
  233.     xdrproc_t xdr_results;
  234.     caddr_t xdr_location;
  235. {
  236.     struct rpc_msg rply; 
  237.  
  238.     rply.rm_direction = REPLY;  
  239.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  240.     rply.acpted_rply.ar_verf = xprt->xp_verf; 
  241.     rply.acpted_rply.ar_stat = SUCCESS;
  242.     rply.acpted_rply.ar_results.where = xdr_location;
  243.     rply.acpted_rply.ar_results.proc = xdr_results;
  244.     return (SVC_REPLY(xprt, &rply)); 
  245. }
  246.  
  247. /*
  248.  * No procedure error reply
  249.  */
  250. void
  251. svcerr_noproc(xprt)
  252.     register SVCXPRT *xprt;
  253. {
  254.     struct rpc_msg rply;
  255.  
  256.     rply.rm_direction = REPLY;
  257.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  258.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  259.     rply.acpted_rply.ar_stat = PROC_UNAVAIL;
  260.     SVC_REPLY(xprt, &rply);
  261. }
  262.  
  263. /*
  264.  * Can't decode args error reply
  265.  */
  266. void
  267. svcerr_decode(xprt)
  268.     register SVCXPRT *xprt;
  269. {
  270.     struct rpc_msg rply; 
  271.  
  272.     rply.rm_direction = REPLY; 
  273.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  274.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  275.     rply.acpted_rply.ar_stat = GARBAGE_ARGS;
  276.     SVC_REPLY(xprt, &rply); 
  277. }
  278.  
  279. /*
  280.  * Some system error
  281.  */
  282. void
  283. svcerr_systemerr(xprt)
  284.     register SVCXPRT *xprt;
  285. {
  286.     struct rpc_msg rply; 
  287.  
  288.     rply.rm_direction = REPLY; 
  289.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  290.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  291.     rply.acpted_rply.ar_stat = SYSTEM_ERR;
  292.     SVC_REPLY(xprt, &rply); 
  293. }
  294.  
  295. /*
  296.  * Authentication error reply
  297.  */
  298. void
  299. svcerr_auth(xprt, why)
  300.     SVCXPRT *xprt;
  301.     enum auth_stat why;
  302. {
  303.     struct rpc_msg rply;
  304.  
  305.     rply.rm_direction = REPLY;
  306.     rply.rm_reply.rp_stat = MSG_DENIED;
  307.     rply.rjcted_rply.rj_stat = AUTH_ERROR;
  308.     rply.rjcted_rply.rj_why = why;
  309.     SVC_REPLY(xprt, &rply);
  310. }
  311.  
  312. /*
  313.  * Auth too weak error reply
  314.  */
  315. void
  316. svcerr_weakauth(xprt)
  317.     SVCXPRT *xprt;
  318. {
  319.  
  320.     svcerr_auth(xprt, AUTH_TOOWEAK);
  321. }
  322.  
  323. /*
  324.  * Program unavailable error reply
  325.  */
  326. void 
  327. svcerr_noprog(xprt)
  328.     register SVCXPRT *xprt;
  329. {
  330.     struct rpc_msg rply;  
  331.  
  332.     rply.rm_direction = REPLY;   
  333.     rply.rm_reply.rp_stat = MSG_ACCEPTED;  
  334.     rply.acpted_rply.ar_verf = xprt->xp_verf;  
  335.     rply.acpted_rply.ar_stat = PROG_UNAVAIL;
  336.     SVC_REPLY(xprt, &rply);
  337. }
  338.  
  339. /*
  340.  * Program version mismatch error reply
  341.  */
  342. void  
  343. svcerr_progvers(xprt, low_vers, high_vers)
  344.     register SVCXPRT *xprt; 
  345.     u_long low_vers;
  346.     u_long high_vers;
  347. {
  348.     struct rpc_msg rply;
  349.  
  350.     rply.rm_direction = REPLY;
  351.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  352.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  353.     rply.acpted_rply.ar_stat = PROG_MISMATCH;
  354.     rply.acpted_rply.ar_vers.low = low_vers;
  355.     rply.acpted_rply.ar_vers.high = high_vers;
  356.     SVC_REPLY(xprt, &rply);
  357. }
  358.  
  359. /* ******************* SERVER INPUT STUFF ******************* */
  360.  
  361. /*
  362.  * Get server side input from some transport.
  363.  *
  364.  * Statement of authentication parameters management:
  365.  * This function owns and manages all authentication parameters, specifically
  366.  * the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
  367.  * the "cooked" credentials (rqst->rq_clntcred).
  368.  * However, this function does not know the structure of the cooked
  369.  * credentials, so it make the following assumptions: 
  370.  *   a) the structure is contiguous (no pointers), and
  371.  *   b) the cred structure size does not exceed RQCRED_SIZE bytes. 
  372.  * In all events, all three parameters are freed upon exit from this routine.
  373.  * The storage is trivially management on the call stack in user land, but
  374.  * is mallocated in kernel land.
  375.  */
  376.  
  377. void
  378. svc_getreq(rdfds)
  379.     int rdfds;
  380. {
  381. #ifdef FD_SETSIZE
  382.     fd_set readfds;
  383.  
  384.     FD_ZERO(&readfds);
  385.     readfds.fds_bits[0] = rdfds;
  386.     svc_getreqset(&readfds);
  387. #else
  388.     int readfds = rdfds & svc_fds;
  389.  
  390.     svc_getreqset(&readfds);
  391. #endif /* def FD_SETSIZE */
  392. }
  393.  
  394. void
  395. svc_getreqset(readfds)
  396. #ifdef FD_SETSIZE
  397.     fd_set *readfds;
  398. {
  399. #else
  400.     int *readfds;
  401. {
  402.     int readfds_local = *readfds;
  403. #endif /* def FD_SETSIZE */
  404.     enum xprt_stat stat;
  405.     struct rpc_msg msg;
  406.     int prog_found;
  407.     u_long low_vers;
  408.     u_long high_vers;
  409.     struct svc_req r;
  410.     register SVCXPRT *xprt;
  411.     register u_long mask;
  412.     register int bit;
  413.     register u_long *maskp;
  414.     register int setsize;
  415.     register int sock;
  416.     char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE];
  417.     msg.rm_call.cb_cred.oa_base = cred_area;
  418.     msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
  419.     r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);
  420.  
  421.  
  422. #ifdef FD_SETSIZE
  423.     setsize = _rpc_dtablesize();    
  424.     maskp = (u_long *)readfds->fds_bits;
  425.     for (sock = 0; sock < setsize; sock += NFDBITS) {
  426.         for (mask = *maskp++; bit = ffs(mask); mask ^= (1 << (bit - 1))) {
  427.         /* sock has input waiting */
  428.         xprt = xports[sock + bit - 1];
  429. #else
  430.     for (sock = 0; readfds_local != 0; sock++, readfds_local >>= 1) {
  431.         if ((readfds_local & 1) != 0) {
  432.         /* sock has input waiting */
  433.         xprt = xports[sock];
  434. #endif /* def FD_SETSIZE */
  435.         /* now receive msgs from xprtprt (support batch calls) */
  436.         do {
  437.             if (SVC_RECV(xprt, &msg)) {
  438.  
  439.                 /* now find the exported program and call it */
  440.                 register struct svc_callout *s;
  441.                 enum auth_stat why;
  442.  
  443.                 r.rq_xprt = xprt;
  444.                 r.rq_prog = msg.rm_call.cb_prog;
  445.                 r.rq_vers = msg.rm_call.cb_vers;
  446.                 r.rq_proc = msg.rm_call.cb_proc;
  447.                 r.rq_cred = msg.rm_call.cb_cred;
  448.                 /* first authenticate the message */
  449.                 if ((why= _authenticate(&r, &msg)) != AUTH_OK) {
  450.                     svcerr_auth(xprt, why);
  451.                     goto call_done;
  452.                 }
  453.                 /* now match message with a registered service*/
  454.                 prog_found = FALSE;
  455.                 low_vers = 0 - 1;
  456.                 high_vers = 0;
  457.                 for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  458.                     if (s->sc_prog == r.rq_prog) {
  459.                         if (s->sc_vers == r.rq_vers) {
  460.                             (*s->sc_dispatch)(&r, xprt);
  461.                             goto call_done;
  462.                         }  /* found correct version */
  463.                         prog_found = TRUE;
  464.                         if (s->sc_vers < low_vers)
  465.                             low_vers = s->sc_vers;
  466.                         if (s->sc_vers > high_vers)
  467.                             high_vers = s->sc_vers;
  468.                     }   /* found correct program */
  469.                 }
  470.                 /*
  471.                  * if we got here, the program or version
  472.                  * is not served ...
  473.                  */
  474.                 if (prog_found)
  475.                     svcerr_progvers(xprt,
  476.                     low_vers, high_vers);
  477.                 else
  478.                      svcerr_noprog(xprt);
  479.                 /* Fall through to ... */
  480.             }
  481.         call_done:
  482.             if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
  483.                 SVC_DESTROY(xprt);
  484.                 break;
  485.             }
  486.         } while (stat == XPRT_MOREREQS);
  487.         }
  488.     }
  489. }
  490.