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