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