home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / lan / soss.arj / RPC / SVC.C < prev    next >
C/C++ Source or Header  |  1991-02-22  |  11KB  |  464 lines
  1. /*
  2.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  3.  * unrestricted use provided that this legend is included on all tape
  4.  * media and as a part of the software program in whole or part.  Users
  5.  * may copy or modify Sun RPC without charge, but are not authorized
  6.  * to license or distribute it to anyone else except as part of a product or
  7.  * program developed by the user.
  8.  * 
  9.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  10.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  11.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  12.  * 
  13.  * Sun RPC is provided with no support and without any obligation on the
  14.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  15.  * modification or enhancement.
  16.  * 
  17.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  18.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  19.  * OR ANY PART THEREOF.
  20.  * 
  21.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  22.  * or profits or other special, indirect and consequential damages, even if
  23.  * Sun has been advised of the possibility of such damages.
  24.  * 
  25.  * Sun Microsystems, Inc.
  26.  * 2550 Garcia Avenue
  27.  * Mountain View, California  94043
  28.  */
  29. #ifndef lint
  30. static char sccsid[] = "@(#)svc.c 1.1 86/02/03 Copyr 1984 Sun Micro";
  31. #endif
  32.  
  33. /*
  34.  * svc.c, Server-side remote procedure call interface.
  35.  *
  36.  * There are two sets of procedures here.  The xprt routines are
  37.  * for handling transport handles.  The svc routines handle the
  38.  * list of service routines.
  39.  *
  40.  * Copyright (C) 1984, Sun Microsystems, Inc.
  41.  */
  42. #include "sock.h"
  43. #include "types.h"
  44. #include <errno.h>
  45. #include "in.h"
  46. #include "xdr.h"
  47. #include "auth.h"
  48. #include "clnt.h"
  49. #include "rpc_msg.h"
  50. #include "svc.h"
  51. #include "svc_auth.h"
  52. #include "p_clnt.h"
  53. #include <conio.h>
  54.  
  55. #define NOFILE 32
  56.  
  57. static SVCXPRT *xports[NOFILE];
  58. long svc_fds = 0;
  59. extern errno;
  60. char *malloc();
  61.  
  62. #define NULL_SVC ((struct svc_callout *)0)
  63. #define    RQCRED_SIZE    400
  64.  
  65. /*
  66.  * The services list
  67.  * Each entry represents a set of procedures (an rpc program).
  68.  * The dispatch routine takes request structs and runs the
  69.  * apropriate procedure.
  70.  */
  71. static struct svc_callout {
  72.     struct svc_callout *sc_next;
  73.     u_long            sc_prog;
  74.     u_long            sc_vers;
  75.     void            (*sc_dispatch)();
  76. } *svc_head;
  77.  
  78. static struct svc_callout *svc_find();
  79.  
  80. /* ***************  SVCXPRT related stuff **************** */
  81.  
  82. /*
  83.  * Activate a transport handle.
  84.  */
  85. void
  86. xprt_register(xprt)
  87.     SVCXPRT *xprt;
  88. {
  89.     register int sock = xprt->xp_sock;
  90.  
  91.     if (sock < NOFILE) {
  92.         xports[sock] = xprt;
  93.         svc_fds |= (1 << sock);
  94.     }
  95. }
  96.  
  97. /*
  98.  * De-activate a transport handle. 
  99.  */
  100. void
  101. xprt_unregister(xprt) 
  102.     SVCXPRT *xprt;
  103. { 
  104.     register int sock = xprt->xp_sock;
  105.  
  106.     if ((sock < NOFILE) && (xports[sock] == xprt)) {
  107.         xports[sock] = (SVCXPRT *)0;
  108.         svc_fds &= ~(1L << sock);
  109.     }
  110. } 
  111.  
  112.  
  113. /* ********************** CALLOUT list related stuff ************* */
  114.  
  115. /*
  116.  * Add a service program to the callout list.
  117.  * The dispatch routine will be called when a rpc request for this
  118.  * program number comes in.
  119.  */
  120. bool_t
  121. svc_register(xprt, prog, vers, dispatch, protocol)
  122.     SVCXPRT *xprt;
  123.     u_long prog;
  124.     u_long vers;
  125.     void (*dispatch)();
  126.     int protocol;
  127. {
  128.     struct svc_callout *prev;
  129.     register struct svc_callout *s;
  130.  
  131.     if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) {
  132.         if (s->sc_dispatch == dispatch)
  133.             goto pmap_it;  /* he is registering another xptr */
  134.         return (FALSE);
  135.     }
  136.     s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout));
  137.     if (s == (struct svc_callout *)0) {
  138.         return (FALSE);
  139.     }
  140.     s->sc_prog = prog;
  141.     s->sc_vers = vers;
  142.     s->sc_dispatch = dispatch;
  143.     s->sc_next = svc_head;
  144.     svc_head = s;
  145. pmap_it:
  146.     /* now register the information with the local binder service */
  147.     /* port map service not available on the PC */
  148.         /* See-Mong Tan, 6/14/88 */
  149. /*    if (protocol) {
  150.         return (pmap_set(prog, vers, protocol, xprt->xp_port));
  151.     }
  152. */
  153.     return (TRUE);
  154. }
  155.  
  156. /*
  157.  * Remove a service program from the callout list.
  158.  */
  159. void
  160. svc_unregister(prog, vers)
  161.     u_long prog;
  162.     u_long vers;
  163. {
  164.     struct svc_callout *prev;
  165.     register struct svc_callout *s;
  166.  
  167.     if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
  168.         return;
  169.     if (prev == NULL_SVC) {
  170.         svc_head = s->sc_next;
  171.     } else {
  172.         prev->sc_next = s->sc_next;
  173.     }
  174.     s->sc_next = NULL_SVC;
  175.     mem_free((char *) s, (u_int) sizeof(struct svc_callout));
  176.     /* now unregister the information with the local binder service */
  177. /*    (void)pmap_unset(prog, vers);    */
  178. }
  179.  
  180. /*
  181.  * Search the callout list for a program number, return the callout
  182.  * struct.
  183.  */
  184. static struct svc_callout *
  185. svc_find(prog, vers, prev)
  186.     u_long prog;
  187.     u_long vers;
  188.     struct svc_callout **prev;
  189. {
  190.     register struct svc_callout *s, *p;
  191.  
  192.     p = NULL_SVC;
  193.     for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  194.         if ((s->sc_prog == prog) && (s->sc_vers == vers))
  195.             goto done;
  196.         p = s;
  197.     }
  198. done:
  199.     *prev = p;
  200.     return (s);
  201. }
  202.  
  203. /* ******************* REPLY GENERATION ROUTINES  ************ */
  204.  
  205. /*
  206.  * Send a reply to an rpc request
  207.  */
  208. bool_t
  209. svc_sendreply(xprt, xdr_results, xdr_location)
  210.     register SVCXPRT *xprt;
  211.     xdrproc_t xdr_results;
  212.     caddr_t xdr_location;
  213. {
  214.     struct rpc_msg rply; 
  215.  
  216.     rply.rm_direction = REPLY;  
  217.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  218.     rply.acpted_rply.ar_verf = xprt->xp_verf; 
  219.     rply.acpted_rply.ar_stat = SUCCESS1;
  220.     rply.acpted_rply.ar_results.where = xdr_location;
  221.     rply.acpted_rply.ar_results.proc = xdr_results;
  222.     return (SVC_REPLY(xprt, &rply)); 
  223. }
  224.  
  225. /*
  226.  * No procedure error reply
  227.  */
  228. void
  229. svcerr_noproc(xprt)
  230.     register SVCXPRT *xprt;
  231. {
  232.     struct rpc_msg rply;
  233.  
  234.     rply.rm_direction = REPLY;
  235.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  236.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  237.     rply.acpted_rply.ar_stat = PROC_UNAVAIL;
  238.     SVC_REPLY(xprt, &rply);
  239. }
  240.  
  241. /*
  242.  * Can't decode args error reply
  243.  */
  244. void
  245. svcerr_decode(xprt)
  246.     register SVCXPRT *xprt;
  247. {
  248.     struct rpc_msg rply; 
  249.  
  250.     rply.rm_direction = REPLY; 
  251.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  252.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  253.     rply.acpted_rply.ar_stat = GARBAGE_ARGS;
  254.     SVC_REPLY(xprt, &rply); 
  255. }
  256.  
  257. /*
  258.  * Some system error
  259.  */
  260. void
  261. svcerr_systemerr(xprt)
  262.     register SVCXPRT *xprt;
  263. {
  264.     struct rpc_msg rply; 
  265.  
  266.     rply.rm_direction = REPLY; 
  267.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  268.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  269.     rply.acpted_rply.ar_stat = SYSTEM_ERR;
  270.     SVC_REPLY(xprt, &rply); 
  271. }
  272.  
  273. /*
  274.  * Authentication error reply
  275.  */
  276. void
  277. svcerr_auth(xprt, why)
  278.     SVCXPRT *xprt;
  279.     enum auth_stat why;
  280. {
  281.     struct rpc_msg rply;
  282.  
  283.     rply.rm_direction = REPLY;
  284.     rply.rm_reply.rp_stat = MSG_DENIED;
  285.     rply.rjcted_rply.rj_stat = AUTH_ERROR;
  286.     rply.rjcted_rply.rj_why = why;
  287.     SVC_REPLY(xprt, &rply);
  288. }
  289.  
  290. /*
  291.  * Auth too weak error reply
  292.  */
  293. void
  294. svcerr_weakauth(xprt)
  295.     SVCXPRT *xprt;
  296. {
  297.  
  298.     svcerr_auth(xprt, AUTH_TOOWEAK);
  299. }
  300.  
  301. /*
  302.  * Program unavailable error reply
  303.  */
  304. void 
  305. svcerr_noprog(xprt)
  306.     register SVCXPRT *xprt;
  307. {
  308.     struct rpc_msg rply;  
  309.  
  310.     rply.rm_direction = REPLY;   
  311.     rply.rm_reply.rp_stat = MSG_ACCEPTED;  
  312.     rply.acpted_rply.ar_verf = xprt->xp_verf;  
  313.     rply.acpted_rply.ar_stat = PROG_UNAVAIL;
  314.     SVC_REPLY(xprt, &rply);
  315. }
  316.  
  317. /*
  318.  * Program version mismatch error reply
  319.  */
  320. void  
  321. svcerr_progvers(xprt, low_vers, high_vers)
  322.     register SVCXPRT *xprt; 
  323.     u_long low_vers;
  324.     u_long high_vers;
  325. {
  326.     struct rpc_msg rply;
  327.  
  328.     rply.rm_direction = REPLY;
  329.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  330.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  331.     rply.acpted_rply.ar_stat = PROG_MISMATCH;
  332.     rply.acpted_rply.ar_vers.low = low_vers;
  333.     rply.acpted_rply.ar_vers.high = high_vers;
  334.     SVC_REPLY(xprt, &rply);
  335. }
  336.  
  337. /* ******************* SERVER INPUT STUFF ******************* */
  338.  
  339. /*
  340.  * Get server side input from some transport.
  341.  *
  342.  * Statement of authentication parameters management:
  343.  * This function owns and manages all authentication parameters, specifically
  344.  * the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
  345.  * the "cooked" credentials (rqst->rq_clntcred).  However, this function
  346.  * does not know the structure of the cooked credentials, so it make the
  347.  * following two assumptions: a) the structure is contiguous (no pointers), and
  348.  * b) the structure size does not exceed RQCRED_SIZE bytes. 
  349.  * In all events, all three parameters are freed upon exit from this routine.
  350.  * The storage is trivially management on the call stack in user land, but
  351.  * is mallocated in kernel land.
  352.  */
  353. void
  354. svc_getreq(rdfds)
  355.     long rdfds;
  356. {
  357.     register enum xprt_stat stat;
  358.     struct rpc_msg msg;
  359.     int prog_found;
  360.     u_long low_vers;
  361.     u_long high_vers;
  362.     struct svc_req r;
  363.     register int sock;
  364.     long int readfds = rdfds & svc_fds;
  365.     register SVCXPRT *xprt;
  366.     char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE];
  367.     msg.rm_call.cb_cred.oa_base = cred_area;
  368.     msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
  369.     r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);
  370.  
  371.     for (sock = 0; readfds != 0; sock++, readfds >>= 1L) {
  372.         if ((readfds & 1L) != 0) {
  373.         /* sock has input waiting */
  374.         xprt = xports[sock];
  375.         /* now receive msgs from xprt (support batch calls) */
  376.         do {
  377.             if (SVC_RECV(xprt, &msg)) {
  378.                 /* now find the exported program and call it */
  379.                 register struct svc_callout *s;
  380.                 enum auth_stat why;
  381.  
  382.                 r.rq_xprt = xprt;
  383.                 r.rq_prog = msg.rm_call.cb_prog;
  384.                 r.rq_vers = msg.rm_call.cb_vers;
  385.                 r.rq_proc = msg.rm_call.cb_proc;
  386.                 r.rq_cred = msg.rm_call.cb_cred;
  387.                 /* first authenticate the message */
  388.                 if ((why= _authenticate(&r, &msg)) != AUTH_OK) {
  389.                     svcerr_auth(xprt, why);
  390.                     goto call_done;
  391.                 }
  392.                 /* now match message with a registered service*/
  393.                 prog_found = FALSE;
  394.                 low_vers = 0 - 1;
  395.                 high_vers = 0;
  396.                 for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  397.                     if (s->sc_prog == r.rq_prog) {
  398.                         if (s->sc_vers == r.rq_vers) {
  399.                             (*s->sc_dispatch)(&r, xprt);
  400.                             goto call_done;
  401.                         }  /* found correct version */
  402.                         prog_found = TRUE;
  403.                         if (s->sc_vers < low_vers)
  404.                             low_vers = s->sc_vers;
  405.                         if (s->sc_vers > high_vers)
  406.                             high_vers = s->sc_vers;
  407.                     }   /* found correct program */
  408.                 }
  409.                 /*
  410.                  * if we got here, the program or version
  411.                  * is not served ...
  412.                  */
  413.                 if (prog_found)
  414.                     svcerr_progvers(xprt,
  415.                     low_vers, high_vers);
  416.                 else
  417.                      svcerr_noprog(xprt);
  418.                 /* Fall through to ... */
  419.             }
  420.         call_done:
  421.             if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
  422.                 SVC_DESTROY(xprt);
  423.                 break;
  424.             }
  425.         } while (stat == XPRT_MOREREQS);
  426.         }
  427.     }
  428. }
  429.  
  430.  
  431. /*
  432.  * This is the rpc server side idle loop
  433.  * Wait for input, call server program.
  434.  */
  435. void
  436. svc_run()
  437. {
  438.     long readfds;
  439.  
  440.     while (TRUE) {
  441.         if(kbhit()) {
  442.             if(getch() == 'q') {
  443.             printf("\nTermination requested.\n");
  444.             exit(0);
  445.             }
  446.         }
  447.         readfds = svc_fds;
  448.         switch (sock_select(&readfds, (long *)0)) {
  449.  
  450.         case -1:
  451.             if (errno == EINTR || errno == EWOULDBLOCK)
  452.                 continue;
  453.             else {
  454.                 perror("svc.c: - Select failed");
  455.                 return;
  456.             }
  457.         case 0:
  458.             continue;
  459.         default:
  460.             svc_getreq(readfds);
  461.         }
  462.     }
  463. }
  464.