home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume1 / rpc / part09 < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  55.2 KB
  1. Date: Wed, 3 Apr 85 00:16:07 pst
  2. From: decvax!sun!pumpkinseed!blyon (Bob Lyon)
  3. Subject: Sun RPC part 9 of 10
  4.  
  5. echo x - svc.c
  6. sed 's/^X//' >svc.c <<'!Funky!Stuff!'
  7. /*
  8.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  9.  * unrestricted use provided that this legend is included on all tape
  10.  * media and as a part of the software program in whole or part.  Users
  11.  * may copy or modify Sun RPC without charge, but are not authorized
  12.  * to license or distribute it to anyone else except as part of a product or
  13.  * program developed by the user.
  14.  * 
  15.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  16.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  17.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  18.  * 
  19.  * Sun RPC is provided with no support and without any obligation on the
  20.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  21.  * modification or enhancement.
  22.  * 
  23.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  24.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  25.  * OR ANY PART THEREOF.
  26.  * 
  27.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  28.  * or profits or other special, indirect and consequential damages, even if
  29.  * Sun has been advised of the possibility of such damages.
  30.  * 
  31.  * Sun Microsystems, Inc.
  32.  * 2550 Garcia Avenue
  33.  * Mountain View, California  94043
  34.  */
  35. #ifndef lint
  36. static char sccsid[] = "@(#)svc.c 1.7 85/03/20 Copyr 1984 Sun Micro";
  37. #endif
  38.  
  39. /*
  40.  * svc.c, Server-side remote procedure call interface.
  41.  *
  42.  * There are two sets of procedures here.  The xprt routines are
  43.  * for handling transport handles.  The svc routines handle the
  44.  * list of service routines.
  45.  *
  46.  * Copyright (C) 1984, Sun Microsystems, Inc.
  47.  */
  48.  
  49. #include <stdio.h>
  50. #include "types.h"
  51. #include <sys/errno.h>
  52. #include <netinet/in.h>
  53. #include "xdr.h"
  54. #include "auth.h"
  55. #include "clnt.h"
  56. #include "rpc_msg.h"
  57. #include "svc.h"
  58. #include "svc_auth.h"
  59. #include "pmap_clnt.h"    /* <make kernel depend happy> */
  60.  
  61. #define NOFILE 32
  62.  
  63. static SVCXPRT *xports[NOFILE];
  64. int svc_fds = 0;
  65. extern errno;
  66. char *malloc();
  67.  
  68. #define NULL_SVC ((struct svc_callout *)0)
  69.  
  70. void rpctest_service();
  71.  
  72. /*
  73.  * The services list
  74.  * Each entry represents a set of procedures (an rpc program).
  75.  * The dispatch routine takes request structs and runs the
  76.  * apropriate procedure.
  77.  */
  78. static struct svc_callout {
  79.     struct svc_callout *sc_next;
  80.     u_long            sc_prog;
  81.     u_long            sc_vers;
  82.     void            (*sc_dispatch)();
  83. } *svc_head = NULL_SVC;
  84.  
  85. static struct svc_callout *svc_find();
  86.  
  87. /* ***************  SVCXPRT related stuff **************** */
  88.  
  89. /*
  90.  * Activate a transport handle.
  91.  */
  92. void
  93. xprt_register(xprt)
  94.     SVCXPRT *xprt;
  95. {
  96.     register int sock = xprt->xp_sock;
  97.  
  98.     if (sock < NOFILE) {
  99.         xports[sock] = xprt;
  100.         svc_fds |= (1 << sock);
  101.     }
  102. }
  103.  
  104. /*
  105.  * De-activate a transport handle. 
  106.  */
  107. void
  108. xprt_unregister(xprt) 
  109.     SVCXPRT *xprt;
  110. { 
  111.     register int sock = xprt->xp_sock;
  112.  
  113.     if ((sock < NOFILE) && (xports[sock] == xprt)) {
  114.         xports[sock] = (SVCXPRT *)NULL;
  115.         svc_fds &= ~(1 << sock);
  116.     }
  117. } 
  118.  
  119.  
  120. /* ********************** CALLOUT list related stuff ************* */
  121.  
  122. /*
  123.  * Add a service program to the callout list.
  124.  * The dispatch routine will be called when a rpc request for this
  125.  * program number comes in.
  126.  */
  127. bool_t
  128. svc_register(xprt, prog, vers, dispatch, protocol)
  129.     SVCXPRT *xprt;
  130.     u_long prog;
  131.     u_long vers;
  132.     void (*dispatch)();
  133.     int protocol;
  134. {
  135.     struct svc_callout *prev;
  136.     register struct svc_callout *s;
  137.  
  138.     if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) {
  139.         if (s->sc_dispatch == dispatch)
  140.             goto pmap_it;  /* he is registering another xptr */
  141.         return (FALSE);
  142.     }
  143.     s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout));
  144.     if (s == NULL) {
  145.         fprintf(stderr, "svc_register: out of memory\n");
  146.         return (FALSE);
  147.     }
  148.     s->sc_prog = prog;
  149.     s->sc_vers = vers;
  150.     s->sc_dispatch = dispatch;
  151.     s->sc_next = svc_head;
  152.     svc_head = s;
  153. pmap_it:
  154.     /* now register the information with the local binder service */
  155.     if (protocol) {
  156.         return (pmap_set(prog, vers, protocol, xprt->xp_port));
  157.     }
  158.     return (TRUE);
  159. }
  160.  
  161. /*
  162.  * Remove a service program from the callout list.
  163.  */
  164. void
  165. svc_unregister(prog, vers)
  166.     u_long prog;
  167.     u_long vers;
  168. {
  169.     struct svc_callout *prev;
  170.     register struct svc_callout *s;
  171.  
  172.     if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
  173.         return;
  174.     if (prev == NULL_SVC) {
  175.         svc_head = s->sc_next;
  176.     } else {
  177.         prev->sc_next = s->sc_next;
  178.     }
  179.     s->sc_next = NULL_SVC;
  180.     mem_free(s, sizeof(struct svc_callout));
  181.     /* now unregister the information with the local binder service */
  182.     (void)pmap_unset(prog, vers);
  183. }
  184.  
  185. /*
  186.  * Search the callout list for a program number, return the callout
  187.  * struct.
  188.  */
  189. static struct svc_callout *
  190. svc_find(prog, vers, prev)
  191.     u_long prog;
  192.     u_long vers;
  193.     struct svc_callout **prev;
  194. {
  195.     register struct svc_callout *s, *p;
  196.  
  197.     p = NULL_SVC;
  198.     for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  199.         if ((s->sc_prog == prog) && (s->sc_vers == vers))
  200.             goto done;
  201.         p = s;
  202.     }
  203. done:
  204.     *prev = p;
  205.     return (s);
  206. }
  207.  
  208. /* ******************* REPLY GENERATION ROUTINES  ************ */
  209.  
  210. /*
  211.  * Send a reply to an rpc request
  212.  */
  213. bool_t
  214. svc_sendreply(xprt, xdr_results, xdr_location)
  215.     register SVCXPRT *xprt;
  216.     xdrproc_t xdr_results;
  217.     caddr_t xdr_location;
  218. {
  219.     struct rpc_msg rply; 
  220.  
  221.     rply.rm_direction = REPLY;  
  222.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  223.     rply.acpted_rply.ar_verf = xprt->xp_verf; 
  224.     rply.acpted_rply.ar_stat = SUCCESS;
  225.     rply.acpted_rply.ar_results.where = xdr_location;
  226.     rply.acpted_rply.ar_results.proc = xdr_results;
  227.     return (SVC_REPLY(xprt, &rply)); 
  228. }
  229.  
  230. /*
  231.  * No procedure error reply
  232.  */
  233. void
  234. svcerr_noproc(xprt)
  235.     register SVCXPRT *xprt;
  236. {
  237.     struct rpc_msg rply;
  238.  
  239.     rply.rm_direction = REPLY;
  240.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  241.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  242.     rply.acpted_rply.ar_stat = PROC_UNAVAIL;
  243.     SVC_REPLY(xprt, &rply);
  244. }
  245.  
  246. /*
  247.  * Can't decode args error reply
  248.  */
  249. void
  250. svcerr_decode(xprt)
  251.     register SVCXPRT *xprt;
  252. {
  253.     struct rpc_msg rply; 
  254.  
  255.     rply.rm_direction = REPLY; 
  256.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  257.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  258.     rply.acpted_rply.ar_stat = GARBAGE_ARGS;
  259.     SVC_REPLY(xprt, &rply); 
  260. }
  261.  
  262. /*
  263.  * Some system error
  264.  */
  265. void
  266. svcerr_systemerr(xprt)
  267.     register SVCXPRT *xprt;
  268. {
  269.     struct rpc_msg rply; 
  270.  
  271.     rply.rm_direction = REPLY; 
  272.     rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  273.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  274.     rply.acpted_rply.ar_stat = SYSTEM_ERR;
  275.     SVC_REPLY(xprt, &rply); 
  276. }
  277.  
  278. /*
  279.  * Authentication error reply
  280.  */
  281. void
  282. svcerr_auth(xprt, why)
  283.     SVCXPRT *xprt;
  284.     enum auth_stat why;
  285. {
  286.     struct rpc_msg rply;
  287.  
  288.     rply.rm_direction = REPLY;
  289.     rply.rm_reply.rp_stat = MSG_DENIED;
  290.     rply.rjcted_rply.rj_stat = AUTH_ERROR;
  291.     rply.rjcted_rply.rj_why = why;
  292.     SVC_REPLY(xprt, &rply);
  293. }
  294.  
  295. /*
  296.  * Auth too weak error reply
  297.  */
  298. void
  299. svcerr_weakauth(xprt)
  300.     SVCXPRT *xprt;
  301. {
  302.  
  303.     svcerr_auth(xprt, AUTH_TOOWEAK);
  304. }
  305.  
  306. /*
  307.  * Program unavailable error reply
  308.  */
  309. void 
  310. svcerr_noprog(xprt)
  311.     register SVCXPRT *xprt;
  312. {
  313.     struct rpc_msg rply;  
  314.  
  315.     rply.rm_direction = REPLY;   
  316.     rply.rm_reply.rp_stat = MSG_ACCEPTED;  
  317.     rply.acpted_rply.ar_verf = xprt->xp_verf;  
  318.     rply.acpted_rply.ar_stat = PROG_UNAVAIL;
  319.     SVC_REPLY(xprt, &rply);
  320. }
  321.  
  322. /*
  323.  * Program version mismatch error reply
  324.  */
  325. void  
  326. svcerr_progvers(xprt, low_vers, high_vers)
  327.     register SVCXPRT *xprt; 
  328.     u_long low_vers;
  329.     u_long high_vers;
  330. {
  331.     struct rpc_msg rply;
  332.  
  333.     rply.rm_direction = REPLY;
  334.     rply.rm_reply.rp_stat = MSG_ACCEPTED;
  335.     rply.acpted_rply.ar_verf = xprt->xp_verf;
  336.     rply.acpted_rply.ar_stat = PROG_MISMATCH;
  337.     rply.acpted_rply.ar_vers.low = low_vers;
  338.     rply.acpted_rply.ar_vers.high = high_vers;
  339.     SVC_REPLY(xprt, &rply);
  340. }
  341.  
  342. /* ******************* SERVER INPUT STUFF ******************* */
  343.  
  344. /*
  345.  * Get server side input from some transport
  346.  */
  347. void
  348. svc_getreq(rdfds)
  349.     int rdfds;
  350. {
  351.     register int sock;
  352.     register int readfds = rdfds & svc_fds;
  353.     register SVCXPRT *xprt;
  354.     register enum xprt_stat stat;
  355.     struct rpc_msg msg;
  356.     /*char cred_body[MAX_AUTH_BYTES], verf_body[MAX_AUTH_BYTES];*/
  357.     char *cred_body;
  358.     int prog_found;
  359.     u_long low_vers;
  360.     u_long high_vers;
  361.  
  362.     cred_body = (char *)mem_alloc(2 * MAX_AUTH_BYTES);
  363.     if (cred_body == NULL) {
  364.         fprintf(stderr, "svc_getreq: out of memory\n");
  365.         svcerr_systemerr(xprt);
  366.         goto call_done;
  367.     }
  368.     msg.rm_call.cb_cred.oa_base = cred_body;
  369.     msg.rm_call.cb_verf.oa_base = &(cred_body[MAX_AUTH_BYTES]);
  370.     for (sock = 0; readfds != 0; sock++, readfds >>= 1) {
  371.         if ((readfds & 1) != 0) {
  372.         /* sock has input waiting */
  373.         xprt = xports[sock];
  374.         /* now receive msgs from xprtprt (support batch calls) */
  375.         do {
  376.             if (SVC_RECV(xprt, &msg)) {
  377.  
  378.                 /* now find the exported program and call it */
  379.                 register struct svc_callout *s;
  380.                 enum auth_stat why;
  381.                 struct svc_req r;
  382.  
  383.                 r.rq_xprt = xprt;
  384.                 r.rq_prog = msg.rm_call.cb_prog;
  385.                 r.rq_vers = msg.rm_call.cb_vers;
  386.                 r.rq_proc = msg.rm_call.cb_proc;
  387.                 r.rq_cred = msg.rm_call.cb_cred;
  388.                 /* first authenticate the message */
  389.                 if ((why= _authenticate(&r, &msg)) != AUTH_OK) {
  390.                     svcerr_auth(xprt, why);
  391.                     goto call_done;
  392.                 }
  393.                 /* now match message with a registered service*/
  394.                 prog_found = FALSE;
  395.                 low_vers = 0 - 1;
  396.                 high_vers = 0;
  397.                 for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
  398.                     if (s->sc_prog == r.rq_prog) {
  399.                         if (s->sc_vers == r.rq_vers) {
  400.                             (*s->sc_dispatch)(&r, xprt);
  401.                             goto call_done;
  402.                         }  /* found correct version */
  403.                         prog_found = TRUE;
  404.                         if (s->sc_vers < low_vers)
  405.                             low_vers = s->sc_vers;
  406.                         if (s->sc_vers > high_vers)
  407.                             high_vers = s->sc_vers;
  408.                     }   /* found correct program */
  409.                 }
  410.                 /*
  411.                  * if we got here, the program or version
  412.                  * is not served ...
  413.                  */
  414.                 if (prog_found)
  415.                     svcerr_progvers(xprt,
  416.                     low_vers, high_vers);
  417.                 else
  418.                      svcerr_noprog(xprt);
  419.                 /* Fall through to ... */
  420.             }
  421.         call_done:
  422.             if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
  423.                 SVC_DESTROY(xprt);
  424.                 break;
  425.             }
  426.         } while (stat == XPRT_MOREREQS);
  427.         }
  428.     }
  429.     mem_free(cred_body, 2 * MAX_AUTH_BYTES);
  430. }
  431.  
  432. /*
  433.  * This is the rpc server side idle loop
  434.  * Wait for input, call server program.
  435.  */
  436. void
  437. svc_run()
  438. {
  439.     int readfds;
  440.  
  441.     while (TRUE) {
  442.         readfds = svc_fds;
  443.         switch (select(32, &readfds, (int *)NULL, (int *)NULL,
  444.             (struct timeval *)NULL)) {
  445.  
  446.         case -1:
  447.                         if (errno == EINTR)
  448.                                 continue;
  449.                     else {
  450.                                 perror("svc.c: - Select failed");
  451.                                 return;
  452.             }
  453.         case 0:
  454.             continue;
  455.         default:
  456.             svc_getreq(readfds);
  457.         }
  458.     }
  459. }
  460.  
  461. /* *************************** BUILTIN TEST SERVICE **************** */
  462. void
  463. rpctest_service(reqst, xprt)
  464.     struct svc_req *reqst;
  465.     register SVCXPRT *xprt;
  466. {
  467.  
  468.     switch (reqst->rq_proc) {
  469.  
  470.     case RPCTEST_NULL_PROC:
  471.         /* get nullp parameters, return null results */
  472.         if (SVC_GETARGS(xprt, xdr_void, NULL)) {
  473.             svc_sendreply(xprt, (xdrproc_t)xdr_void, (caddr_t)NULL);
  474.         } else {
  475.             svcerr_decode(xprt);
  476.         }
  477.         return;
  478.  
  479.     case  RPCTEST_NULL_BATCH_PROC:  /* nothing !! */
  480.         return;
  481.  
  482.     default:
  483.         svcerr_noproc(xprt);
  484.         return;
  485.     }
  486. }
  487. !Funky!Stuff!
  488. echo x - svc.h
  489. sed 's/^X//' >svc.h <<'!Funky!Stuff!'
  490. /*
  491.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  492.  * unrestricted use provided that this legend is included on all tape
  493.  * media and as a part of the software program in whole or part.  Users
  494.  * may copy or modify Sun RPC without charge, but are not authorized
  495.  * to license or distribute it to anyone else except as part of a product or
  496.  * program developed by the user.
  497.  * 
  498.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  499.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  500.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  501.  * 
  502.  * Sun RPC is provided with no support and without any obligation on the
  503.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  504.  * modification or enhancement.
  505.  * 
  506.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  507.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  508.  * OR ANY PART THEREOF.
  509.  * 
  510.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  511.  * or profits or other special, indirect and consequential damages, even if
  512.  * Sun has been advised of the possibility of such damages.
  513.  * 
  514.  * Sun Microsystems, Inc.
  515.  * 2550 Garcia Avenue
  516.  * Mountain View, California  94043
  517.  */
  518. /*      @(#)svc.h 1.2 85/02/08 SMI      */
  519.  
  520. /*
  521.  * svc.h, Server-side remote procedure call interface.
  522.  *
  523.  * Copyright (C) 1984, Sun Microsystems, Inc.
  524.  */
  525.  
  526. /*
  527.  * This interface must manage two items concerning remote procedure calling:
  528.  *
  529.  * 1) An arbitrary number of transport connections upon which rpc requests
  530.  * are received.  The two most notable transports are TCP and UDP;  they are
  531.  * created and registered by routines in svc_tcp.c and svc_udp.c, respectively;
  532.  * they in turn call xprt_register and xprt_unregister.
  533.  *
  534.  * 2) An arbitrary number of locally registered services.  Services are
  535.  * described by the following four data: program number, version number,
  536.  * "service dispatch" function, a transport handle, and a boolean that
  537.  * indicates whether or not the exported program should be registered with a
  538.  * local binder service;  if true the program's number and version and the
  539.  * port number from the transport handle are registered with the binder.
  540.  * These data are registered with the rpc svc system via svc_register.
  541.  *
  542.  * A service's dispatch function is called whenever an rpc request comes in
  543.  * on a transport.  The request's program and version numbers must match
  544.  * those of the registered service.  The dispatch function is passed two
  545.  * parameters, struct svc_req * and SVCXPRT *, defined below.
  546.  */
  547.  
  548. enum xprt_stat {
  549.     XPRT_DIED,
  550.     XPRT_MOREREQS,
  551.     XPRT_IDLE
  552. };
  553.  
  554. /*
  555.  * Server side transport handle
  556.  */
  557. typedef struct {
  558.     int        xp_sock;
  559.     u_short        xp_port;     /* associated port number */
  560.     struct xp_ops {
  561.         bool_t    (*xp_recv)();     /* receive incomming requests */
  562.         enum xprt_stat (*xp_stat)(); /* get transport status */
  563.         bool_t    (*xp_getargs)(); /* get arguments */
  564.         bool_t    (*xp_reply)();     /* send reply */
  565.         bool_t    (*xp_freeargs)();/* free mem allocated for args */
  566.         void    (*xp_destroy)(); /* destroy this struct */
  567.     } *xp_ops;
  568.     int        xp_addrlen;     /* length of remote address */
  569.     struct sockaddr_in xp_raddr;     /* remote address */
  570.     struct opaque_auth xp_verf;     /* raw response verifier */
  571.     caddr_t        xp_p1;         /* private */
  572.     caddr_t        xp_p2;         /* private */
  573. } SVCXPRT;
  574.  
  575. /*
  576.  *  Approved way of getting address of caller
  577.  */
  578. #define svc_getcaller(x) (&(x)->xp_raddr)
  579.  
  580. /*
  581.  * Operations defined on an SVCXPRT handle
  582.  *
  583.  * SVCXPRT        *xprt;
  584.  * struct rpc_msg    *msg;
  585.  * xdrproc_t         xargs;
  586.  * caddr_t         argsp;
  587.  */
  588. #define SVC_RECV(xprt, msg)                \
  589.     (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
  590. #define svc_recv(xprt, msg)                \
  591.     (*(xprt)->xp_ops->xp_recv)((xprt), (msg))
  592.  
  593. #define SVC_STAT(xprt)                    \
  594.     (*(xprt)->xp_ops->xp_stat)(xprt)
  595. #define svc_stat(xprt)                    \
  596.     (*(xprt)->xp_ops->xp_stat)(xprt)
  597.  
  598. #define SVC_GETARGS(xprt, xargs, argsp)            \
  599.     (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
  600. #define svc_getargs(xprt, xargs, argsp)            \
  601.     (*(xprt)->xp_ops->xp_getargs)((xprt), (xargs), (argsp))
  602.  
  603. #define SVC_REPLY(xprt, msg)                \
  604.     (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
  605. #define svc_reply(xprt, msg)                \
  606.     (*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
  607.  
  608. #define SVC_FREEARGS(xprt, xargs, argsp)        \
  609.     (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
  610. #define svc_freeargs(xprt, xargs, argsp)        \
  611.     (*(xprt)->xp_ops->xp_freeargs)((xprt), (xargs), (argsp))
  612.  
  613. #define SVC_DESTROY(xprt)                \
  614.     (*(xprt)->xp_ops->xp_destroy)(xprt)
  615. #define svc_destroy(xprt)                \
  616.     (*(xprt)->xp_ops->xp_destroy)(xprt)
  617.  
  618.  
  619. /*
  620.  * Service request
  621.  */
  622. struct svc_req {
  623.     u_long        rq_prog;    /* service program number */
  624.     u_long        rq_vers;    /* service protocol version */
  625.     u_long        rq_proc;    /* the desired procedure */
  626.     struct opaque_auth rq_cred;    /* raw creds from the wire */
  627.     caddr_t        rq_clntcred;    /* read only cooked cred */
  628.     SVCXPRT    *rq_xprt;        /* associated transport */
  629. };
  630.  
  631.  
  632. /*
  633.  * Service registration
  634.  *
  635.  * svc_register(xprt, prog, vers, dispatch, protocol)
  636.  *    SVCXPRT *xprt;
  637.  *    u_long prog;
  638.  *    u_long vers;
  639.  *    void (*dispatch)();
  640.  *    int protocol;  /* like TCP or UDP, zero means do not register 
  641.  */
  642. extern bool_t    svc_register();
  643.  
  644. /*
  645.  * Service un-registration
  646.  *
  647.  * svc_unregister(prog, vers)
  648.  *    u_long prog;
  649.  *    u_long vers;
  650.  */
  651. extern void    svc_unregister();
  652.  
  653. /*
  654.  * Transport registration.
  655.  *
  656.  * xprt_register(xprt)
  657.  *    SVCXPRT *xprt;
  658.  */
  659. extern void    xprt_register();
  660.  
  661. /*
  662.  * Transport un-register
  663.  *
  664.  * xprt_unregister(xprt)
  665.  *    SVCXPRT *xprt;
  666.  */
  667. extern void    xprt_unregister();
  668.  
  669.  
  670. /*
  671.  * When the service routine is called, it must first check to see if it
  672.  * knows about the procedure;  if not, it should call svcerr_noproc
  673.  * and return.  If so, it should deserialize its arguments via 
  674.  * SVC_GETARGS (defined above).  If the deserialization does not work,
  675.  * svcerr_decode should be called followed by a return.  Successful
  676.  * decoding of the arguments should be followed the execution of the
  677.  * procedure's code and a call to svc_sendreply.
  678.  *
  679.  * Also, if the service refuses to execute the procedure due to too-
  680.  * weak authentication parameters, svcerr_weakauth should be called.
  681.  * Note: do not confuse access-control failure with weak authentication!
  682.  *
  683.  * NB: In pure implementations of rpc, the caller always waits for a reply
  684.  * msg.  This message is sent when svc_sendreply is called.  
  685.  * Therefore pure service implementations should always call
  686.  * svc_sendreply even if the function logically returns void;  use
  687.  * xdr.h - xdr_void for the xdr routine.  HOWEVER, tcp based rpc allows
  688.  * for the abuse of pure rpc via batched calling or pipelining.  In the
  689.  * case of a batched call, svc_sendreply should NOT be called since
  690.  * this would send a return message, which is what batching tries to avoid.
  691.  * It is the service/protocol writer's responsibility to know which calls are
  692.  * batched and which are not.  Warning: responding to batch calls may
  693.  * deadlock the caller and server processes!
  694.  */
  695.  
  696. extern bool_t  svc_sendreply();
  697. extern void    svcerr_noproc();
  698. extern void    svcerr_decode();
  699. extern void    svcerr_weakauth();
  700.  
  701. /*
  702.  * Lowest level dispatching -OR- who owns this process anyway.
  703.  * Somebody has to wait for incoming requests and then call the correct
  704.  * service routine.  The routine svc_run does infinite waiting; i.e.,
  705.  * svc_run never returns.
  706.  * Since another (co-existant) package may wish to selectively wait for
  707.  * incoming calls or other events outside of the rpc architecture, the
  708.  * routine svc_getreq is provided.  It must be passed readfds, the
  709.  * "in-place" results of a select system call (see select, section 2).
  710.  */
  711.  
  712. /* dynamic; must be inspected before each call to select */
  713. extern int svc_fds;
  714.  
  715. extern void    svc_getreq();
  716. extern void    svc_run();  /* never returns */
  717.  
  718. /*
  719.  * a small program implemented by the svc_rpc implementation itself;
  720.  * also see clnt.h for protocol numbers.
  721.  */
  722. extern void rpctest_service();
  723.  
  724. /*
  725.  * Socket to use on svcxxx_create call to get default socket
  726.  */
  727. #define    RPC_ANYSOCK    -1
  728.  
  729. /*
  730.  * These are the existing service side transport implementations
  731.  */
  732.  
  733. /*
  734.  * Memory based rpc for testing and timing.
  735.  */
  736. extern SVCXPRT *svcraw_create();
  737.  
  738. /*
  739.  * Udp based rpc.
  740.  */
  741. extern SVCXPRT *svcudp_create();
  742.  
  743. /*
  744.  * Tcp based rpc.
  745.  */
  746. extern SVCXPRT *svctcp_create();
  747.  
  748. !Funky!Stuff!
  749. echo x - svc_auth.c
  750. sed 's/^X//' >svc_auth.c <<'!Funky!Stuff!'
  751. /*
  752.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  753.  * unrestricted use provided that this legend is included on all tape
  754.  * media and as a part of the software program in whole or part.  Users
  755.  * may copy or modify Sun RPC without charge, but are not authorized
  756.  * to license or distribute it to anyone else except as part of a product or
  757.  * program developed by the user.
  758.  * 
  759.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  760.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  761.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  762.  * 
  763.  * Sun RPC is provided with no support and without any obligation on the
  764.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  765.  * modification or enhancement.
  766.  * 
  767.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  768.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  769.  * OR ANY PART THEREOF.
  770.  * 
  771.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  772.  * or profits or other special, indirect and consequential damages, even if
  773.  * Sun has been advised of the possibility of such damages.
  774.  * 
  775.  * Sun Microsystems, Inc.
  776.  * 2550 Garcia Avenue
  777.  * Mountain View, California  94043
  778.  */
  779. #ifndef lint
  780. static char sccsid[] = "@(#)svc_auth.c 1.4 85/03/17 Copyr 1984 Sun Micro";
  781. #endif
  782.  
  783. /*
  784.  * svc_auth.c, Server-side rpc authenticator interface.
  785.  *
  786.  * Copyright (C) 1984, Sun Microsystems, Inc.
  787.  */
  788.  
  789. #include "types.h"
  790. #include <netinet/in.h>
  791. #include "xdr.h"
  792. #include "auth.h"
  793. #include "clnt.h"
  794. #include "rpc_msg.h"
  795. #include "svc.h"
  796. #include "svc_auth.h"
  797.  
  798. /*
  799.  * svcauthsw is the bdevsw of server side authentication. 
  800.  * 
  801.  * Server side authenticators are called from authenticate by
  802.  * using the client auth struct flavor field to index into svcauthsw.
  803.  * The server auth flavors must implement a routine that looks  
  804.  * like: 
  805.  * 
  806.  *    enum auth_stat 
  807.  *    flavorx_auth(rqst, msg)
  808.  *        register struct svc_req *rqst; 
  809.  *        register struct rpc_msg *msg;
  810.  *  
  811.  */
  812.  
  813. enum auth_stat _svcauth_null();        /* no authentication */
  814. enum auth_stat _svcauth_unix();        /* unix style (uid, gids) */
  815. enum auth_stat _svcauth_short();        /* short hand unix style */
  816.  
  817. static struct {
  818.     enum auth_stat (*authenticator)();
  819. } svcauthsw[] = {
  820.     _svcauth_null,            /* AUTH_NULL */
  821.     _svcauth_unix,            /* AUTH_UNIX */
  822.     _svcauth_short            /* AUTH_SHORT */
  823. };
  824. #define    AUTH_MAX    2        /* HIGHEST AUTH NUMBER */
  825.  
  826.  
  827. /*
  828.  * The call rpc message, msg has been obtained from the wire.  The msg contains
  829.  * the raw form of credentials and verifiers.  authenticate returns AUTH_OK
  830.  * if the msg is successfully authenticated.  If AUTH_OK then the routine also
  831.  * does the following things:
  832.  * set rqst->rq_xprt->verf to the appropriate response verifier;
  833.  * sets rqst->rq_client_cred to the "cooked" form of the credentials.
  834.  *
  835.  * NB: rqst->rq_cxprt->verf must be pre-alloctaed;
  836.  * its length is set appropriately.
  837.  *
  838.  * The caller still owns and is responsible for msg->u.cmb.cred and
  839.  * msg->u.cmb.verf.  The authentication system retains ownership of
  840.  * rqst->rq_client_cred, the cooked credentials.
  841.  */
  842. enum auth_stat
  843. _authenticate(rqst, msg)
  844.     register struct svc_req *rqst;
  845.     struct rpc_msg *msg;
  846. {
  847.     register int cred_flavor;
  848.  
  849.     rqst->rq_cred = msg->rm_call.cb_cred;
  850.     rqst->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
  851.     rqst->rq_xprt->xp_verf.oa_length = 0;
  852.     rqst->rq_clntcred = (caddr_t)AUTH_NULL;
  853.     cred_flavor = rqst->rq_cred.oa_flavor;
  854.     if (cred_flavor <= AUTH_MAX) {
  855.         return ((*(svcauthsw[cred_flavor].authenticator))(rqst, msg));
  856.     }
  857.  
  858.     return (AUTH_REJECTEDCRED);
  859. }
  860.  
  861. enum auth_stat
  862. _svcauth_null(/*rqst, msg*/)
  863.     /*struct svc_req *rqst;
  864.     struct rpc_msg *msg;*/
  865. {
  866.  
  867.     return (AUTH_OK);
  868. }
  869. !Funky!Stuff!
  870. echo x - svc_auth.h
  871. sed 's/^X//' >svc_auth.h <<'!Funky!Stuff!'
  872. /*
  873.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  874.  * unrestricted use provided that this legend is included on all tape
  875.  * media and as a part of the software program in whole or part.  Users
  876.  * may copy or modify Sun RPC without charge, but are not authorized
  877.  * to license or distribute it to anyone else except as part of a product or
  878.  * program developed by the user.
  879.  * 
  880.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  881.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  882.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  883.  * 
  884.  * Sun RPC is provided with no support and without any obligation on the
  885.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  886.  * modification or enhancement.
  887.  * 
  888.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  889.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  890.  * OR ANY PART THEREOF.
  891.  * 
  892.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  893.  * or profits or other special, indirect and consequential damages, even if
  894.  * Sun has been advised of the possibility of such damages.
  895.  * 
  896.  * Sun Microsystems, Inc.
  897.  * 2550 Garcia Avenue
  898.  * Mountain View, California  94043
  899.  */
  900. /*      @(#)svc_auth.h 1.2 85/03/14 SMI      */
  901.  
  902. /*
  903.  * svc_auth.h, Service side of rpc authentication.
  904.  * 
  905.  * Copyright (C) 1984, Sun Microsystems, Inc.
  906.  */
  907.  
  908.  
  909. /*
  910.  * Server side authenticator
  911.  */
  912. extern enum auth_stat _authenticate();
  913. !Funky!Stuff!
  914. echo x - svc_auth_unix.c
  915. sed 's/^X//' >svc_auth_unix.c <<'!Funky!Stuff!'
  916. /*
  917.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  918.  * unrestricted use provided that this legend is included on all tape
  919.  * media and as a part of the software program in whole or part.  Users
  920.  * may copy or modify Sun RPC without charge, but are not authorized
  921.  * to license or distribute it to anyone else except as part of a product or
  922.  * program developed by the user.
  923.  * 
  924.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  925.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  926.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  927.  * 
  928.  * Sun RPC is provided with no support and without any obligation on the
  929.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  930.  * modification or enhancement.
  931.  * 
  932.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  933.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  934.  * OR ANY PART THEREOF.
  935.  * 
  936.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  937.  * or profits or other special, indirect and consequential damages, even if
  938.  * Sun has been advised of the possibility of such damages.
  939.  * 
  940.  * Sun Microsystems, Inc.
  941.  * 2550 Garcia Avenue
  942.  * Mountain View, California  94043
  943.  */
  944. #ifndef lint
  945. static char sccsid[] = "@(#)svc_auth_unix.c 1.4 85/03/14 Copyr 1984 Sun Micro";
  946. #endif
  947.  
  948. /*
  949.  * svc_auth_unix.c
  950.  * Handles UNIX flavor authentication parameters on the service side of rpc.
  951.  * There are two svc auth implementations here: AUTH_UNIX and AUTH_SHORT.
  952.  * _svcauth_unix does full blown unix style uid,gid+gids auth,
  953.  * _svcauth_short uses a shorthand auth to index into a cache of longhand auths.
  954.  *
  955.  * Copyright (C) 1984, Sun Microsystems, Inc.
  956.  */
  957.  
  958. #include <stdio.h>
  959. #include "types.h"
  960. #include <sys/time.h>
  961. #include <netinet/in.h>
  962. #include "xdr.h"
  963. #include "auth.h"
  964. #include "clnt.h"
  965. #include "rpc_msg.h"
  966. #include "svc.h"
  967. #include "auth_unix.h"
  968. #include "svc_auth.h"
  969. char *mem_alloc();
  970.  
  971. #define SHORT_VERF_SIZE (3 * BYTES_PER_XDR_UNIT)
  972. #define CACHE_SIZE 16
  973.  
  974. static struct cache_entry {
  975.     u_long        sh;        /* short hand value */
  976. #define SHORT_CRED_SIZE (sizeof (u_long))
  977.     short        cred_len;    /* byte length of opaque credential */
  978.     caddr_t        cred_base;    /* the opaque credential body */
  979.     struct authunix_parms aup;    /* cooked, deserialized credentials */
  980. } cache[CACHE_SIZE];
  981.  
  982. static short cacheindex[CACHE_SIZE];
  983.  
  984. /*
  985.  * Cache handling macros
  986.  */
  987. #define valid_aup(aup) (TRUE)
  988. #define nexti(i)  ((i == CACHE_SIZE-1) ? 0 : i+1)
  989. #define previ(i)  ((i == 0) ? CACHE_SIZE-1 : i-1)
  990. #define cache_hit(c, d) \
  991.    ( hits++, d=cnt-c, depth += d, maxdepth = (d > maxdepth) ? d: maxdepth )
  992.  
  993. /*
  994.  * Cache handling routines
  995.  */
  996. static short    find_short_hand();
  997. static short    find_long_hand();
  998.  
  999. /*
  1000.  * Cache variables
  1001.  */
  1002. static short head, maxdepth;    /* values from 0 to CACHE_SIZE-1, inclusive */
  1003. static short cnt;        /*  values from 0 to CACHE_SIZE, inclusive */
  1004. static u_long additions, deletions, queries, hits, depth;
  1005. static struct timeval last_time;
  1006. static inited = 0;        /* stupid kludge to be sure init gets called */
  1007.  
  1008.  
  1009. /*
  1010.  * Unix longhand authenticator
  1011.  */
  1012. enum auth_stat
  1013. _svcauth_unix(rqst, msg)
  1014.     register struct svc_req *rqst;
  1015.     register struct rpc_msg *msg;
  1016. {
  1017.     register short i = -1;
  1018.     register int len = msg->rm_call.cb_cred.oa_length;
  1019.     register caddr_t base = msg->rm_call.cb_cred.oa_base;
  1020.     register enum auth_stat stat = AUTH_OK;
  1021.     XDR xdrs;
  1022.     struct authunix_parms aup;
  1023.     struct opaque_auth short_cred;
  1024.  
  1025.     if (!inited) {
  1026.         svcauth_unix_init();
  1027.     }
  1028.     while ((i = find_long_hand(base, len)) < 0) {
  1029.         /* deserialize credentials */
  1030.         aup.aup_machname = NULL;
  1031.         aup.aup_gids = (int *)NULL;
  1032.         xdrmem_create(&xdrs, base, (u_int)len, XDR_DECODE); 
  1033.         if (! (xdr_authunix_parms(&xdrs, &aup) && valid_aup(&aup))) {
  1034.             xdrs.x_op = XDR_FREE;
  1035.             (void)xdr_authunix_parms(&xdrs, &aup);
  1036.             stat = AUTH_BADCRED;
  1037.             goto done;
  1038.         }
  1039.         /* now make a new cache entry for this credential */
  1040.         cache_new_user(base, len, &aup);
  1041.     }
  1042.     rqst->rq_clntcred = (caddr_t)&(cache[i].aup);
  1043.     /* now build a verifier that suggests using the short hand credential */
  1044.     short_cred.oa_flavor = AUTH_SHORT;
  1045.     short_cred.oa_length = SHORT_CRED_SIZE;
  1046.     short_cred.oa_base = (caddr_t)&(cache[i].sh);
  1047.     /* the short hand cred get serialized into a verifier */
  1048.     xdrmem_create(&xdrs, rqst->rq_xprt->xp_verf.oa_base,
  1049.         SHORT_VERF_SIZE, XDR_ENCODE);
  1050.     if (! xdr_opaque_auth(&xdrs, &short_cred)) {
  1051.         stat = AUTH_BADCRED;
  1052.         goto done;
  1053.     }
  1054.     rqst->rq_xprt->xp_verf.oa_length = XDR_GETPOS(&xdrs);
  1055.     rqst->rq_xprt->xp_verf.oa_flavor = AUTH_SHORT;
  1056. done:
  1057.     XDR_DESTROY(&xdrs);
  1058.     return (stat);
  1059. }
  1060.  
  1061.  
  1062. /*
  1063.  * Shorthand unix authenticator
  1064.  * Looks up longhand in a cache.
  1065.  */
  1066. enum auth_stat 
  1067. _svcauth_short(rqst, msg)
  1068.     struct svc_req *rqst;
  1069.     struct rpc_msg *msg;
  1070. {
  1071.     short i;
  1072.  
  1073.     if (!inited) {
  1074.         svcauth_unix_init();
  1075.     }
  1076.     if (msg->rm_call.cb_cred.oa_length != SHORT_CRED_SIZE)
  1077.         return (AUTH_BADCRED);
  1078.     if ((i = find_short_hand(*(u_long *)msg->rm_call.cb_cred.oa_base)) < 0)
  1079.         return (AUTH_REJECTEDCRED);
  1080.     rqst->rq_clntcred = (caddr_t)&(cache[i].aup);
  1081.     return (AUTH_OK);
  1082. }
  1083.  
  1084.  
  1085. /*
  1086.  * returns cache index or -1 if sh not in the cache
  1087.  */
  1088. static short
  1089. find_short_hand(sh)
  1090.     register u_long sh;  /* short hand value */
  1091. {
  1092.     /* declared in order of importance */
  1093.     register short entry, i, c, p;
  1094.  
  1095.     queries++;
  1096.     for (c = cnt, i = head; c > 0; --c, i = nexti(i)) {
  1097.  
  1098.         entry = cacheindex[i];
  1099.         if (sh == cache[entry].sh) {
  1100.             /* cache hit! Now buble swap i up one notch */
  1101.             cache_hit(c, p);  /* used for accounting only */
  1102.             if (i != head) {
  1103.                 /* c acts as the temporary variable */
  1104.                 p = previ(i);
  1105.                 c = cacheindex[p];
  1106.                 cacheindex[p] = entry; /* gets cacheindex[i] */
  1107.                 cacheindex[i] = c;
  1108.             }
  1109.             return (entry);
  1110.         }  /* end of successful cache hit */
  1111.     }
  1112.     return (-1);
  1113. }
  1114.  
  1115. /*
  1116.  * returns cache index or -1 if cred not in the cache
  1117.  */
  1118. static short
  1119. find_long_hand(cred_base, len)
  1120.     register caddr_t cred_base;
  1121.     register int len;
  1122. {
  1123.     /* declared in order of importance */
  1124.     register short entry, i, c, p;
  1125.  
  1126.     queries++;
  1127.     for (c = cnt, i = head; c > 0; --c, i = nexti(i)) {
  1128.  
  1129.         entry = cacheindex[i];
  1130.         if ((cache[entry].cred_len == len) &&
  1131.             (bcmp(cache[entry].cred_base, cred_base, len) == 0)) {
  1132.             /* cache hit! Now buble swap i up one notch */
  1133.             cache_hit(c, p);  /* used for accounting only */
  1134.             if (i != head) {
  1135.                 /* c acts as the temporary variable */
  1136.                 p = previ(i);
  1137.                 c = cacheindex[p];
  1138.                 cacheindex[p] = entry; /* gets cacheindex[i] */
  1139.                 cacheindex[i] = c;
  1140.             }
  1141.         return (entry);
  1142.         }  /* end of successful cache hit */
  1143.     }
  1144.     return (-1);
  1145. }
  1146.  
  1147. /*
  1148.  * Place a new entry at the HEAD of the cache.  This means moving the
  1149.  * heap index back one and possibly flushing the oldest entry from the cache.
  1150.  */
  1151. static
  1152. cache_new_user(base, len, aup)
  1153.     caddr_t base;
  1154.     int len;
  1155.     struct authunix_parms *aup;
  1156. {
  1157.     register short entry;
  1158.     struct timeval now;
  1159.  
  1160.     head = previ(head);
  1161.     entry = cacheindex[head];
  1162.     if (cnt == CACHE_SIZE) { /* full cache, delete lru entry */
  1163.         XDR xdrs;
  1164.  
  1165.         xdrs.x_op = XDR_FREE;
  1166.         deletions++;
  1167.         if (cache[entry].cred_base != NULL) {
  1168.             mem_free(cache[entry].cred_base,
  1169.                 cache[entry].cred_len);
  1170.             cache[entry].cred_base = NULL;
  1171.         }
  1172.         (void)xdr_authunix_parms(&xdrs, &cache[entry].aup);
  1173.     } else {
  1174.         cnt++;
  1175.     }
  1176.     /* now add current entry, raw cred must be copied */
  1177.     additions++;
  1178.     cache[entry].aup = *aup;
  1179.     cache[entry].cred_len = len;
  1180.     if ((cache[entry].cred_base = (char *)mem_alloc(len)) == NULL) {
  1181.         fprintf(stderr, "cache_new_user: out of memory\n");
  1182.         additions--;
  1183.         return;
  1184.     }
  1185.     bcopy(base, cache[entry].cred_base, (u_int)len);
  1186.     /* finally compute a new, unique short hand value */
  1187.     cache[entry].sh = ++ last_time.tv_sec;
  1188.     /* don't let real time get ahead of last_time */
  1189.     while (TRUE) {
  1190.         (void)gettimeofday(&now, (struct timezone *)0);
  1191.         if (((long int)now.tv_sec - (long int)last_time.tv_sec) > 0)
  1192.             break;
  1193.         sleep(1);
  1194.     }
  1195. }
  1196.  
  1197. /*
  1198.  * Initialize the shorthand cache.
  1199.  * Must be called before unix auth can be used!
  1200.  */
  1201. static svcauth_unix_init()
  1202. {
  1203.     register short i;
  1204.  
  1205.     inited++;
  1206.     (void)gettimeofday(&last_time, (struct timezone *)0);
  1207.     for (i = 0; i < CACHE_SIZE; ++i) {
  1208.         cacheindex[i] = i;
  1209.     }
  1210. }
  1211. !Funky!Stuff!
  1212. echo x - svc_raw.c
  1213. sed 's/^X//' >svc_raw.c <<'!Funky!Stuff!'
  1214. /*
  1215.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1216.  * unrestricted use provided that this legend is included on all tape
  1217.  * media and as a part of the software program in whole or part.  Users
  1218.  * may copy or modify Sun RPC without charge, but are not authorized
  1219.  * to license or distribute it to anyone else except as part of a product or
  1220.  * program developed by the user.
  1221.  * 
  1222.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1223.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1224.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1225.  * 
  1226.  * Sun RPC is provided with no support and without any obligation on the
  1227.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1228.  * modification or enhancement.
  1229.  * 
  1230.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1231.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1232.  * OR ANY PART THEREOF.
  1233.  * 
  1234.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1235.  * or profits or other special, indirect and consequential damages, even if
  1236.  * Sun has been advised of the possibility of such damages.
  1237.  * 
  1238.  * Sun Microsystems, Inc.
  1239.  * 2550 Garcia Avenue
  1240.  * Mountain View, California  94043
  1241.  */
  1242. #ifndef lint
  1243. static char sccsid[] = "@(#)svc_raw.c 1.3 85/03/14 Copyr 1984 Sun Micro";
  1244. #endif
  1245.  
  1246. /*
  1247.  * svc_raw.c,   This a toy for simple testing and timing.
  1248.  * Interface to create an rpc client and server in the same UNIX process.
  1249.  * This lets us similate rpc and get rpc (round trip) overhead, without
  1250.  * any interference from the kernal.
  1251.  *
  1252.  * Copyright (C) 1984, Sun Microsystems, Inc.
  1253.  */
  1254.  
  1255. #include "types.h"
  1256. #include <netinet/in.h>
  1257. #include "xdr.h"
  1258. #include "auth.h"
  1259. #include "clnt.h"
  1260. #include "rpc_msg.h"
  1261. #include "svc.h"
  1262.  
  1263. #define NULL ((caddr_t)0)
  1264.  
  1265. /*
  1266.  * This is the "network" that we will be moving data over
  1267.  */
  1268. extern char _raw_buf[UDPMSGSIZE];
  1269.  
  1270. static bool_t        svcraw_recv();
  1271. static enum xprt_stat     svcraw_stat();
  1272. static bool_t        svcraw_getargs();
  1273. static bool_t        svcraw_reply();
  1274. static bool_t        svcraw_freeargs();
  1275. static void        svcraw_destroy();
  1276.  
  1277. static struct xp_ops server_ops = {
  1278.     svcraw_recv,
  1279.     svcraw_stat,
  1280.     svcraw_getargs,
  1281.     svcraw_reply,
  1282.     svcraw_freeargs,
  1283.     svcraw_destroy
  1284. };
  1285.  
  1286. static SVCXPRT server;
  1287. static XDR xdr_stream;
  1288. static char verf_body[MAX_AUTH_BYTES];
  1289.  
  1290. SVCXPRT *
  1291. svcraw_create()
  1292. {
  1293.  
  1294.     server.xp_sock = 0;
  1295.     server.xp_port = 0;
  1296.     server.xp_ops = &server_ops;
  1297.     server.xp_verf.oa_base = verf_body;
  1298.     xdrmem_create(&xdr_stream, _raw_buf, UDPMSGSIZE, XDR_FREE);
  1299.     return (&server);
  1300. }
  1301.  
  1302. static enum xprt_stat
  1303. svcraw_stat()
  1304. {
  1305.  
  1306.     return (XPRT_IDLE);
  1307. }
  1308.  
  1309. static bool_t
  1310. svcraw_recv(xprt, msg)
  1311.     SVCXPRT *xprt;
  1312.     struct rpc_msg *msg;
  1313. {
  1314.     register XDR *xdrs = &xdr_stream;
  1315.  
  1316.     xdrs->x_op = XDR_DECODE;
  1317.     XDR_SETPOS(xdrs, 0);
  1318.     if (! xdr_callmsg(xdrs, msg))
  1319.            return (FALSE);
  1320.     return (TRUE);
  1321. }
  1322.  
  1323. static bool_t
  1324. svcraw_reply(xprt, msg)
  1325.     SVCXPRT *xprt;
  1326.     struct rpc_msg *msg;
  1327. {
  1328.     register XDR *xdrs = &xdr_stream;
  1329.  
  1330.     xdrs->x_op = XDR_ENCODE;
  1331.     XDR_SETPOS(xdrs, 0);
  1332.     if (! xdr_replymsg(xdrs, msg))
  1333.            return (FALSE);
  1334.     (void)XDR_GETPOS(xdrs);  /* called just for overhead */
  1335.     return (TRUE);
  1336. }
  1337.  
  1338. static bool_t
  1339. svcraw_getargs(xprt, xdr_args, args_ptr)
  1340.     SVCXPRT *xprt;
  1341.     xdrproc_t xdr_args;
  1342.     caddr_t args_ptr;
  1343. {
  1344.  
  1345.     return ((*xdr_args)(&xdr_stream, args_ptr));
  1346. }
  1347.  
  1348. static bool_t
  1349. svcraw_freeargs(xprt, xdr_args, args_ptr)
  1350.     SVCXPRT *xprt;
  1351.     xdrproc_t xdr_args;
  1352.     caddr_t args_ptr;
  1353. { 
  1354.     register XDR *xdrs = &xdr_stream;
  1355.  
  1356.     xdrs->x_op = XDR_FREE;
  1357.     return ((*xdr_args)(xdrs, args_ptr));
  1358. } 
  1359.  
  1360. static void
  1361. svcraw_destroy()
  1362. {
  1363. }
  1364. !Funky!Stuff!
  1365. echo x - svc_simple.c
  1366. sed 's/^X//' >svc_simple.c <<'!Funky!Stuff!'
  1367. /*
  1368.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1369.  * unrestricted use provided that this legend is included on all tape
  1370.  * media and as a part of the software program in whole or part.  Users
  1371.  * may copy or modify Sun RPC without charge, but are not authorized
  1372.  * to license or distribute it to anyone else except as part of a product or
  1373.  * program developed by the user.
  1374.  * 
  1375.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1376.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1377.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1378.  * 
  1379.  * Sun RPC is provided with no support and without any obligation on the
  1380.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1381.  * modification or enhancement.
  1382.  * 
  1383.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1384.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1385.  * OR ANY PART THEREOF.
  1386.  * 
  1387.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1388.  * or profits or other special, indirect and consequential damages, even if
  1389.  * Sun has been advised of the possibility of such damages.
  1390.  * 
  1391.  * Sun Microsystems, Inc.
  1392.  * 2550 Garcia Avenue
  1393.  * Mountain View, California  94043
  1394.  */
  1395. #ifndef lint
  1396. static char sccsid[] = "@(#)svc_simple.c 1.3 85/03/14 Copyr 1984 Sun Micro";
  1397. #endif
  1398.  
  1399. /* 
  1400.  * svc_simple.c
  1401.  * Simplified front end to rpc.
  1402.  *
  1403.  * Copyright (C) 1984, Sun Microsystems, Inc.
  1404.  */
  1405.  
  1406. #include <stdio.h>
  1407. #include <rpc/rpc.h>
  1408. #include <sys/socket.h>
  1409. #include <sys/time.h>
  1410. #include <netdb.h>
  1411.  
  1412. static struct proglst {
  1413.     char *(*p_progname)();
  1414.     int  p_prognum;
  1415.     int  p_procnum;
  1416.     xdrproc_t p_inproc, p_outproc;
  1417.     struct proglst *p_nxt;
  1418. } *proglst;
  1419. int universal();
  1420.  
  1421. registerrpc(prognum, versnum, procnum, progname, inproc, outproc)
  1422.     char *(*progname)();
  1423.     xdrproc_t inproc, outproc;
  1424. {
  1425.     static SVCXPRT *transp;
  1426.     static madetransp = 0;
  1427.     struct proglst *pl;
  1428.     
  1429.     if (procnum == NULLPROC) {
  1430.         fprintf(stderr,
  1431.             "can't reassign procedure number %d\n", NULLPROC);
  1432.         return (-1);
  1433.     }
  1434.     if (!madetransp) {
  1435.         madetransp = 1;
  1436.         transp = svcudp_create(RPC_ANYSOCK);
  1437.         if (transp == NULL) {
  1438.             fprintf(stderr, "couldn't create an rpc server\n");
  1439.             return (-1);
  1440.         }
  1441.     }
  1442.     pmap_unset(prognum, versnum);
  1443.     if (!svc_register(transp, prognum, versnum, universal, IPPROTO_UDP)) {
  1444.             fprintf(stderr, "couldn't register prog %d vers %d\n",
  1445.             prognum, versnum);
  1446.         return (-1);
  1447.     }
  1448.     pl = (struct proglst *)malloc(sizeof(struct proglst));
  1449.     if (pl == NULL) {
  1450.         fprintf(stderr, "registerrpc: out of memory\n");
  1451.         return (-1);
  1452.     }
  1453.     pl->p_progname = progname;
  1454.     pl->p_prognum = prognum;
  1455.     pl->p_procnum = procnum;
  1456.     pl->p_inproc = inproc;
  1457.     pl->p_outproc = outproc;
  1458.     pl->p_nxt = proglst;
  1459.     proglst = pl;
  1460.     return (0);
  1461. }
  1462.  
  1463. static
  1464. universal(rqstp, transp)
  1465.     struct svc_req *rqstp;
  1466.     SVCXPRT *transp;
  1467. {
  1468.     int prog, proc, i;
  1469.     char *outdata;
  1470.     char xdrbuf[UDPMSGSIZE];
  1471.     struct proglst *pl;
  1472.  
  1473.     /* 
  1474.      * enforce "procnum 0 is echo" convention
  1475.      */
  1476.     if (rqstp->rq_proc == NULLPROC) {
  1477.         if (svc_sendreply(transp, xdr_void, 0) == FALSE) {
  1478.             fprintf(stderr, "xxx\n");
  1479.             exit(1);
  1480.         }
  1481.         return;
  1482.     }
  1483.     prog = rqstp->rq_prog;
  1484.     proc = rqstp->rq_proc;
  1485.     for (pl = proglst; pl != NULL; pl = pl->p_nxt)
  1486.         if (pl->p_prognum == prog && pl->p_procnum == proc) {
  1487.             /* decode arguments into a CLEAN buffer */
  1488.             bzero(xdrbuf, sizeof(xdrbuf)); /* required ! */
  1489.             if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) {
  1490.                 svcerr_decode(transp);
  1491.                 return;
  1492.             }
  1493.             outdata = (*(pl->p_progname))(xdrbuf);
  1494.             if (outdata == NULL && pl->p_outproc != xdr_void)
  1495.                 /* there was an error */
  1496.                 return;
  1497.             if (!svc_sendreply(transp, pl->p_outproc, outdata)) {
  1498.                 fprintf(stderr,
  1499.                     "trouble replying to prog %d\n",
  1500.                     pl->p_prognum);
  1501.                 exit(1);
  1502.             /* free the decoded arguments */
  1503.             (void)svc_freeargs(transp, pl->p_inproc, xdrbuf);
  1504.             }
  1505.             return;
  1506.         }
  1507.     fprintf(stderr, "never registered prog %d\n", prog);
  1508.     exit(1);
  1509. }
  1510.  
  1511. !Funky!Stuff!
  1512. echo x - svc_tcp.c
  1513. sed 's/^X//' >svc_tcp.c <<'!Funky!Stuff!'
  1514. /*
  1515.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1516.  * unrestricted use provided that this legend is included on all tape
  1517.  * media and as a part of the software program in whole or part.  Users
  1518.  * may copy or modify Sun RPC without charge, but are not authorized
  1519.  * to license or distribute it to anyone else except as part of a product or
  1520.  * program developed by the user.
  1521.  * 
  1522.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1523.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1524.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1525.  * 
  1526.  * Sun RPC is provided with no support and without any obligation on the
  1527.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1528.  * modification or enhancement.
  1529.  * 
  1530.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1531.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1532.  * OR ANY PART THEREOF.
  1533.  * 
  1534.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1535.  * or profits or other special, indirect and consequential damages, even if
  1536.  * Sun has been advised of the possibility of such damages.
  1537.  * 
  1538.  * Sun Microsystems, Inc.
  1539.  * 2550 Garcia Avenue
  1540.  * Mountain View, California  94043
  1541.  */
  1542. #ifndef lint
  1543. static char sccsid[] = "@(#)svc_tcp.c 1.5 85/03/17 Copyr 1984 Sun Micro";
  1544. #endif
  1545.  
  1546. /*
  1547.  * svc_tcp.c, Server side for TCP/IP based RPC. 
  1548.  *
  1549.  * Copyright (C) 1984, Sun Microsystems, Inc.
  1550.  *
  1551.  * Actually implements two flavors of transporter -
  1552.  * a tcp rendezvouser (a listner and connection establisher)
  1553.  * and a record/tcp stream.
  1554.  */
  1555.  
  1556. #include <stdio.h>
  1557. #include "types.h"
  1558. #include <netinet/in.h>
  1559. #include <sys/socket.h>
  1560. #include <sys/time.h>
  1561. #include <errno.h>
  1562. #include "xdr.h"
  1563. #include "auth.h"
  1564. #include "clnt.h"
  1565. #include "rpc_msg.h"
  1566. #include "svc.h"
  1567. char *mem_alloc();
  1568. extern bool_t abort();
  1569. extern errno;
  1570.  
  1571. /*
  1572.  * Ops vector for TCP/IP based rpc service handle
  1573.  */
  1574. static bool_t        svctcp_recv();
  1575. static enum xprt_stat    svctcp_stat();
  1576. static bool_t        svctcp_getargs();
  1577. static bool_t        svctcp_reply();
  1578. static bool_t        svctcp_freeargs();
  1579. static void        svctcp_destroy();
  1580.  
  1581. static struct xp_ops svctcp_op = {
  1582.     svctcp_recv,
  1583.     svctcp_stat,
  1584.     svctcp_getargs,
  1585.     svctcp_reply,
  1586.     svctcp_freeargs,
  1587.     svctcp_destroy
  1588. };
  1589.  
  1590. /*
  1591.  * Ops vector for TCP/IP rendezvous handler
  1592.  */
  1593. static bool_t        rendezvous_request();
  1594. static enum xprt_stat    rendezvous_stat();
  1595.  
  1596. static struct xp_ops svctcp_rendezvous_op = {
  1597.     rendezvous_request,
  1598.     rendezvous_stat,
  1599.     abort,
  1600.     abort,
  1601.     abort,
  1602.     svctcp_destroy
  1603. };
  1604.  
  1605. static int readtcp(), writetcp();
  1606.  
  1607. struct tcp_rendezvous { /* kept in xprt->xp_p1 */
  1608.     u_int sendsize;
  1609.     u_int recvsize;
  1610. };
  1611.  
  1612. struct tcp_conn {  /* kept in xprt->xp_p1 */
  1613.     enum xprt_stat strm_stat;
  1614.     u_long x_id;
  1615.     XDR xdrs;
  1616.     char verf_body[MAX_AUTH_BYTES];
  1617. };
  1618.  
  1619. /*
  1620.  * Usage:
  1621.  *    xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
  1622.  *
  1623.  * Creates, registers, and returns a (rpc) tcp based transporter.
  1624.  * Once *xprt is initialized, it is registered as a transporter
  1625.  * see (svc.h, xprt_register).  This routine returns
  1626.  * a NULL if a problem occurred.
  1627.  *
  1628.  * If sock<0 then a socket is created, else sock is used.
  1629.  * If the socket, sock is not bound to a port then svctcp_create
  1630.  * binds it to an arbitrary port.  The routine then starts a tcp
  1631.  * listener on the socket's associated port.  In any (successful) case,
  1632.  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
  1633.  * associated port number.
  1634.  *
  1635.  * Since tcp streams do buffered io similar to stdio, the caller can specify
  1636.  * how big the send and receive buffers are via the second and third parms;
  1637.  * 0 => use the system default.
  1638.  */
  1639. SVCXPRT *
  1640. svctcp_create(sock, sendsize, recvsize)
  1641.     register int sock;
  1642.     u_int sendsize;
  1643.     u_int recvsize;
  1644. {
  1645.     bool_t madesock = FALSE;
  1646.     register SVCXPRT *xprt;
  1647.     register struct tcp_rendezvous *r;
  1648.     struct sockaddr_in addr;
  1649.     int len = sizeof(struct sockaddr_in);
  1650.  
  1651.     if (sock == RPC_ANYSOCK) {
  1652.         if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  1653.             perror("svctcp_.c - udp socket creation problem");
  1654.             return ((SVCXPRT *)NULL);
  1655.         }
  1656.         madesock = TRUE;
  1657.     }
  1658.     addr.sin_addr.s_addr = 0;
  1659.     addr.sin_family = AF_INET;
  1660.     addr.sin_port = 0;
  1661.     (void)bind(sock, (struct sockaddr *)&addr, len);
  1662.     if ((getsockname(sock, (caddr_t)&addr, &len) != 0)  ||
  1663.         (listen(sock, 2) != 0)) {
  1664.         perror("svctcp_.c - cannot getsockname or listen");
  1665.         if (madesock)
  1666.                (void)close(sock);
  1667.         return ((SVCXPRT *)NULL);
  1668.     }
  1669.     r = (struct tcp_rendezvous *)mem_alloc(sizeof(*r));
  1670.     if (r == NULL) {
  1671.         fprintf(stderr, "svctcp_create: out of memory\n");
  1672.         return (NULL);
  1673.     }
  1674.     r->sendsize = sendsize;
  1675.     r->recvsize = recvsize;
  1676.     xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
  1677.     if (xprt == NULL) {
  1678.         fprintf(stderr, "svctcp_create: out of memory\n");
  1679.         return (NULL);
  1680.     }
  1681.     xprt->xp_p2 = NULL;
  1682.     xprt->xp_p1 = (caddr_t)r;
  1683.     xprt->xp_verf = _null_auth;
  1684.     xprt->xp_ops = &svctcp_rendezvous_op;
  1685.     xprt->xp_port = ntohs(addr.sin_port);
  1686.     xprt->xp_sock = sock;
  1687.     xprt_register(xprt);
  1688.     return (xprt);
  1689. }
  1690.  
  1691. static bool_t
  1692. rendezvous_request(xprt)
  1693.     register SVCXPRT *xprt;
  1694. {
  1695.     register int sock;
  1696.     register struct tcp_rendezvous *r;
  1697.     register struct tcp_conn *cd;
  1698.     struct sockaddr_in addr;
  1699.     int len;
  1700.  
  1701.     r = (struct tcp_rendezvous *)xprt->xp_p1;
  1702.     again:
  1703.     len = sizeof(struct sockaddr_in);
  1704.     if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr,
  1705.         &len)) < 0) {
  1706.         if (errno == EINTR)
  1707.             goto again;
  1708.            return (FALSE);
  1709.     }
  1710.     /*
  1711.      * make a new transporter (re-uses xprt)
  1712.      */
  1713.     xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
  1714.     if (xprt == NULL) {
  1715.         fprintf(stderr, "rendezvous_request: out of memory\n");
  1716.         return (FALSE);
  1717.     }
  1718.     cd = (struct tcp_conn *)mem_alloc(sizeof(struct tcp_conn));
  1719.     if (cd == NULL) {
  1720.         fprintf(stderr, "rendezvous_request: out of memory\n");
  1721.         return (FALSE);
  1722.     }
  1723.     cd->strm_stat = XPRT_IDLE;
  1724.     xdrrec_create(&(cd->xdrs), r->sendsize, r->recvsize,
  1725.         (caddr_t)xprt, readtcp, writetcp);
  1726.     xprt->xp_p2 = NULL;
  1727.     xprt->xp_p1 = (caddr_t)cd;
  1728.     xprt->xp_verf.oa_base = cd->verf_body;
  1729.     xprt->xp_raddr = addr;
  1730.     xprt->xp_addrlen = len;
  1731.     xprt->xp_ops = &svctcp_op;  /* truely deals with calls */
  1732.     xprt->xp_port = 0;  /* this is a connection, not a rendezvouser */
  1733.     xprt->xp_sock = sock;
  1734.     xprt_register(xprt);
  1735.     return (FALSE); /* there is never an rpc msg to be processed */
  1736. }
  1737.  
  1738. static enum xprt_stat
  1739. rendezvous_stat()
  1740. {
  1741.  
  1742.     return (XPRT_IDLE);
  1743. }
  1744.  
  1745. static void
  1746. svctcp_destroy(xprt)
  1747.     register SVCXPRT *xprt;
  1748. {
  1749.     register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
  1750.  
  1751.     xprt_unregister(xprt);
  1752.     (void)close(xprt->xp_sock);
  1753.     if (xprt->xp_port != 0) {
  1754.         /* a rendezvouser socket */
  1755.         xprt->xp_port = 0;
  1756.     } else {
  1757.         /* an actual connection socket */
  1758.         XDR_DESTROY(&(cd->xdrs));
  1759.     }
  1760.     mem_free((caddr_t)cd, sizeof(struct tcp_conn));
  1761.     mem_free((caddr_t)xprt, sizeof(SVCXPRT));
  1762. }
  1763.  
  1764. /*
  1765.  * All read operations timeout after 35 seconds.
  1766.  * A timeout is fatal for the connection.
  1767.  */
  1768. static struct timeval wait_per_try = { 35, 0 };
  1769.  
  1770. /*
  1771.  * reads data from the tcp conection.
  1772.  * any error is fatal and the connection is closed.
  1773.  * (And a read of zero bytes is a half closed stream => error.)
  1774.  */
  1775. static int
  1776. readtcp(xprt, buf, len)
  1777.     register SVCXPRT *xprt;
  1778.     caddr_t buf;
  1779.     register int len;
  1780. {
  1781.     register int sock = xprt->xp_sock;
  1782.     register int mask = 1 << sock;
  1783.     int readfds;
  1784.  
  1785.     do {
  1786.         readfds = mask;
  1787.         if (select(32, &readfds, NULL, NULL, &wait_per_try) <= 0) {
  1788.             if (errno == EINTR)
  1789.                 continue;
  1790.             goto fatal_err;
  1791.         }
  1792.     } while (readfds != mask);
  1793.     if ((len = read(sock, buf, len)) > 0)
  1794.         return (len);
  1795. fatal_err:
  1796.     ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
  1797.     return (-1);
  1798. }
  1799.  
  1800. /*
  1801.  * writes data to the tcp connection.
  1802.  * Any error is fatal and the connection is closed.
  1803.  */
  1804. static int
  1805. writetcp(xprt, buf, len)
  1806.     register SVCXPRT *xprt;
  1807.     caddr_t buf;
  1808.     int len;
  1809. {
  1810.     register int i, cnt;
  1811.  
  1812.     for (cnt = len; cnt > 0; cnt -= i, buf += i) {
  1813.         if ((i = write(xprt->xp_sock, buf, cnt)) < 0) {
  1814.             ((struct tcp_conn *)(xprt->xp_p1))->strm_stat =
  1815.                 XPRT_DIED;
  1816.             return (-1);
  1817.         }
  1818.     }
  1819.     return (len);
  1820. }
  1821.  
  1822. static enum xprt_stat
  1823. svctcp_stat(xprt)
  1824.     SVCXPRT *xprt;
  1825. {
  1826.     register struct tcp_conn *cd =
  1827.         (struct tcp_conn *)(xprt->xp_p1);
  1828.  
  1829.     if (cd->strm_stat == XPRT_DIED)
  1830.         return (XPRT_DIED);
  1831.     if (! xdrrec_eof(&(cd->xdrs)))
  1832.         return (XPRT_MOREREQS);
  1833.     return (XPRT_IDLE);
  1834. }
  1835.  
  1836. static bool_t
  1837. svctcp_recv(xprt, msg)
  1838.     SVCXPRT *xprt;
  1839.     register struct rpc_msg *msg;
  1840. {
  1841.     register struct tcp_conn *cd =
  1842.         (struct tcp_conn *)(xprt->xp_p1);
  1843.     register XDR *xdrs = &(cd->xdrs);
  1844.  
  1845.     xdrs->x_op = XDR_DECODE;
  1846.     (void)xdrrec_skiprecord(xdrs);
  1847.     if (xdr_callmsg(xdrs, msg)) {
  1848.         cd->x_id = msg->rm_xid;
  1849.         return (TRUE);
  1850.     }
  1851.     return (FALSE);
  1852. }
  1853.  
  1854. static bool_t
  1855. svctcp_getargs(xprt, xdr_args, args_ptr)
  1856.     SVCXPRT *xprt;
  1857.     xdrproc_t xdr_args;
  1858.     caddr_t args_ptr;
  1859. {
  1860.  
  1861.     return ((*xdr_args)(&(((struct tcp_conn *)(xprt->xp_p1))->xdrs), args_ptr));
  1862. }
  1863.  
  1864. static bool_t
  1865. svctcp_freeargs(xprt, xdr_args, args_ptr)
  1866.     SVCXPRT *xprt;
  1867.     xdrproc_t xdr_args;
  1868.     caddr_t args_ptr;
  1869. {
  1870.     register XDR *xdrs =
  1871.         &(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
  1872.  
  1873.     xdrs->x_op = XDR_FREE;
  1874.     return ((*xdr_args)(xdrs, args_ptr));
  1875. }
  1876.  
  1877. static bool_t
  1878. svctcp_reply(xprt, msg)
  1879.     SVCXPRT *xprt;
  1880.     register struct rpc_msg *msg;
  1881. {
  1882.     register struct tcp_conn *cd =
  1883.         (struct tcp_conn *)(xprt->xp_p1);
  1884.     register XDR *xdrs = &(cd->xdrs);
  1885.     register bool_t stat;
  1886.  
  1887.     xdrs->x_op = XDR_ENCODE;
  1888.     msg->rm_xid = cd->x_id;
  1889.     stat = xdr_replymsg(xdrs, msg);
  1890.     (void)xdrrec_endofrecord(xdrs, TRUE);
  1891.     return (stat);
  1892. }
  1893. !Funky!Stuff!
  1894. echo x - svc_udp.c
  1895. sed 's/^X//' >svc_udp.c <<'!Funky!Stuff!'
  1896. /*
  1897.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  1898.  * unrestricted use provided that this legend is included on all tape
  1899.  * media and as a part of the software program in whole or part.  Users
  1900.  * may copy or modify Sun RPC without charge, but are not authorized
  1901.  * to license or distribute it to anyone else except as part of a product or
  1902.  * program developed by the user.
  1903.  * 
  1904.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1905.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1906.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1907.  * 
  1908.  * Sun RPC is provided with no support and without any obligation on the
  1909.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1910.  * modification or enhancement.
  1911.  * 
  1912.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1913.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  1914.  * OR ANY PART THEREOF.
  1915.  * 
  1916.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1917.  * or profits or other special, indirect and consequential damages, even if
  1918.  * Sun has been advised of the possibility of such damages.
  1919.  * 
  1920.  * Sun Microsystems, Inc.
  1921.  * 2550 Garcia Avenue
  1922.  * Mountain View, California  94043
  1923.  */
  1924. #ifndef lint
  1925. static char sccsid[] = "@(#)svc_udp.c 1.4 85/03/14 Copyr 1984 Sun Micro";
  1926. #endif
  1927.  
  1928. /*
  1929.  * svc_udp.c,
  1930.  * Server side for UDP/IP based RPC.  (Does some caching in the hopes of
  1931.  * achieving execute-at-most-once semantics.)
  1932.  *
  1933.  * Copyright (C) 1984, Sun Microsystems, Inc.
  1934.  */
  1935.  
  1936. #include <stdio.h>
  1937. #include "types.h"
  1938. #include <netinet/in.h>
  1939. #include <sys/socket.h>
  1940. #include <errno.h>
  1941. #include "xdr.h"
  1942. #include "auth.h"
  1943. #include "clnt.h"
  1944. #include "rpc_msg.h"
  1945. #include "svc.h"
  1946.  
  1947. char *mem_alloc();
  1948.  
  1949. #define rpc_buffer(xprt) ((xprt)->xp_p1)
  1950.  
  1951. static bool_t        svcudp_recv();
  1952. static bool_t        svcudp_reply();
  1953. static enum xprt_stat    svcudp_stat();
  1954. static bool_t        svcudp_getargs();
  1955. static bool_t        svcudp_freeargs();
  1956. static void        svcudp_destroy();
  1957.  
  1958. static struct xp_ops svcudp_op = {
  1959.     svcudp_recv,
  1960.     svcudp_stat,
  1961.     svcudp_getargs,
  1962.     svcudp_reply,
  1963.     svcudp_freeargs,
  1964.     svcudp_destroy
  1965. };
  1966.  
  1967. extern int errno;
  1968.  
  1969. /*
  1970.  * kept in xprt->xp_p2
  1971.  */
  1972. struct svcudp_data {
  1973.     u_long    su_xid;        /* transaction id */
  1974.     XDR    su_xdrs;    /* XDR handle */
  1975.     char    su_verfbody[MAX_AUTH_BYTES];    /* verifier body */
  1976. };
  1977. #define    su_data(xprt)    ((struct svcudp_data *)(xprt->xp_p2))
  1978.  
  1979. /*
  1980.  * Usage:
  1981.  *    xprt = svcudp_create(sock);
  1982.  *
  1983.  * If sock<0 then a socket is created, else sock is used.
  1984.  * If the socket, sock is not bound to a port then svcudp_create
  1985.  * binds it to an arbitrary port.  In any (successful) case,
  1986.  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
  1987.  * associated port number.
  1988.  * Once *xprt is initialized, it is registered as a transporter;
  1989.  * see (svc.h, xprt_register).
  1990.  * The routines returns NULL if a problem occurred.
  1991.  */
  1992. SVCXPRT *
  1993. svcudp_create(sock)
  1994.     register int sock;
  1995. {
  1996.     bool_t madesock = FALSE;
  1997.     register SVCXPRT *xprt;
  1998.     register struct svcudp_data *su;
  1999.     struct sockaddr_in addr;
  2000.     int len = sizeof(struct sockaddr_in);
  2001.  
  2002.     if (sock == RPC_ANYSOCK) {
  2003.         if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  2004.             perror("svcudp_create: socket creation problem");
  2005.             return ((SVCXPRT *)NULL);
  2006.         }
  2007.         madesock = TRUE;
  2008.     }
  2009.     addr.sin_addr.s_addr = 0;
  2010.     addr.sin_family = AF_INET;
  2011.     addr.sin_port = 0;
  2012.     (void)bind(sock, (struct sockaddr *)&addr, len);
  2013.     if (getsockname(sock, (caddr_t)&addr, &len) != 0) {
  2014.         perror("svcudp_create - cannot getsockname");
  2015.         if (madesock)
  2016.             (void)close(sock);
  2017.         return ((SVCXPRT *)NULL);
  2018.     }
  2019.     xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
  2020.     if (xprt == NULL) {
  2021.         fprintf(stderr, "svcudp_create: out of memory\n");
  2022.         return (NULL);
  2023.     }
  2024.     if ((rpc_buffer(xprt) = mem_alloc(UDPMSGSIZE)) == NULL) {
  2025.         fprintf(stderr, "svcudp_create: out of memory\n");
  2026.         return (NULL);
  2027.     }
  2028.     su = (struct svcudp_data *)mem_alloc(sizeof(*su));
  2029.     if (su == NULL) {
  2030.         fprintf(stderr, "svcudp_create: out of memory\n");
  2031.         return (NULL);
  2032.     }
  2033.     xdrmem_create(
  2034.         &(su->su_xdrs), rpc_buffer(xprt), UDPMSGSIZE, XDR_DECODE);
  2035.     xprt->xp_p2 = (caddr_t)su;
  2036.     xprt->xp_verf.oa_base = su->su_verfbody;
  2037.     xprt->xp_ops = &svcudp_op;
  2038.     xprt->xp_port = ntohs(addr.sin_port);
  2039.     xprt->xp_sock = sock;
  2040.     xprt_register(xprt);
  2041.     return (xprt);
  2042. }
  2043.  
  2044. static enum xprt_stat
  2045. svcudp_stat(xprt)
  2046.     SVCXPRT *xprt;
  2047. {
  2048.  
  2049.     return (XPRT_IDLE); 
  2050. }
  2051.  
  2052. static bool_t
  2053. svcudp_recv(xprt, msg)
  2054.     register SVCXPRT *xprt;
  2055.     struct rpc_msg *msg;
  2056. {
  2057.     register struct svcudp_data *su = su_data(xprt);
  2058.     register XDR *xdrs = &(su->su_xdrs);
  2059.     register int rlen;
  2060.  
  2061.     again:
  2062.     xprt->xp_addrlen = sizeof(struct sockaddr_in);
  2063.     rlen = recvfrom(xprt->xp_sock, rpc_buffer(xprt), UDPMSGSIZE,
  2064.         0, (struct sockaddr *)&(xprt->xp_raddr), &(xprt->xp_addrlen));
  2065.     if (rlen == -1 && errno == EINTR)
  2066.         goto again;
  2067.     if (rlen < 4*sizeof(u_long))
  2068.         return (FALSE);
  2069.     xdrs->x_op = XDR_DECODE;
  2070.     XDR_SETPOS(xdrs, 0);
  2071.     if (! xdr_callmsg(xdrs, msg))
  2072.         return (FALSE);
  2073.     su->su_xid = msg->rm_xid;
  2074.     return (TRUE);
  2075. }
  2076.  
  2077. static bool_t
  2078. svcudp_reply(xprt, msg)
  2079.     register SVCXPRT *xprt; 
  2080.     struct rpc_msg *msg; 
  2081. {
  2082.     register struct svcudp_data *su = su_data(xprt);
  2083.     register XDR *xdrs = &(su->su_xdrs);
  2084.     register int slen;
  2085.     register bool_t stat = FALSE;
  2086.  
  2087.     xdrs->x_op = XDR_ENCODE;
  2088.     XDR_SETPOS(xdrs, 0);
  2089.     msg->rm_xid = su->su_xid;
  2090.     if (xdr_replymsg(xdrs, msg)) {
  2091.         slen = (int)XDR_GETPOS(xdrs);
  2092.         if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0,
  2093.             (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen)
  2094.             == slen)
  2095.             stat = TRUE;
  2096.     }
  2097.     return (stat);
  2098. }
  2099.  
  2100. static bool_t
  2101. svcudp_getargs(xprt, xdr_args, args_ptr)
  2102.     SVCXPRT *xprt;
  2103.     xdrproc_t xdr_args;
  2104.     caddr_t args_ptr;
  2105. {
  2106.  
  2107.     return ((*xdr_args)(&(su_data(xprt)->su_xdrs), args_ptr));
  2108. }
  2109.  
  2110. static bool_t
  2111. svcudp_freeargs(xprt, xdr_args, args_ptr)
  2112.     SVCXPRT *xprt;
  2113.     xdrproc_t xdr_args;
  2114.     caddr_t args_ptr;
  2115. {
  2116.     register XDR *xdrs = &(su_data(xprt)->su_xdrs);
  2117.  
  2118.     xdrs->x_op = XDR_FREE;
  2119.     return ((*xdr_args)(xdrs, args_ptr));
  2120. }
  2121.  
  2122. static void
  2123. svcudp_destroy(xprt)
  2124.     register SVCXPRT *xprt;
  2125. {
  2126.     register struct svcudp_data *su = su_data(xprt);
  2127.  
  2128.     xprt_unregister(xprt);
  2129.     (void)close(xprt->xp_sock);
  2130.     XDR_DESTROY(&(su->su_xdrs));
  2131.     mem_free((caddr_t)su, sizeof(struct svcudp_data));
  2132.     mem_free(rpc_buffer(xprt), UDPMSGSIZE);
  2133.     mem_free((caddr_t)xprt, sizeof(SVCXPRT));
  2134. }
  2135. !Funky!Stuff!
  2136.  
  2137. exit
  2138.