Fix prototypes and parameters for compiling with enabled warnings.
authordrepper <drepper>
Thu, 27 Mar 1997 01:52:01 +0000 (01:52 +0000)
committerdrepper <drepper>
Thu, 27 Mar 1997 01:52:01 +0000 (01:52 +0000)
sunrpc/rpcinfo.c
sunrpc/svc.c
sunrpc/svc_auth.c
sunrpc/svc_authux.c
sunrpc/svc_raw.c
sunrpc/svc_run.c
sunrpc/svc_simple.c
sunrpc/svc_tcp.c

index 30932c8..23fb3c0 100644 (file)
@@ -1,6 +1,7 @@
-/* @(#)rpcinfo.c       2.2 88/08/11 4.0 RPCSRC */
-#ifndef lint
-static char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI";
+
+/* @(#)rpcinfo.c        2.2 88/08/11 4.0 RPCSRC */
+#if !defined(lint) && defined (SCCSID)
+static char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI";
 #endif
 
 /*
@@ -41,33 +42,38 @@ static      char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI";
  * Mountain View, California  94043
  */
 
+#include <getopt.h>
+#include <string.h>
+#include <unistd.h>
 #include <rpc/rpc.h>
 #include <stdio.h>
 #include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 #include <netdb.h>
 #include <rpc/pmap_prot.h>
 #include <rpc/pmap_clnt.h>
 #include <signal.h>
 #include <ctype.h>
+#include <locale.h>
+#include <libintl.h>
 
 #define MAXHOSTLEN 256
 
 #define        MIN_VERS        ((u_long) 0)
-#define        MAX_VERS        ((u_long) 4294967295L)
-
-static void    udpping(/*u_short portflag, int argc, char **argv*/);
-static void    tcpping(/*u_short portflag, int argc, char **argv*/);
-static int     pstatus(/*CLIENT *client, u_long prognum, u_long vers*/);
-static void    pmapdump(/*int argc, char **argv*/);
-static bool_t  reply_proc(/*void *res, struct sockaddr_in *who*/);
-static void    brdcst(/*int argc, char **argv*/);
-static void    deletereg(/* int argc, char **argv */) ;
-static void    usage(/*void*/);
-static u_long  getprognum(/*char *arg*/);
-static u_long  getvers(/*char *arg*/);
-static void    get_inet_address(/*struct sockaddr_in *addr, char *host*/);
-extern u_long inet_addr();  /* in 4.2BSD, arpa/inet.h called that a in_addr */
-extern char *inet_ntoa();
+#define        MAX_VERS        ((u_long) 4294967295UL)
+
+static void udpping (u_short portflag, int argc, char **argv);
+static void tcpping (u_short portflag, int argc, char **argv);
+static int pstatus (CLIENT *client, u_long prognum, u_long vers);
+static void pmapdump (int argc, char **argv);
+static bool_t reply_proc (void *res, struct sockaddr_in *who);
+static void brdcst (int argc, char **argv);
+static void deletereg (int argc, char **argv);
+static void usage (void);
+static u_long getprognum (char *arg);
+static u_long getvers (char *arg);
+static void get_inet_address (struct sockaddr_in *addr, char *host);
 
 /*
  * Functions to be performed.
@@ -80,365 +86,408 @@ extern char *inet_ntoa();
 #define DELETES                5       /* delete registration for the service */
 
 int
-main(argc, argv)
-       int argc;
-       char **argv;
+main (int argc, char **argv)
 {
-       register int c;
-       extern char *optarg;
-       extern int optind;
-       int errflg;
-       int function;
-       u_short portnum;
-
-       function = NONE;
-       portnum = 0;
-       errflg = 0;
-       while ((c = getopt(argc, argv, "ptubdn:")) != -1) {
-               switch (c) {
-
-               case 'p':
-                       if (function != NONE)
-                               errflg = 1;
-                       else
-                               function = PMAPDUMP;
-                       break;
-
-               case 't':
-                       if (function != NONE)
-                               errflg = 1;
-                       else
-                               function = TCPPING;
-                       break;
-
-               case 'u':
-                       if (function != NONE)
-                               errflg = 1;
-                       else
-                               function = UDPPING;
-                       break;
-
-               case 'b':
-                       if (function != NONE)
-                               errflg = 1;
-                       else
-                               function = BRDCST;
-                       break;
-
-               case 'n':
-                       portnum = (u_short) atoi(optarg);   /* hope we don't get bogus # */
-                       break;
-
-               case 'd':
-                       if (function != NONE)
-                               errflg = 1;
-                       else
-                               function = DELETES;
-                       break;
-
-               case '?':
-                       errflg = 1;
-               }
+  register int c;
+  int errflg;
+  int function;
+  u_short portnum;
+
+  setlocale (LC_ALL, "");
+  textdomain (_libc_intl_domainname);
+
+  function = NONE;
+  portnum = 0;
+  errflg = 0;
+  while ((c = getopt (argc, argv, "ptubdn:")) != -1)
+    {
+      switch (c)
+       {
+
+       case 'p':
+         if (function != NONE)
+           errflg = 1;
+         else
+           function = PMAPDUMP;
+         break;
+
+       case 't':
+         if (function != NONE)
+           errflg = 1;
+         else
+           function = TCPPING;
+         break;
+
+       case 'u':
+         if (function != NONE)
+           errflg = 1;
+         else
+           function = UDPPING;
+         break;
+
+       case 'b':
+         if (function != NONE)
+           errflg = 1;
+         else
+           function = BRDCST;
+         break;
+
+       case 'n':
+         portnum = (u_short) atoi (optarg);    /* hope we don't get bogus # */
+         break;
+
+       case 'd':
+         if (function != NONE)
+           errflg = 1;
+         else
+           function = DELETES;
+         break;
+
+       case '?':
+         errflg = 1;
        }
-
-       if (errflg || function == NONE) {
-               usage();
-               return (1);
+    }
+
+  if (errflg || function == NONE)
+    {
+      usage ();
+      return (1);
+    }
+
+  switch (function)
+    {
+
+    case PMAPDUMP:
+      if (portnum != 0)
+       {
+         usage ();
+         return (1);
        }
-
-       switch (function) {
-
-       case PMAPDUMP:
-               if (portnum != 0) {
-                       usage();
-                       return (1);
-               }
-               pmapdump(argc - optind, argv + optind);
-               break;
-
-       case UDPPING:
-               udpping(portnum, argc - optind, argv + optind);
-               break;
-
-       case TCPPING:
-               tcpping(portnum, argc - optind, argv + optind);
-               break;
-
-       case BRDCST:
-               if (portnum != 0) {
-                       usage();
-                       return (1);
-               }
-               brdcst(argc - optind, argv + optind);
-               break;
-
-       case DELETES:
-               deletereg(argc - optind, argv + optind);
-               break;
+      pmapdump (argc - optind, argv + optind);
+      break;
+
+    case UDPPING:
+      udpping (portnum, argc - optind, argv + optind);
+      break;
+
+    case TCPPING:
+      tcpping (portnum, argc - optind, argv + optind);
+      break;
+
+    case BRDCST:
+      if (portnum != 0)
+       {
+         usage ();
+         return (1);
        }
+      brdcst (argc - optind, argv + optind);
+      break;
 
-       return (0);
+    case DELETES:
+      deletereg (argc - optind, argv + optind);
+      break;
+    }
+
+  return (0);
 }
 
 static void
-udpping(portnum, argc, argv)
-       u_short portnum;
-       int argc;
-       char **argv;
+udpping (portnum, argc, argv)
+     u_short portnum;
+     int argc;
+     char **argv;
 {
-       struct timeval to;
-       struct sockaddr_in addr;
-       enum clnt_stat rpc_stat;
-       CLIENT *client;
-       u_long prognum, vers, minvers, maxvers;
-       int sock = RPC_ANYSOCK;
-       struct rpc_err rpcerr;
-       int failure;
-
-       if (argc < 2 || argc > 3) {
-               usage();
-               exit(1);
+  struct timeval to;
+  struct sockaddr_in addr;
+  enum clnt_stat rpc_stat;
+  CLIENT *client;
+  u_long prognum, vers, minvers, maxvers;
+  int sock = RPC_ANYSOCK;
+  struct rpc_err rpcerr;
+  int failure;
+
+  if (argc < 2 || argc > 3)
+    {
+      usage ();
+      exit (1);
+    }
+  prognum = getprognum (argv[1]);
+  get_inet_address (&addr, argv[0]);
+  /* Open the socket here so it will survive calls to clnt_destroy */
+  sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (sock < 0)
+    {
+      perror ("rpcinfo: socket");
+      exit (1);
+    }
+  failure = 0;
+  if (argc == 2)
+    {
+      /*
+       * A call to version 0 should fail with a program/version
+       * mismatch, and give us the range of versions supported.
+       */
+      addr.sin_port = htons (portnum);
+      to.tv_sec = 5;
+      to.tv_usec = 0;
+      if ((client = clntudp_create (&addr, prognum, (u_long) 0,
+                                   to, &sock)) == NULL)
+       {
+         clnt_pcreateerror ("rpcinfo");
+         printf (_ ("program %lu is not available\n"),
+                 prognum);
+         exit (1);
+       }
+      to.tv_sec = 10;
+      to.tv_usec = 0;
+      rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void,
+                           (char *) NULL, (xdrproc_t) xdr_void,
+                           (char *) NULL, to);
+      if (rpc_stat == RPC_PROGVERSMISMATCH)
+       {
+         clnt_geterr (client, &rpcerr);
+         minvers = rpcerr.re_vers.low;
+         maxvers = rpcerr.re_vers.high;
+       }
+      else if (rpc_stat == RPC_SUCCESS)
+       {
+         /*
+          * Oh dear, it DOES support version 0.
+          * Let's try version MAX_VERS.
+          */
+         addr.sin_port = htons (portnum);
+         to.tv_sec = 5;
+         to.tv_usec = 0;
+         if ((client = clntudp_create (&addr, prognum, MAX_VERS,
+                                       to, &sock)) == NULL)
+           {
+             clnt_pcreateerror ("rpcinfo");
+             printf (_ ("program %lu version %lu is not available\n"),
+                     prognum, MAX_VERS);
+             exit (1);
+           }
+         to.tv_sec = 10;
+         to.tv_usec = 0;
+         rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void,
+                               NULL, (xdrproc_t) xdr_void, NULL, to);
+         if (rpc_stat == RPC_PROGVERSMISMATCH)
+           {
+             clnt_geterr (client, &rpcerr);
+             minvers = rpcerr.re_vers.low;
+             maxvers = rpcerr.re_vers.high;
+           }
+         else if (rpc_stat == RPC_SUCCESS)
+           {
+             /*
+              * It also supports version MAX_VERS.
+              * Looks like we have a wise guy.
+              * OK, we give them information on all
+              * 4 billion versions they support...
+              */
+             minvers = 0;
+             maxvers = MAX_VERS;
+           }
+         else
+           {
+             (void) pstatus (client, prognum, MAX_VERS);
+             exit (1);
+           }
        }
-       prognum = getprognum(argv[1]);
-       get_inet_address(&addr, argv[0]);
-       /* Open the socket here so it will survive calls to clnt_destroy */
-       sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-       if (sock < 0) {
-               perror("rpcinfo: socket");
-               exit(1);
+      else
+       {
+         (void) pstatus (client, prognum, (u_long) 0);
+         exit (1);
        }
-       failure = 0;
-       if (argc == 2) {
-               /*
-                * A call to version 0 should fail with a program/version
-                * mismatch, and give us the range of versions supported.
-                */
-               addr.sin_port = htons(portnum);
-               to.tv_sec = 5;
-               to.tv_usec = 0;
-               if ((client = clntudp_create(&addr, prognum, (u_long)0,
-                   to, &sock)) == NULL) {
-                       clnt_pcreateerror("rpcinfo");
-                       printf(_("program %lu is not available\n"),
-                           prognum);
-                       exit(1);
-               }
-               to.tv_sec = 10;
-               to.tv_usec = 0;
-               rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL,
-                   xdr_void, (char *)NULL, to);
-               if (rpc_stat == RPC_PROGVERSMISMATCH) {
-                       clnt_geterr(client, &rpcerr);
-                       minvers = rpcerr.re_vers.low;
-                       maxvers = rpcerr.re_vers.high;
-               } else if (rpc_stat == RPC_SUCCESS) {
-                       /*
-                        * Oh dear, it DOES support version 0.
-                        * Let's try version MAX_VERS.
-                        */
-                       addr.sin_port = htons(portnum);
-                       to.tv_sec = 5;
-                       to.tv_usec = 0;
-                       if ((client = clntudp_create(&addr, prognum, MAX_VERS,
-                           to, &sock)) == NULL) {
-                               clnt_pcreateerror("rpcinfo");
-                               printf(_("program %lu version %lu is not available\n"),
-                                   prognum, MAX_VERS);
-                               exit(1);
-                       }
-                       to.tv_sec = 10;
-                       to.tv_usec = 0;
-                       rpc_stat = clnt_call(client, NULLPROC, xdr_void,
-                           (char *)NULL, xdr_void, (char *)NULL, to);
-                       if (rpc_stat == RPC_PROGVERSMISMATCH) {
-                               clnt_geterr(client, &rpcerr);
-                               minvers = rpcerr.re_vers.low;
-                               maxvers = rpcerr.re_vers.high;
-                       } else if (rpc_stat == RPC_SUCCESS) {
-                               /*
-                                * It also supports version MAX_VERS.
-                                * Looks like we have a wise guy.
-                                * OK, we give them information on all
-                                * 4 billion versions they support...
-                                */
-                               minvers = 0;
-                               maxvers = MAX_VERS;
-                       } else {
-                               (void) pstatus(client, prognum, MAX_VERS);
-                               exit(1);
-                       }
-               } else {
-                       (void) pstatus(client, prognum, (u_long)0);
-                       exit(1);
-               }
-               clnt_destroy(client);
-               for (vers = minvers; vers <= maxvers; vers++) {
-                       addr.sin_port = htons(portnum);
-                       to.tv_sec = 5;
-                       to.tv_usec = 0;
-                       if ((client = clntudp_create(&addr, prognum, vers,
-                           to, &sock)) == NULL) {
-                               clnt_pcreateerror("rpcinfo");
-                               printf(_("program %lu version %lu is not available\n"),
-                                   prognum, vers);
-                               exit(1);
-                       }
-                       to.tv_sec = 10;
-                       to.tv_usec = 0;
-                       rpc_stat = clnt_call(client, NULLPROC, xdr_void,
-                           (char *)NULL, xdr_void, (char *)NULL, to);
-                       if (pstatus(client, prognum, vers) < 0)
-                               failure = 1;
-                       clnt_destroy(client);
-               }
+      clnt_destroy (client);
+      for (vers = minvers; vers <= maxvers; vers++)
+       {
+         addr.sin_port = htons (portnum);
+         to.tv_sec = 5;
+         to.tv_usec = 0;
+         if ((client = clntudp_create (&addr, prognum, vers,
+                                       to, &sock)) == NULL)
+           {
+             clnt_pcreateerror ("rpcinfo");
+             printf (_ ("program %lu version %lu is not available\n"),
+                     prognum, vers);
+             exit (1);
+           }
+         to.tv_sec = 10;
+         to.tv_usec = 0;
+         rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void,
+                               NULL, (xdrproc_t) xdr_void, NULL, to);
+         if (pstatus (client, prognum, vers) < 0)
+           failure = 1;
+         clnt_destroy (client);
        }
-       else {
-               vers = getvers(argv[2]);
-               addr.sin_port = htons(portnum);
-               to.tv_sec = 5;
-               to.tv_usec = 0;
-               if ((client = clntudp_create(&addr, prognum, vers,
-                   to, &sock)) == NULL) {
-                       clnt_pcreateerror("rpcinfo");
-                       printf("program %lu version %lu is not available\n",
-                           prognum, vers);
-                       exit(1);
-               }
-               to.tv_sec = 10;
-               to.tv_usec = 0;
-               rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
-                   xdr_void, (char *)NULL, to);
-               if (pstatus(client, prognum, vers) < 0)
-                       failure = 1;
+    }
+  else
+    {
+      vers = getvers (argv[2]);
+      addr.sin_port = htons (portnum);
+      to.tv_sec = 5;
+      to.tv_usec = 0;
+      if ((client = clntudp_create (&addr, prognum, vers,
+                                   to, &sock)) == NULL)
+       {
+         clnt_pcreateerror ("rpcinfo");
+         printf ("program %lu version %lu is not available\n",
+                 prognum, vers);
+         exit (1);
        }
-       (void) close(sock); /* Close it up again */
-       if (failure)
-               exit(1);
+      to.tv_sec = 10;
+      to.tv_usec = 0;
+      rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL,
+                           (xdrproc_t) xdr_void, NULL, to);
+      if (pstatus (client, prognum, vers) < 0)
+       failure = 1;
+    }
+  (void) close (sock);         /* Close it up again */
+  if (failure)
+    exit (1);
 }
 
 static void
-tcpping(portnum, argc, argv)
-       u_short portnum;
-       int argc;
-       char **argv;
+tcpping (portnum, argc, argv)
+     u_short portnum;
+     int argc;
+     char **argv;
 {
-       struct timeval to;
-       struct sockaddr_in addr;
-       enum clnt_stat rpc_stat;
-       CLIENT *client;
-       u_long prognum, vers, minvers, maxvers;
-       int sock = RPC_ANYSOCK;
-       struct rpc_err rpcerr;
-       int failure;
-
-       if (argc < 2 || argc > 3) {
-               usage();
-               exit(1);
+  struct timeval to;
+  struct sockaddr_in addr;
+  enum clnt_stat rpc_stat;
+  CLIENT *client;
+  u_long prognum, vers, minvers, maxvers;
+  int sock = RPC_ANYSOCK;
+  struct rpc_err rpcerr;
+  int failure;
+
+  if (argc < 2 || argc > 3)
+    {
+      usage ();
+      exit (1);
+    }
+  prognum = getprognum (argv[1]);
+  get_inet_address (&addr, argv[0]);
+  failure = 0;
+  if (argc == 2)
+    {
+      /*
+       * A call to version 0 should fail with a program/version
+       * mismatch, and give us the range of versions supported.
+       */
+      addr.sin_port = htons (portnum);
+      if ((client = clnttcp_create (&addr, prognum, MIN_VERS,
+                                   &sock, 0, 0)) == NULL)
+       {
+         clnt_pcreateerror ("rpcinfo");
+         printf (_ ("program %lu is not available\n"),
+                 prognum);
+         exit (1);
        }
-       prognum = getprognum(argv[1]);
-       get_inet_address(&addr, argv[0]);
-       failure = 0;
-       if (argc == 2) {
-               /*
-                * A call to version 0 should fail with a program/version
-                * mismatch, and give us the range of versions supported.
-                */
-               addr.sin_port = htons(portnum);
-               if ((client = clnttcp_create(&addr, prognum, MIN_VERS,
-                   &sock, 0, 0)) == NULL) {
-                       clnt_pcreateerror("rpcinfo");
-                       printf(_("program %lu is not available\n"),
-                           prognum);
-                       exit(1);
-               }
-               to.tv_sec = 10;
-               to.tv_usec = 0;
-               rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL,
-                   xdr_void, (char *)NULL, to);
-               if (rpc_stat == RPC_PROGVERSMISMATCH) {
-                       clnt_geterr(client, &rpcerr);
-                       minvers = rpcerr.re_vers.low;
-                       maxvers = rpcerr.re_vers.high;
-               } else if (rpc_stat == RPC_SUCCESS) {
-                       /*
-                        * Oh dear, it DOES support version 0.
-                        * Let's try version MAX_VERS.
-                        */
-                       addr.sin_port = htons(portnum);
-                       if ((client = clnttcp_create(&addr, prognum, MAX_VERS,
-                           &sock, 0, 0)) == NULL) {
-                               clnt_pcreateerror("rpcinfo");
-                               printf(_("program %lu version %lu is not available\n"),
-                                   prognum, MAX_VERS);
-                               exit(1);
-                       }
-                       to.tv_sec = 10;
-                       to.tv_usec = 0;
-                       rpc_stat = clnt_call(client, NULLPROC, xdr_void,
-                           (char *)NULL, xdr_void, (char *)NULL, to);
-                       if (rpc_stat == RPC_PROGVERSMISMATCH) {
-                               clnt_geterr(client, &rpcerr);
-                               minvers = rpcerr.re_vers.low;
-                               maxvers = rpcerr.re_vers.high;
-                       } else if (rpc_stat == RPC_SUCCESS) {
-                               /*
-                                * It also supports version MAX_VERS.
-                                * Looks like we have a wise guy.
-                                * OK, we give them information on all
-                                * 4 billion versions they support...
-                                */
-                               minvers = 0;
-                               maxvers = MAX_VERS;
-                       } else {
-                               (void) pstatus(client, prognum, MAX_VERS);
-                               exit(1);
-                       }
-               } else {
-                       (void) pstatus(client, prognum, MIN_VERS);
-                       exit(1);
-               }
-               clnt_destroy(client);
-               (void) close(sock);
-               sock = RPC_ANYSOCK; /* Re-initialize it for later */
-               for (vers = minvers; vers <= maxvers; vers++) {
-                       addr.sin_port = htons(portnum);
-                       if ((client = clnttcp_create(&addr, prognum, vers,
-                           &sock, 0, 0)) == NULL) {
-                               clnt_pcreateerror("rpcinfo");
-                               printf(_("program %lu version %lu is not available\n"),
-                                   prognum, vers);
-                               exit(1);
-                       }
-                       to.tv_usec = 0;
-                       to.tv_sec = 10;
-                       rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
-                           xdr_void, (char *)NULL, to);
-                       if (pstatus(client, prognum, vers) < 0)
-                               failure = 1;
-                       clnt_destroy(client);
-                       (void) close(sock);
-                       sock = RPC_ANYSOCK;
-               }
+      to.tv_sec = 10;
+      to.tv_usec = 0;
+      rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, NULL,
+                           (xdrproc_t) xdr_void, NULL, to);
+      if (rpc_stat == RPC_PROGVERSMISMATCH)
+       {
+         clnt_geterr (client, &rpcerr);
+         minvers = rpcerr.re_vers.low;
+         maxvers = rpcerr.re_vers.high;
        }
-       else {
-               vers = getvers(argv[2]);
-               addr.sin_port = htons(portnum);
-               if ((client = clnttcp_create(&addr, prognum, vers, &sock,
-                   0, 0)) == NULL) {
-                       clnt_pcreateerror("rpcinfo");
-                       printf(_("program %lu version %lu is not available\n"),
-                           prognum, vers);
-                       exit(1);
-               }
-               to.tv_usec = 0;
-               to.tv_sec = 10;
-               rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
-                   xdr_void, (char *)NULL, to);
-               if (pstatus(client, prognum, vers) < 0)
-                       failure = 1;
+      else if (rpc_stat == RPC_SUCCESS)
+       {
+         /*
+          * Oh dear, it DOES support version 0.
+          * Let's try version MAX_VERS.
+          */
+         addr.sin_port = htons (portnum);
+         if ((client = clnttcp_create (&addr, prognum, MAX_VERS,
+                                       &sock, 0, 0)) == NULL)
+           {
+             clnt_pcreateerror ("rpcinfo");
+             printf (_ ("program %lu version %lu is not available\n"),
+                     prognum, MAX_VERS);
+             exit (1);
+           }
+         to.tv_sec = 10;
+         to.tv_usec = 0;
+         rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void,
+                               NULL, (xdrproc_t) xdr_void, NULL, to);
+         if (rpc_stat == RPC_PROGVERSMISMATCH)
+           {
+             clnt_geterr (client, &rpcerr);
+             minvers = rpcerr.re_vers.low;
+             maxvers = rpcerr.re_vers.high;
+           }
+         else if (rpc_stat == RPC_SUCCESS)
+           {
+             /*
+              * It also supports version MAX_VERS.
+              * Looks like we have a wise guy.
+              * OK, we give them information on all
+              * 4 billion versions they support...
+              */
+             minvers = 0;
+             maxvers = MAX_VERS;
+           }
+         else
+           {
+             (void) pstatus (client, prognum, MAX_VERS);
+             exit (1);
+           }
        }
-       if (failure)
-               exit(1);
+      else
+       {
+         (void) pstatus (client, prognum, MIN_VERS);
+         exit (1);
+       }
+      clnt_destroy (client);
+      (void) close (sock);
+      sock = RPC_ANYSOCK;      /* Re-initialize it for later */
+      for (vers = minvers; vers <= maxvers; vers++)
+       {
+         addr.sin_port = htons (portnum);
+         if ((client = clnttcp_create (&addr, prognum, vers,
+                                       &sock, 0, 0)) == NULL)
+           {
+             clnt_pcreateerror ("rpcinfo");
+             printf (_ ("program %lu version %lu is not available\n"),
+                     prognum, vers);
+             exit (1);
+           }
+         to.tv_usec = 0;
+         to.tv_sec = 10;
+         rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL,
+                               (xdrproc_t) xdr_void, NULL, to);
+         if (pstatus (client, prognum, vers) < 0)
+           failure = 1;
+         clnt_destroy (client);
+         (void) close (sock);
+         sock = RPC_ANYSOCK;
+       }
+    }
+  else
+    {
+      vers = getvers (argv[2]);
+      addr.sin_port = htons (portnum);
+      if ((client = clnttcp_create (&addr, prognum, vers, &sock,
+                                   0, 0)) == NULL)
+       {
+         clnt_pcreateerror ("rpcinfo");
+         printf (_ ("program %lu version %lu is not available\n"),
+                 prognum, vers);
+         exit (1);
+       }
+      to.tv_usec = 0;
+      to.tv_sec = 10;
+      rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL,
+                           (xdrproc_t) xdr_void, NULL, to);
+      if (pstatus (client, prognum, vers) < 0)
+       failure = 1;
+    }
+  if (failure)
+    exit (1);
 }
 
 /*
@@ -449,90 +498,102 @@ tcpping(portnum, argc, argv)
  * a good error message.
  */
 static int
-pstatus(client, prognum, vers)
-       register CLIENT *client;
-       u_long prognum;
-       u_long vers;
+pstatus (client, prognum, vers)
+     register CLIENT *client;
+     u_long prognum;
+     u_long vers;
 {
-       struct rpc_err rpcerr;
-
-       clnt_geterr(client, &rpcerr);
-       if (rpcerr.re_status != RPC_SUCCESS) {
-               clnt_perror(client, "rpcinfo");
-               printf(_("program %lu version %lu is not available\n"),
-                   prognum, vers);
-               return (-1);
-       } else {
-               printf(_("program %lu version %lu ready and waiting\n"),
-                   prognum, vers);
-               return (0);
-       }
+  struct rpc_err rpcerr;
+
+  clnt_geterr (client, &rpcerr);
+  if (rpcerr.re_status != RPC_SUCCESS)
+    {
+      clnt_perror (client, "rpcinfo");
+      printf (_ ("program %lu version %lu is not available\n"),
+             prognum, vers);
+      return (-1);
+    }
+  else
+    {
+      printf (_ ("program %lu version %lu ready and waiting\n"),
+             prognum, vers);
+      return (0);
+    }
 }
 
 static void
-pmapdump(argc, argv)
-       int argc;
-       char **argv;
+pmapdump (argc, argv)
+     int argc;
+     char **argv;
 {
-       struct sockaddr_in server_addr;
-       register struct hostent *hp;
-       struct pmaplist *head = NULL;
-       int socket = RPC_ANYSOCK;
-       struct timeval minutetimeout;
-       register CLIENT *client;
-       struct rpcent *rpc;
-
-       if (argc > 1) {
-               usage();
-               exit(1);
-       }
-       if (argc == 1)
-               get_inet_address(&server_addr, argv[0]);
-       else {
-               bzero((char *)&server_addr, sizeof server_addr);
-               server_addr.sin_family = AF_INET;
-               if ((hp = gethostbyname("localhost")) != NULL)
-                       bcopy(hp->h_addr, (caddr_t)&server_addr.sin_addr,
-                           hp->h_length);
-               else
-                       server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
-       }
-       minutetimeout.tv_sec = 60;
-       minutetimeout.tv_usec = 0;
-       server_addr.sin_port = htons(PMAPPORT);
-       if ((client = clnttcp_create(&server_addr, PMAPPROG,
-           PMAPVERS, &socket, 50, 500)) == NULL) {
-               clnt_pcreateerror(_("rpcinfo: can't contact portmapper"));
-               exit(1);
-       }
-       if (clnt_call(client, PMAPPROC_DUMP, xdr_void, NULL,
-           xdr_pmaplist, &head, minutetimeout) != RPC_SUCCESS) {
-               fprintf(stderr, _("rpcinfo: can't contact portmapper: "));
-               clnt_perror(client, "rpcinfo");
-               exit(1);
-       }
-       if (head == NULL) {
-               printf(_("No remote programs registered.\n"));
-       } else {
-               printf(_("   program vers proto   port\n"));
-               for (; head != NULL; head = head->pml_next) {
-                       printf("%10ld%5ld",
-                           head->pml_map.pm_prog,
-                           head->pml_map.pm_vers);
-                       if (head->pml_map.pm_prot == IPPROTO_UDP)
-                               printf("%6s",  "udp");
-                       else if (head->pml_map.pm_prot == IPPROTO_TCP)
-                               printf("%6s", "tcp");
-                       else
-                               printf("%6ld",  head->pml_map.pm_prot);
-                       printf("%7ld",  head->pml_map.pm_port);
-                       rpc = getrpcbynumber(head->pml_map.pm_prog);
-                       if (rpc)
-                               printf("  %s\n", rpc->r_name);
-                       else
-                               printf("\n");
-               }
+  struct sockaddr_in server_addr;
+  register struct hostent *hp;
+  struct pmaplist *head = NULL;
+  int socket = RPC_ANYSOCK;
+  struct timeval minutetimeout;
+  register CLIENT *client;
+  struct rpcent *rpc;
+
+  if (argc > 1)
+    {
+      usage ();
+      exit (1);
+    }
+  if (argc == 1)
+    get_inet_address (&server_addr, argv[0]);
+  else
+    {
+      bzero ((char *) &server_addr, sizeof server_addr);
+      server_addr.sin_family = AF_INET;
+      if ((hp = gethostbyname ("localhost")) != NULL)
+       bcopy (hp->h_addr, (caddr_t) & server_addr.sin_addr,
+              hp->h_length);
+      else
+       server_addr.sin_addr.s_addr = inet_addr ("0.0.0.0");
+    }
+  minutetimeout.tv_sec = 60;
+  minutetimeout.tv_usec = 0;
+  server_addr.sin_port = htons (PMAPPORT);
+  if ((client = clnttcp_create (&server_addr, PMAPPROG,
+                               PMAPVERS, &socket, 50, 500)) == NULL)
+    {
+      clnt_pcreateerror (_ ("rpcinfo: can't contact portmapper"));
+      exit (1);
+    }
+  if (clnt_call (client, PMAPPROC_DUMP, (xdrproc_t) xdr_void, NULL,
+                (xdrproc_t) xdr_pmaplist, (caddr_t) &head,
+                minutetimeout) != RPC_SUCCESS)
+    {
+      fprintf (stderr, _ ("rpcinfo: can't contact portmapper: "));
+      clnt_perror (client, "rpcinfo");
+      exit (1);
+    }
+  if (head == NULL)
+    {
+      printf (_ ("No remote programs registered.\n"));
+    }
+  else
+    {
+      printf (_ ("   program vers proto   port\n"));
+      for (; head != NULL; head = head->pml_next)
+       {
+         printf ("%10ld%5ld",
+                 head->pml_map.pm_prog,
+                 head->pml_map.pm_vers);
+         if (head->pml_map.pm_prot == IPPROTO_UDP)
+           printf ("%6s", "udp");
+         else if (head->pml_map.pm_prot == IPPROTO_TCP)
+           printf ("%6s", "tcp");
+         else
+           printf ("%6ld", head->pml_map.pm_prot);
+         printf ("%7ld", head->pml_map.pm_port);
+         rpc = getrpcbynumber (head->pml_map.pm_prog);
+         if (rpc)
+           printf ("  %s\n", rpc->r_name);
+         else
+           printf ("\n");
        }
+    }
 }
 
 /*
@@ -541,126 +602,139 @@ pmapdump(argc, argv)
  * be piped through sort(1) and then uniq(1).
  */
 
-/*ARGSUSED*/
+/*ARGSUSED */
 static bool_t
-reply_proc(res, who)
-       void *res;              /* Nothing comes back */
-       struct sockaddr_in *who; /* Who sent us the reply */
+reply_proc (res, who)
+     void *res;                        /* Nothing comes back */
+     struct sockaddr_in *who;  /* Who sent us the reply */
 {
-       register struct hostent *hp;
+  register struct hostent *hp;
 
-       hp = gethostbyaddr((char *) &who->sin_addr, sizeof who->sin_addr,
-           AF_INET);
-       printf("%s %s\n", inet_ntoa(who->sin_addr),
-           (hp == NULL) ? _("(unknown)") : hp->h_name);
-       return(FALSE);
+  hp = gethostbyaddr ((char *) &who->sin_addr, sizeof who->sin_addr,
+                     AF_INET);
+  printf ("%s %s\n", inet_ntoa (who->sin_addr),
+         (hp == NULL) ? _ ("(unknown)") : hp->h_name);
+  return (FALSE);
 }
 
 static void
-brdcst(argc, argv)
-       int argc;
-       char **argv;
+brdcst (argc, argv)
+     int argc;
+     char **argv;
 {
-       enum clnt_stat rpc_stat;
-       u_long prognum, vers;
-
-       if (argc != 2) {
-               usage();
-               exit(1);
-       }
-       prognum = getprognum(argv[0]);
-       vers = getvers(argv[1]);
-       rpc_stat = clnt_broadcast(prognum, vers, NULLPROC, xdr_void,
-           (char *)NULL, xdr_void, (char *)NULL, reply_proc);
-       if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) {
-               fprintf(stderr, _("rpcinfo: broadcast failed: %s\n"),
-                   clnt_sperrno(rpc_stat));
-               exit(1);
-       }
-       exit(0);
+  enum clnt_stat rpc_stat;
+  u_long prognum, vers;
+
+  if (argc != 2)
+    {
+      usage ();
+      exit (1);
+    }
+  prognum = getprognum (argv[0]);
+  vers = getvers (argv[1]);
+  rpc_stat = clnt_broadcast (prognum, vers, NULLPROC, (xdrproc_t) xdr_void,
+                            NULL, (xdrproc_t) xdr_void, NULL,
+                            (resultproc_t) reply_proc);
+  if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT))
+    {
+      fprintf (stderr, _ ("rpcinfo: broadcast failed: %s\n"),
+              clnt_sperrno (rpc_stat));
+      exit (1);
+    }
+  exit (0);
 }
 
 static void
-deletereg(argc, argv)
-       int argc;
-       char **argv;
-{      u_long prog_num, version_num ;
-
-       if (argc != 2) {
-               usage() ;
-               exit(1) ;
-       }
-       if (getuid()) { /* This command allowed only to root */
-               fprintf(stderr, "Sorry. You are not root\n") ;
-               exit(1) ;
-       }
-       prog_num = getprognum(argv[0]);
-       version_num = getvers(argv[1]);
-       if ((pmap_unset(prog_num, version_num)) == 0) {
-               fprintf(stderr, _("rpcinfo: Could not delete registration for prog %s version %s\n"),
-                       argv[0], argv[1]) ;
-               exit(1) ;
-       }
+deletereg (argc, argv)
+     int argc;
+     char **argv;
+{
+  u_long prog_num, version_num;
+
+  if (argc != 2)
+    {
+      usage ();
+      exit (1);
+    }
+  if (getuid ())
+    {                          /* This command allowed only to root */
+      fprintf (stderr, "Sorry. You are not root\n");
+      exit (1);
+    }
+  prog_num = getprognum (argv[0]);
+  version_num = getvers (argv[1]);
+  if ((pmap_unset (prog_num, version_num)) == 0)
+    {
+      fprintf (stderr, _ ("rpcinfo: Could not delete registration for prog %s version %s\n"),
+              argv[0], argv[1]);
+      exit (1);
+    }
 }
 
 static void
-usage()
+usage ()
 {
-       fprintf(stderr, _("Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"));
-       fprintf(stderr, _("       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"));
-       fprintf(stderr, _("       rpcinfo -p [ host ]\n"));
-       fprintf(stderr, _("       rpcinfo -b prognum versnum\n"));
-       fprintf(stderr, _("       rpcinfo -d prognum versnum\n")) ;
+  fprintf (stderr, _ ("Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"));
+  fprintf (stderr, _ ("       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"));
+  fprintf (stderr, _ ("       rpcinfo -p [ host ]\n"));
+  fprintf (stderr, _ ("       rpcinfo -b prognum versnum\n"));
+  fprintf (stderr, _ ("       rpcinfo -d prognum versnum\n"));
 }
 
 static u_long
-getprognum(arg)
-       char *arg;
+getprognum (arg)
+     char *arg;
 {
-       register struct rpcent *rpc;
-       register u_long prognum;
-
-       if (isalpha(*arg)) {
-               rpc = getrpcbyname(arg);
-               if (rpc == NULL) {
-                       fprintf(stderr, _("rpcinfo: %s is unknown service\n"),
-                           arg);
-                       exit(1);
-               }
-               prognum = rpc->r_number;
-       } else {
-               prognum = (u_long) atoi(arg);
+  register struct rpcent *rpc;
+  register u_long prognum;
+
+  if (isalpha (*arg))
+    {
+      rpc = getrpcbyname (arg);
+      if (rpc == NULL)
+       {
+         fprintf (stderr, _ ("rpcinfo: %s is unknown service\n"),
+                  arg);
+         exit (1);
        }
-
-       return (prognum);
+      prognum = rpc->r_number;
+    }
+  else
+    {
+      prognum = (u_long) atoi (arg);
+    }
+
+  return (prognum);
 }
 
 static u_long
-getvers(arg)
-       char *arg;
+getvers (arg)
+     char *arg;
 {
-       register u_long vers;
+  register u_long vers;
 
-       vers = (int) atoi(arg);
-       return (vers);
+  vers = (int) atoi (arg);
+  return (vers);
 }
 
 static void
-get_inet_address(addr, host)
-       struct sockaddr_in *addr;
-       char *host;
+get_inet_address (addr, host)
+     struct sockaddr_in *addr;
+     char *host;
 {
-       register struct hostent *hp;
-
-       bzero((char *)addr, sizeof *addr);
-       addr->sin_addr.s_addr = (u_long) inet_addr(host);
-       if (addr->sin_addr.s_addr == -1 || addr->sin_addr.s_addr == 0) {
-               if ((hp = gethostbyname(host)) == NULL) {
-                       fprintf(stderr, _("rpcinfo: %s is unknown host\n"),
-                               host);
-                       exit(1);
-               }
-               bcopy(hp->h_addr, (char *)&addr->sin_addr, hp->h_length);
+  register struct hostent *hp;
+
+  bzero ((char *) addr, sizeof *addr);
+  addr->sin_addr.s_addr = (u_long) inet_addr (host);
+  if (addr->sin_addr.s_addr == -1 || addr->sin_addr.s_addr == 0)
+    {
+      if ((hp = gethostbyname (host)) == NULL)
+       {
+         fprintf (stderr, _ ("rpcinfo: %s is unknown host\n"),
+                  host);
+         exit (1);
        }
-       addr->sin_family = AF_INET;
+      bcopy (hp->h_addr, (char *) &addr->sin_addr, hp->h_length);
+    }
+  addr->sin_family = AF_INET;
 }
index fcd7b36..93d8bbd 100644 (file)
@@ -41,8 +41,9 @@ static char sccsid[] = "@(#)svc.c 1.41 87/10/13 Copyr 1984 Sun Micro";
  * Copyright (C) 1984, Sun Microsystems, Inc.
  */
 
-#include <sys/errno.h>
+#include <errno.h>
 #include <rpc/rpc.h>
+#include <rpc/svc.h>
 #include <rpc/pmap_clnt.h>
 
 #ifndef errno
@@ -58,7 +59,7 @@ static SVCXPRT *xports[NOFILE];
 #endif /* def FD_SETSIZE */
 
 #define NULL_SVC ((struct svc_callout *)0)
-#define        RQCRED_SIZE     400             /* this size is excessive */
+#define        RQCRED_SIZE     400     /* this size is excessive */
 
 /*
  * The services list
@@ -66,14 +67,16 @@ static SVCXPRT *xports[NOFILE];
  * The dispatch routine takes request structs and runs the
  * appropriate procedure.
  */
-static struct svc_callout {
-       struct svc_callout *sc_next;
-       u_long              sc_prog;
-       u_long              sc_vers;
-       void                (*sc_dispatch)();
-} *svc_head;
+static struct svc_callout
+  {
+    struct svc_callout *sc_next;
+    u_long sc_prog;
+    u_long sc_vers;
+    void (*sc_dispatch) (struct svc_req *, SVCXPRT *);
+  }
+ *svc_head;
 
-static struct svc_callout *svc_find();
+static struct svc_callout *svc_find (u_long, u_long, struct svc_callout **);
 
 /* ***************  SVCXPRT related stuff **************** */
 
@@ -81,25 +84,27 @@ static struct svc_callout *svc_find();
  * Activate a transport handle.
  */
 void
-xprt_register(xprt)
-       SVCXPRT *xprt;
+xprt_register (SVCXPRT *xprt)
 {
-       register int sock = xprt->xp_sock;
+  register int sock = xprt->xp_sock;
 
 #ifdef FD_SETSIZE
-       if (xports == NULL) {
-               xports = (SVCXPRT **)
-                       mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *));
-       }
-       if (sock < _rpc_dtablesize()) {
-               xports[sock] = xprt;
-               FD_SET(sock, &svc_fdset);
-       }
+  if (xports == NULL)
+    {
+      xports = (SVCXPRT **)
+       mem_alloc (FD_SETSIZE * sizeof (SVCXPRT *));
+    }
+  if (sock < _rpc_dtablesize ())
+    {
+      xports[sock] = xprt;
+      FD_SET (sock, &svc_fdset);
+    }
 #else
-       if (sock < NOFILE) {
-               xports[sock] = xprt;
-               svc_fds |= (1 << sock);
-       }
+  if (sock < NOFILE)
+    {
+      xports[sock] = xprt;
+      svc_fds |= (1 << sock);
+    }
 #endif /* def FD_SETSIZE */
 
 }
@@ -108,21 +113,23 @@ xprt_register(xprt)
  * De-activate a transport handle.
  */
 void
-xprt_unregister(xprt)
-       SVCXPRT *xprt;
+xprt_unregister (xprt)
+     SVCXPRT *xprt;
 {
-       register int sock = xprt->xp_sock;
+  register int sock = xprt->xp_sock;
 
 #ifdef FD_SETSIZE
-       if ((sock < _rpc_dtablesize()) && (xports[sock] == xprt)) {
-               xports[sock] = (SVCXPRT *)0;
-               FD_CLR(sock, &svc_fdset);
-       }
+  if ((sock < _rpc_dtablesize ()) && (xports[sock] == xprt))
+    {
+      xports[sock] = (SVCXPRT *) 0;
+      FD_CLR (sock, &svc_fdset);
+    }
 #else
-       if ((sock < NOFILE) && (xports[sock] == xprt)) {
-               xports[sock] = (SVCXPRT *)0;
-               svc_fds &= ~(1 << sock);
-       }
+  if ((sock < NOFILE) && (xports[sock] == xprt))
+    {
+      xports[sock] = (SVCXPRT *) 0;
+      svc_fds &= ~(1 << sock);
+    }
 #endif /* def FD_SETSIZE */
 }
 
@@ -135,60 +142,62 @@ xprt_unregister(xprt)
  * program number comes in.
  */
 bool_t
-svc_register(xprt, prog, vers, dispatch, protocol)
-       SVCXPRT *xprt;
-       u_long prog;
-       u_long vers;
-       void (*dispatch)();
-       int protocol;
+svc_register (SVCXPRT *xprt, u_long prog, u_long vers,
+             void (*dispatch) (struct svc_req *, SVCXPRT *), u_long protocol)
 {
-       struct svc_callout *prev;
-       register struct svc_callout *s;
-
-       if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) {
-               if (s->sc_dispatch == dispatch)
-                       goto pmap_it;  /* he is registering another xptr */
-               return (FALSE);
-       }
-       s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout));
-       if (s == (struct svc_callout *)0) {
-               return (FALSE);
-       }
-       s->sc_prog = prog;
-       s->sc_vers = vers;
-       s->sc_dispatch = dispatch;
-       s->sc_next = svc_head;
-       svc_head = s;
+  struct svc_callout *prev;
+  register struct svc_callout *s;
+
+  if ((s = svc_find (prog, vers, &prev)) != NULL_SVC)
+    {
+      if (s->sc_dispatch == dispatch)
+       goto pmap_it;           /* he is registering another xptr */
+      return FALSE;
+    }
+  s = (struct svc_callout *) mem_alloc (sizeof (struct svc_callout));
+  if (s == (struct svc_callout *) 0)
+    {
+      return FALSE;
+    }
+  s->sc_prog = prog;
+  s->sc_vers = vers;
+  s->sc_dispatch = dispatch;
+  s->sc_next = svc_head;
+  svc_head = s;
 pmap_it:
-       /* now register the information with the local binder service */
-       if (protocol) {
-               return (pmap_set(prog, vers, protocol, xprt->xp_port));
-       }
-       return (TRUE);
+  /* now register the information with the local binder service */
+  if (protocol)
+    {
+      return pmap_set (prog, vers, protocol, xprt->xp_port);
+    }
+  return TRUE;
 }
 
 /*
  * Remove a service program from the callout list.
  */
 void
-svc_unregister(prog, vers)
-       u_long prog;
-       u_long vers;
+svc_unregister (prog, vers)
+     u_long prog;
+     u_long vers;
 {
-       struct svc_callout *prev;
-       register struct svc_callout *s;
-
-       if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
-               return;
-       if (prev == NULL_SVC) {
-               svc_head = s->sc_next;
-       } else {
-               prev->sc_next = s->sc_next;
-       }
-       s->sc_next = NULL_SVC;
-       mem_free((char *) s, (u_int) sizeof(struct svc_callout));
-       /* now unregister the information with the local binder service */
-       (void)pmap_unset(prog, vers);
+  struct svc_callout *prev;
+  register struct svc_callout *s;
+
+  if ((s = svc_find (prog, vers, &prev)) == NULL_SVC)
+    return;
+  if (prev == NULL_SVC)
+    {
+      svc_head = s->sc_next;
+    }
+  else
+    {
+      prev->sc_next = s->sc_next;
+    }
+  s->sc_next = NULL_SVC;
+  mem_free ((char *) s, (u_int) sizeof (struct svc_callout));
+  /* now unregister the information with the local binder service */
+  (void) pmap_unset (prog, vers);
 }
 
 /*
@@ -196,22 +205,20 @@ svc_unregister(prog, vers)
  * struct.
  */
 static struct svc_callout *
-svc_find(prog, vers, prev)
-       u_long prog;
-       u_long vers;
-       struct svc_callout **prev;
+svc_find (u_long prog, u_long vers, struct svc_callout **prev)
 {
-       register struct svc_callout *s, *p;
-
-       p = NULL_SVC;
-       for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
-               if ((s->sc_prog == prog) && (s->sc_vers == vers))
-                       goto done;
-               p = s;
-       }
+  register struct svc_callout *s, *p;
+
+  p = NULL_SVC;
+  for (s = svc_head; s != NULL_SVC; s = s->sc_next)
+    {
+      if ((s->sc_prog == prog) && (s->sc_vers == vers))
+       goto done;
+      p = s;
+    }
 done:
-       *prev = p;
-       return (s);
+  *prev = p;
+  return s;
 }
 
 /* ******************* REPLY GENERATION ROUTINES  ************ */
@@ -220,132 +227,132 @@ done:
  * Send a reply to an rpc request
  */
 bool_t
-svc_sendreply(xprt, xdr_results, xdr_location)
-       register SVCXPRT *xprt;
-       xdrproc_t xdr_results;
-       caddr_t xdr_location;
+svc_sendreply (xprt, xdr_results, xdr_location)
+     register SVCXPRT *xprt;
+     xdrproc_t xdr_results;
+     caddr_t xdr_location;
 {
-       struct rpc_msg rply;
-
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_ACCEPTED;
-       rply.acpted_rply.ar_verf = xprt->xp_verf;
-       rply.acpted_rply.ar_stat = SUCCESS;
-       rply.acpted_rply.ar_results.where = xdr_location;
-       rply.acpted_rply.ar_results.proc = xdr_results;
-       return (SVC_REPLY(xprt, &rply));
+  struct rpc_msg rply;
+
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_ACCEPTED;
+  rply.acpted_rply.ar_verf = xprt->xp_verf;
+  rply.acpted_rply.ar_stat = SUCCESS;
+  rply.acpted_rply.ar_results.where = xdr_location;
+  rply.acpted_rply.ar_results.proc = xdr_results;
+  return SVC_REPLY (xprt, &rply);
 }
 
 /*
  * No procedure error reply
  */
 void
-svcerr_noproc(xprt)
-       register SVCXPRT *xprt;
+svcerr_noproc (xprt)
+     register SVCXPRT *xprt;
 {
-       struct rpc_msg rply;
+  struct rpc_msg rply;
 
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_ACCEPTED;
-       rply.acpted_rply.ar_verf = xprt->xp_verf;
-       rply.acpted_rply.ar_stat = PROC_UNAVAIL;
-       SVC_REPLY(xprt, &rply);
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_ACCEPTED;
+  rply.acpted_rply.ar_verf = xprt->xp_verf;
+  rply.acpted_rply.ar_stat = PROC_UNAVAIL;
+  SVC_REPLY (xprt, &rply);
 }
 
 /*
  * Can't decode args error reply
  */
 void
-svcerr_decode(xprt)
-       register SVCXPRT *xprt;
+svcerr_decode (xprt)
+     register SVCXPRT *xprt;
 {
-       struct rpc_msg rply;
+  struct rpc_msg rply;
 
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_ACCEPTED;
-       rply.acpted_rply.ar_verf = xprt->xp_verf;
-       rply.acpted_rply.ar_stat = GARBAGE_ARGS;
-       SVC_REPLY(xprt, &rply);
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_ACCEPTED;
+  rply.acpted_rply.ar_verf = xprt->xp_verf;
+  rply.acpted_rply.ar_stat = GARBAGE_ARGS;
+  SVC_REPLY (xprt, &rply);
 }
 
 /*
  * Some system error
  */
 void
-svcerr_systemerr(xprt)
-       register SVCXPRT *xprt;
+svcerr_systemerr (xprt)
+     register SVCXPRT *xprt;
 {
-       struct rpc_msg rply;
+  struct rpc_msg rply;
 
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_ACCEPTED;
-       rply.acpted_rply.ar_verf = xprt->xp_verf;
-       rply.acpted_rply.ar_stat = SYSTEM_ERR;
-       SVC_REPLY(xprt, &rply);
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_ACCEPTED;
+  rply.acpted_rply.ar_verf = xprt->xp_verf;
+  rply.acpted_rply.ar_stat = SYSTEM_ERR;
+  SVC_REPLY (xprt, &rply);
 }
 
 /*
  * Authentication error reply
  */
 void
-svcerr_auth(xprt, why)
-       SVCXPRT *xprt;
-       enum auth_stat why;
+svcerr_auth (xprt, why)
+     SVCXPRT *xprt;
+     enum auth_stat why;
 {
-       struct rpc_msg rply;
+  struct rpc_msg rply;
 
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_DENIED;
-       rply.rjcted_rply.rj_stat = AUTH_ERROR;
-       rply.rjcted_rply.rj_why = why;
-       SVC_REPLY(xprt, &rply);
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_DENIED;
+  rply.rjcted_rply.rj_stat = AUTH_ERROR;
+  rply.rjcted_rply.rj_why = why;
+  SVC_REPLY (xprt, &rply);
 }
 
 /*
  * Auth too weak error reply
  */
 void
-svcerr_weakauth(xprt)
-       SVCXPRT *xprt;
+svcerr_weakauth (xprt)
+     SVCXPRT *xprt;
 {
 
-       svcerr_auth(xprt, AUTH_TOOWEAK);
+  svcerr_auth (xprt, AUTH_TOOWEAK);
 }
 
 /*
  * Program unavailable error reply
  */
 void
-svcerr_noprog(xprt)
-       register SVCXPRT *xprt;
+svcerr_noprog (xprt)
+     register SVCXPRT *xprt;
 {
-       struct rpc_msg rply;
+  struct rpc_msg rply;
 
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_ACCEPTED;
-       rply.acpted_rply.ar_verf = xprt->xp_verf;
-       rply.acpted_rply.ar_stat = PROG_UNAVAIL;
-       SVC_REPLY(xprt, &rply);
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_ACCEPTED;
+  rply.acpted_rply.ar_verf = xprt->xp_verf;
+  rply.acpted_rply.ar_stat = PROG_UNAVAIL;
+  SVC_REPLY (xprt, &rply);
 }
 
 /*
  * Program version mismatch error reply
  */
 void
-svcerr_progvers(xprt, low_vers, high_vers)
-       register SVCXPRT *xprt;
-       u_long low_vers;
-       u_long high_vers;
+svcerr_progvers (xprt, low_vers, high_vers)
+     register SVCXPRT *xprt;
+     u_long low_vers;
+     u_long high_vers;
 {
-       struct rpc_msg rply;
-
-       rply.rm_direction = REPLY;
-       rply.rm_reply.rp_stat = MSG_ACCEPTED;
-       rply.acpted_rply.ar_verf = xprt->xp_verf;
-       rply.acpted_rply.ar_stat = PROG_MISMATCH;
-       rply.acpted_rply.ar_vers.low = low_vers;
-       rply.acpted_rply.ar_vers.high = high_vers;
-       SVC_REPLY(xprt, &rply);
+  struct rpc_msg rply;
+
+  rply.rm_direction = REPLY;
+  rply.rm_reply.rp_stat = MSG_ACCEPTED;
+  rply.acpted_rply.ar_verf = xprt->xp_verf;
+  rply.acpted_rply.ar_stat = PROG_MISMATCH;
+  rply.acpted_rply.ar_vers.low = low_vers;
+  rply.acpted_rply.ar_vers.high = high_vers;
+  SVC_REPLY (xprt, &rply);
 }
 
 /* ******************* SERVER INPUT STUFF ******************* */
@@ -367,115 +374,127 @@ svcerr_progvers(xprt, low_vers, high_vers)
  */
 
 void
-svc_getreq(rdfds)
-       int rdfds;
+svc_getreq (rdfds)
+     int rdfds;
 {
 #ifdef FD_SETSIZE
-       fd_set readfds;
+  fd_set readfds;
 
-       FD_ZERO(&readfds);
-       readfds.fds_bits[0] = rdfds;
-       svc_getreqset(&readfds);
+  FD_ZERO (&readfds);
+  readfds.fds_bits[0] = rdfds;
+  svc_getreqset (&readfds);
 #else
-       int readfds = rdfds & svc_fds;
+  int readfds = rdfds & svc_fds;
 
-       svc_getreqset(&readfds);
+  svc_getreqset (&readfds);
 #endif /* def FD_SETSIZE */
 }
 
 void
-svc_getreqset(readfds)
+svc_getreqset (readfds)
 #ifdef FD_SETSIZE
-       fd_set *readfds;
+     fd_set *readfds;
 {
 #else
-       int *readfds;
+     int *readfds;
 {
-    int readfds_local = *readfds;
+  int readfds_local = *readfds;
 #endif /* def FD_SETSIZE */
-       enum xprt_stat stat;
-       struct rpc_msg msg;
-       int prog_found;
-       u_long low_vers;
-       u_long high_vers;
-       struct svc_req r;
-       register SVCXPRT *xprt;
-       register u_long mask;
-       register int bit;
-       register u_int32_t *maskp;
-       register int setsize;
-       register int sock;
-       char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE];
-       msg.rm_call.cb_cred.oa_base = cred_area;
-       msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
-       r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);
+  enum xprt_stat stat;
+  struct rpc_msg msg;
+  int prog_found;
+  u_long low_vers;
+  u_long high_vers;
+  struct svc_req r;
+  register SVCXPRT *xprt;
+  register u_long mask;
+  register int bit;
+  register u_int32_t *maskp;
+  register int setsize;
+  register int sock;
+  char cred_area[2 * MAX_AUTH_BYTES + RQCRED_SIZE];
+  msg.rm_call.cb_cred.oa_base = cred_area;
+  msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
+  r.rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]);
 
 
 #ifdef FD_SETSIZE
-       setsize = _rpc_dtablesize();
-       maskp = (u_int32_t *)readfds->fds_bits;
-       for (sock = 0; sock < setsize; sock += 32) {
-           for (mask = *maskp++; bit = ffs(mask); mask ^= (1 << (bit - 1))) {
-               /* sock has input waiting */
-               xprt = xports[sock + bit - 1];
+  setsize = _rpc_dtablesize ();
+  maskp = (u_int32_t *) readfds->fds_bits;
+  for (sock = 0; sock < setsize; sock += 32)
+    {
+      for (mask = *maskp++; bit = ffs (mask); mask ^= (1 << (bit - 1)))
+       {
+         /* sock has input waiting */
+         xprt = xports[sock + bit - 1];
 #else
-       for (sock = 0; readfds_local != 0; sock++, readfds_local >>= 1) {
-           if ((readfds_local & 1) != 0) {
-               /* sock has input waiting */
-               xprt = xports[sock];
+  for (sock = 0; readfds_local != 0; sock++, readfds_local >>= 1)
+    {
+      if ((readfds_local & 1) != 0)
+       {
+         /* sock has input waiting */
+         xprt = xports[sock];
 #endif /* def FD_SETSIZE */
-               /* now receive msgs from xprtprt (support batch calls) */
-               do {
-                       if (SVC_RECV(xprt, &msg)) {
-
-                               /* now find the exported program and call it */
-                               register struct svc_callout *s;
-                               enum auth_stat why;
-
-                               r.rq_xprt = xprt;
-                               r.rq_prog = msg.rm_call.cb_prog;
-                               r.rq_vers = msg.rm_call.cb_vers;
-                               r.rq_proc = msg.rm_call.cb_proc;
-                               r.rq_cred = msg.rm_call.cb_cred;
-                               /* first authenticate the message */
-                               if ((why= _authenticate(&r, &msg)) != AUTH_OK) {
-                                       svcerr_auth(xprt, why);
-                                       goto call_done;
-                               }
-                               /* now match message with a registered service*/
-                               prog_found = FALSE;
-                               low_vers = 0 - 1;
-                               high_vers = 0;
-                               for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
-                                       if (s->sc_prog == r.rq_prog) {
-                                               if (s->sc_vers == r.rq_vers) {
-                                                       (*s->sc_dispatch)(&r, xprt);
-                                                       goto call_done;
-                                               }  /* found correct version */
-                                               prog_found = TRUE;
-                                               if (s->sc_vers < low_vers)
-                                                       low_vers = s->sc_vers;
-                                               if (s->sc_vers > high_vers)
-                                                       high_vers = s->sc_vers;
-                                       }   /* found correct program */
-                               }
-                               /*
-                                * if we got here, the program or version
-                                * is not served ...
-                                */
-                               if (prog_found)
-                                       svcerr_progvers(xprt,
-                                       low_vers, high_vers);
-                               else
-                                        svcerr_noprog(xprt);
-                               /* Fall through to ... */
-                       }
-               call_done:
-                       if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
-                               SVC_DESTROY(xprt);
-                               break;
-                       }
-               } while (stat == XPRT_MOREREQS);
+         /* now receive msgs from xprtprt (support batch calls) */
+         do
+           {
+             if (SVC_RECV (xprt, &msg))
+               {
+
+                 /* now find the exported program and call it */
+                 register struct svc_callout *s;
+                 enum auth_stat why;
+
+                 r.rq_xprt = xprt;
+                 r.rq_prog = msg.rm_call.cb_prog;
+                 r.rq_vers = msg.rm_call.cb_vers;
+                 r.rq_proc = msg.rm_call.cb_proc;
+                 r.rq_cred = msg.rm_call.cb_cred;
+                 /* first authenticate the message */
+                 if ((why = _authenticate (&r, &msg)) != AUTH_OK)
+                   {
+                     svcerr_auth (xprt, why);
+                     goto call_done;
+                   }
+                 /* now match message with a registered service */
+                 prog_found = FALSE;
+                 low_vers = 0 - 1;
+                 high_vers = 0;
+                 for (s = svc_head; s != NULL_SVC; s = s->sc_next)
+                   {
+                     if (s->sc_prog == r.rq_prog)
+                       {
+                         if (s->sc_vers == r.rq_vers)
+                           {
+                             (*s->sc_dispatch) (&r, xprt);
+                             goto call_done;
+                           }   /* found correct version */
+                         prog_found = TRUE;
+                         if (s->sc_vers < low_vers)
+                           low_vers = s->sc_vers;
+                         if (s->sc_vers > high_vers)
+                           high_vers = s->sc_vers;
+                       }       /* found correct program */
+                   }
+                 /*
+                  * if we got here, the program or version
+                  * is not served ...
+                  */
+                 if (prog_found)
+                   svcerr_progvers (xprt,
+                                    low_vers, high_vers);
+                 else
+                   svcerr_noprog (xprt);
+                 /* Fall through to ... */
+               }
+           call_done:
+             if ((stat = SVC_STAT (xprt)) == XPRT_DIED)
+               {
+                 SVC_DESTROY (xprt);
+                 break;
+               }
            }
+         while (stat == XPRT_MOREREQS);
        }
+    }
 }
index b650de9..9f7ed5e 100644 (file)
@@ -1,6 +1,4 @@
-#if !defined(lint) && defined(SCCSIDS)
-static char sccsid[] = "@(#)svc_auth.c 2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/11 Copyr 1984 Sun Micro";
-#endif
+/* @(#)svc_auth.c       2.4 88/08/15 4.0 RPCSRC */
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
@@ -29,15 +27,20 @@ static char sccsid[] = "@(#)svc_auth.c      2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/
  * 2550 Garcia Avenue
  * Mountain View, California  94043
  */
+#if !defined(lint) && defined(SCCSIDS)
+static char sccsid[] = "@(#)svc_auth.c 1.19 87/08/11 Copyr 1984 Sun Micro";
+#endif
 
 /*
- * svc_auth_nodes.c, Server-side rpc authenticator interface,
+ * svc_auth.c, Server-side rpc authenticator interface.
  * *WITHOUT* DES authentication.
  *
  * Copyright (C) 1984, Sun Microsystems, Inc.
  */
 
 #include <rpc/rpc.h>
+#include <rpc/svc.h>
+#include <rpc/svc_auth.h>
 
 /*
  * svcauthsw is the bdevsw of server side authentication.
@@ -47,25 +50,31 @@ static char sccsid[] = "@(#)svc_auth.c      2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/
  * The server auth flavors must implement a routine that looks
  * like:
  *
- *     enum auth_stat
- *     flavorx_auth(rqst, msg)
- *             register struct svc_req *rqst;
- *             register struct rpc_msg *msg;
+ *      enum auth_stat
+ *      flavorx_auth(rqst, msg)
+ *              register struct svc_req *rqst;
+ *              register struct rpc_msg *msg;
  *
  */
 
-enum auth_stat _svcauth_null();                /* no authentication */
-enum auth_stat _svcauth_unix();                /* unix style (uid, gids) */
-enum auth_stat _svcauth_short();       /* short hand unix style */
+static enum auth_stat _svcauth_null (struct svc_req *, struct rpc_msg *);
+                               /* no authentication */
+extern enum auth_stat _svcauth_unix (struct svc_req *, struct rpc_msg *);
+                               /* unix style (uid, gids) */
+extern enum auth_stat _svcauth_short (struct svc_req *, struct rpc_msg *);
+                               /* short hand unix style */
 
-static struct {
-       enum auth_stat (*authenticator)();
-} svcauthsw[] = {
-       _svcauth_null,                  /* AUTH_NULL */
-       _svcauth_unix,                  /* AUTH_UNIX */
-       _svcauth_short,                 /* AUTH_SHORT */
+static const struct
+  {
+    enum auth_stat (*authenticator) (struct svc_req *, struct rpc_msg *);
+  }
+svcauthsw[] =
+{
+  { _svcauth_null },           /* AUTH_NULL */
+  { _svcauth_unix },           /* AUTH_UNIX */
+  { _svcauth_short }           /* AUTH_SHORT */
 };
-#define        AUTH_MAX        2               /* HIGHEST AUTH NUMBER */
+#define        AUTH_MAX        2       /* HIGHEST AUTH NUMBER */
 
 
 /*
@@ -87,28 +96,22 @@ static struct {
  * invalid.
  */
 enum auth_stat
-_authenticate(rqst, msg)
-       register struct svc_req *rqst;
-       struct rpc_msg *msg;
+_authenticate (register struct svc_req *rqst, struct rpc_msg *msg)
 {
-       register int cred_flavor;
+  register int cred_flavor;
 
-       rqst->rq_cred = msg->rm_call.cb_cred;
-       rqst->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
-       rqst->rq_xprt->xp_verf.oa_length = 0;
-       cred_flavor = rqst->rq_cred.oa_flavor;
-       if ((cred_flavor <= AUTH_MAX) && (cred_flavor >= AUTH_NULL)) {
-               return ((*(svcauthsw[cred_flavor].authenticator))(rqst, msg));
-       }
+  rqst->rq_cred = msg->rm_call.cb_cred;
+  rqst->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
+  rqst->rq_xprt->xp_verf.oa_length = 0;
+  cred_flavor = rqst->rq_cred.oa_flavor;
+  if ((cred_flavor <= AUTH_MAX) && (cred_flavor >= AUTH_NULL))
+    return (*(svcauthsw[cred_flavor].authenticator)) (rqst, msg);
 
-       return (AUTH_REJECTEDCRED);
+  return AUTH_REJECTEDCRED;
 }
 
-enum auth_stat
-_svcauth_null(/*rqst, msg*/)
-       /*struct svc_req *rqst;
-       struct rpc_msg *msg;*/
+static enum auth_stat
+_svcauth_null (struct svc_req *rqst, struct rpc_msg *msg)
 {
-
-       return (AUTH_OK);
+  return AUTH_OK;
 }
index 59fdde6..04cff9c 100644 (file)
@@ -43,80 +43,89 @@ static char sccsid[] = "@(#)svc_auth_unix.c 1.28 88/02/08 Copyr 1984 Sun Micro";
  */
 
 #include <stdio.h>
+#include <string.h>
 #include <rpc/rpc.h>
+#include <rpc/svc.h>
 
 /*
  * Unix longhand authenticator
  */
 enum auth_stat
-_svcauth_unix(rqst, msg)
-       register struct svc_req *rqst;
-       register struct rpc_msg *msg;
+_svcauth_unix (struct svc_req *rqst, struct rpc_msg *msg)
 {
-       register enum auth_stat stat;
-       XDR xdrs;
-       register struct authunix_parms *aup;
-       register long *buf;
-       struct area {
-               struct authunix_parms area_aup;
-               char area_machname[MAX_MACHINE_NAME+1];
-               gid_t area_gids[NGRPS];
-       } *area;
-       u_int auth_len;
-       int str_len, gid_len;
-       register int i;
+  enum auth_stat stat;
+  XDR xdrs;
+  struct authunix_parms *aup;
+  long *buf;
+  struct area
+    {
+      struct authunix_parms area_aup;
+      char area_machname[MAX_MACHINE_NAME + 1];
+      gid_t area_gids[NGRPS];
+    }
+   *area;
+  u_int auth_len;
+  u_int str_len, gid_len;
+  u_int i;
 
-       area = (struct area *) rqst->rq_clntcred;
-       aup = &area->area_aup;
-       aup->aup_machname = area->area_machname;
-       aup->aup_gids = area->area_gids;
-       auth_len = (u_int)msg->rm_call.cb_cred.oa_length;
-       xdrmem_create(&xdrs, msg->rm_call.cb_cred.oa_base, auth_len,XDR_DECODE);
-       buf = XDR_INLINE(&xdrs, auth_len);
-       if (buf != NULL) {
-               aup->aup_time = IXDR_GET_LONG(buf);
-               str_len = IXDR_GET_U_LONG(buf);
-               if (str_len > MAX_MACHINE_NAME) {
-                       stat = AUTH_BADCRED;
-                       goto done;
-               }
-               bcopy((caddr_t)buf, aup->aup_machname, (u_int)str_len);
-               aup->aup_machname[str_len] = 0;
-               str_len = RNDUP(str_len);
-               buf = (u_long *) ((char *) buf + str_len);
-               aup->aup_uid = IXDR_GET_LONG(buf);
-               aup->aup_gid = IXDR_GET_LONG(buf);
-               gid_len = IXDR_GET_U_LONG(buf);
-               if (gid_len > NGRPS) {
-                       stat = AUTH_BADCRED;
-                       goto done;
-               }
-               aup->aup_len = gid_len;
-               for (i = 0; i < gid_len; i++) {
-                       aup->aup_gids[i] = IXDR_GET_LONG(buf);
-               }
-               /*
-                * five is the smallest unix credentials structure -
-                * timestamp, hostname len (0), uid, gid, and gids len (0).
-                */
-               if ((5 + gid_len) * BYTES_PER_XDR_UNIT + str_len > auth_len) {
-                       (void) printf("bad auth_len gid %d str %d auth %d\n",
-                           gid_len, str_len, auth_len);
-                       stat = AUTH_BADCRED;
-                       goto done;
-               }
-       } else if (! xdr_authunix_parms(&xdrs, aup)) {
-               xdrs.x_op = XDR_FREE;
-               (void)xdr_authunix_parms(&xdrs, aup);
-               stat = AUTH_BADCRED;
-               goto done;
+  area = (struct area *) rqst->rq_clntcred;
+  aup = &area->area_aup;
+  aup->aup_machname = area->area_machname;
+  aup->aup_gids = area->area_gids;
+  auth_len = (u_int) msg->rm_call.cb_cred.oa_length;
+  xdrmem_create (&xdrs, msg->rm_call.cb_cred.oa_base, auth_len, XDR_DECODE);
+  buf = XDR_INLINE (&xdrs, auth_len);
+  if (buf != NULL)
+    {
+      aup->aup_time = IXDR_GET_LONG (buf);
+      str_len = IXDR_GET_U_LONG (buf);
+      if (str_len > MAX_MACHINE_NAME)
+       {
+         stat = AUTH_BADCRED;
+         goto done;
        }
-       rqst->rq_xprt->xp_verf.oa_flavor = AUTH_NULL;
-       rqst->rq_xprt->xp_verf.oa_length = 0;
-       stat = AUTH_OK;
+      bcopy ((caddr_t) buf, aup->aup_machname, (u_int) str_len);
+      aup->aup_machname[str_len] = 0;
+      str_len = RNDUP (str_len);
+      buf = (u_long *) ((char *) buf + str_len);
+      aup->aup_uid = IXDR_GET_LONG (buf);
+      aup->aup_gid = IXDR_GET_LONG (buf);
+      gid_len = IXDR_GET_U_LONG (buf);
+      if (gid_len > NGRPS)
+       {
+         stat = AUTH_BADCRED;
+         goto done;
+       }
+      aup->aup_len = gid_len;
+      for (i = 0; i < gid_len; i++)
+       {
+         aup->aup_gids[i] = IXDR_GET_LONG (buf);
+       }
+      /*
+       * five is the smallest unix credentials structure -
+       * timestamp, hostname len (0), uid, gid, and gids len (0).
+       */
+      if ((5 + gid_len) * BYTES_PER_XDR_UNIT + str_len > auth_len)
+       {
+         (void) printf ("bad auth_len gid %d str %d auth %d\n",
+                        gid_len, str_len, auth_len);
+         stat = AUTH_BADCRED;
+         goto done;
+       }
+    }
+  else if (!xdr_authunix_parms (&xdrs, aup))
+    {
+      xdrs.x_op = XDR_FREE;
+      (void) xdr_authunix_parms (&xdrs, aup);
+      stat = AUTH_BADCRED;
+      goto done;
+    }
+  rqst->rq_xprt->xp_verf.oa_flavor = AUTH_NULL;
+  rqst->rq_xprt->xp_verf.oa_length = 0;
+  stat = AUTH_OK;
 done:
-       XDR_DESTROY(&xdrs);
-       return (stat);
+  XDR_DESTROY (&xdrs);
+  return stat;
 }
 
 
@@ -124,11 +133,9 @@ done:
  * Shorthand unix authenticator
  * Looks up longhand in a cache.
  */
-/*ARGSUSED*/
+/*ARGSUSED */
 enum auth_stat
-_svcauth_short(rqst, msg)
-       struct svc_req *rqst;
-       struct rpc_msg *msg;
+_svcauth_short (struct svc_req *rqst, struct rpc_msg *msg)
 {
-       return (AUTH_REJECTEDCRED);
+  return AUTH_REJECTEDCRED;
 }
index 1b6cb3b..1a7fcaa 100644 (file)
@@ -41,126 +41,121 @@ static char sccsid[] = "@(#)svc_raw.c 1.15 87/08/11 Copyr 1984 Sun Micro";
  */
 
 #include <rpc/rpc.h>
-
+#include <rpc/svc.h>
 
 /*
  * This is the "network" that we will be moving data over
  */
-static struct svcraw_private {
-       char    _raw_buf[UDPMSGSIZE];
-       SVCXPRT server;
-       XDR     xdr_stream;
-       char    verf_body[MAX_AUTH_BYTES];
-} *svcraw_private;
-
-static bool_t          svcraw_recv();
-static enum xprt_stat  svcraw_stat();
-static bool_t          svcraw_getargs();
-static bool_t          svcraw_reply();
-static bool_t          svcraw_freeargs();
-static void            svcraw_destroy();
-
-static struct xp_ops server_ops = {
-       svcraw_recv,
-       svcraw_stat,
-       svcraw_getargs,
-       svcraw_reply,
-       svcraw_freeargs,
-       svcraw_destroy
+static struct svcraw_private
+  {
+    char _raw_buf[UDPMSGSIZE];
+    SVCXPRT server;
+    XDR xdr_stream;
+    char verf_body[MAX_AUTH_BYTES];
+  }
+ *svcraw_private;
+
+static bool_t svcraw_recv (SVCXPRT *, struct rpc_msg *);
+static enum xprt_stat svcraw_stat (SVCXPRT *);
+static bool_t svcraw_getargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svcraw_reply (SVCXPRT *, struct rpc_msg *);
+static bool_t svcraw_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
+static void svcraw_destroy (SVCXPRT *);
+
+static struct xp_ops server_ops =
+{
+  svcraw_recv,
+  svcraw_stat,
+  svcraw_getargs,
+  svcraw_reply,
+  svcraw_freeargs,
+  svcraw_destroy
 };
 
 SVCXPRT *
-svcraw_create()
+svcraw_create (void)
 {
-       register struct svcraw_private *srp = svcraw_private;
-
-       if (srp == 0) {
-               srp = (struct svcraw_private *)calloc(1, sizeof (*srp));
-               if (srp == 0)
-                       return (0);
-       }
-       srp->server.xp_sock = 0;
-       srp->server.xp_port = 0;
-       srp->server.xp_ops = &server_ops;
-       srp->server.xp_verf.oa_base = srp->verf_body;
-       xdrmem_create(&srp->xdr_stream, srp->_raw_buf, UDPMSGSIZE, XDR_FREE);
-       return (&srp->server);
+  struct svcraw_private *srp = svcraw_private;
+
+  if (srp == 0)
+    {
+      srp = (struct svcraw_private *) calloc (1, sizeof (*srp));
+      if (srp == 0)
+       return NULL;
+    }
+  srp->server.xp_sock = 0;
+  srp->server.xp_port = 0;
+  srp->server.xp_ops = &server_ops;
+  srp->server.xp_verf.oa_base = srp->verf_body;
+  xdrmem_create (&srp->xdr_stream, srp->_raw_buf, UDPMSGSIZE, XDR_FREE);
+  return &srp->server;
 }
 
 static enum xprt_stat
-svcraw_stat()
+svcraw_stat (SVCXPRT *xprt)
 {
-
-       return (XPRT_IDLE);
+  return XPRT_IDLE;
 }
 
 static bool_t
-svcraw_recv(xprt, msg)
-       SVCXPRT *xprt;
-       struct rpc_msg *msg;
+svcraw_recv (xprt, msg)
+     SVCXPRT *xprt;
+     struct rpc_msg *msg;
 {
-       register struct svcraw_private *srp = svcraw_private;
-       register XDR *xdrs;
-
-       if (srp == 0)
-               return (0);
-       xdrs = &srp->xdr_stream;
-       xdrs->x_op = XDR_DECODE;
-       XDR_SETPOS(xdrs, 0);
-       if (! xdr_callmsg(xdrs, msg))
-              return (FALSE);
-       return (TRUE);
+  struct svcraw_private *srp = svcraw_private;
+  XDR *xdrs;
+
+  if (srp == 0)
+    return FALSE;
+  xdrs = &srp->xdr_stream;
+  xdrs->x_op = XDR_DECODE;
+  XDR_SETPOS (xdrs, 0);
+  if (!xdr_callmsg (xdrs, msg))
+    return FALSE;
+  return TRUE;
 }
 
 static bool_t
-svcraw_reply(xprt, msg)
-       SVCXPRT *xprt;
-       struct rpc_msg *msg;
+svcraw_reply (SVCXPRT *xprt, struct rpc_msg *msg)
 {
-       register struct svcraw_private *srp = svcraw_private;
-       register XDR *xdrs;
-
-       if (srp == 0)
-               return (FALSE);
-       xdrs = &srp->xdr_stream;
-       xdrs->x_op = XDR_ENCODE;
-       XDR_SETPOS(xdrs, 0);
-       if (! xdr_replymsg(xdrs, msg))
-              return (FALSE);
-       (void)XDR_GETPOS(xdrs);  /* called just for overhead */
-       return (TRUE);
+  struct svcraw_private *srp = svcraw_private;
+  XDR *xdrs;
+
+  if (srp == 0)
+    return FALSE;
+  xdrs = &srp->xdr_stream;
+  xdrs->x_op = XDR_ENCODE;
+  XDR_SETPOS (xdrs, 0);
+  if (!xdr_replymsg (xdrs, msg))
+    return FALSE;
+  (void) XDR_GETPOS (xdrs);    /* called just for overhead */
+  return TRUE;
 }
 
 static bool_t
-svcraw_getargs(xprt, xdr_args, args_ptr)
-       SVCXPRT *xprt;
-       xdrproc_t xdr_args;
-       caddr_t args_ptr;
+svcraw_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 {
-       register struct svcraw_private *srp = svcraw_private;
+  struct svcraw_private *srp = svcraw_private;
 
-       if (srp == 0)
-               return (FALSE);
-       return ((*xdr_args)(&srp->xdr_stream, args_ptr));
+  if (srp == 0)
+    return FALSE;
+  return (*xdr_args) (&srp->xdr_stream, args_ptr);
 }
 
 static bool_t
-svcraw_freeargs(xprt, xdr_args, args_ptr)
-       SVCXPRT *xprt;
-       xdrproc_t xdr_args;
-       caddr_t args_ptr;
+svcraw_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 {
-       register struct svcraw_private *srp = svcraw_private;
-       register XDR *xdrs;
-
-       if (srp == 0)
-               return (FALSE);
-       xdrs = &srp->xdr_stream;
-       xdrs->x_op = XDR_FREE;
-       return ((*xdr_args)(xdrs, args_ptr));
+  struct svcraw_private *srp = svcraw_private;
+  XDR *xdrs;
+
+  if (srp == 0)
+    return FALSE;
+  xdrs = &srp->xdr_stream;
+  xdrs->x_op = XDR_FREE;
+  return (*xdr_args) (xdrs, args_ptr);
 }
 
 static void
-svcraw_destroy()
+svcraw_destroy (SVCXPRT *xprt)
 {
 }
index 45ea400..0f59637 100644 (file)
@@ -36,39 +36,39 @@ static char sccsid[] = "@(#)svc_run.c 1.1 87/10/13 Copyr 1984 Sun Micro";
  * This is the rpc server side idle loop
  * Wait for input, call server program.
  */
+#include <errno.h>
 #include <rpc/rpc.h>
-#include <sys/errno.h>
 
 void
-svc_run()
+svc_run (void)
 {
 #ifdef FD_SETSIZE
-       fd_set readfds;
+  fd_set readfds;
 #else
-      int readfds;
+  int readfds;
 #endif /* def FD_SETSIZE */
-#ifndef errno
-       extern int errno;
-#endif
 
-       for (;;) {
+  for (;;)
+    {
 #ifdef FD_SETSIZE
-               readfds = svc_fdset;
+      readfds = svc_fdset;
 #else
-               readfds = svc_fds;
+      readfds = svc_fds;
 #endif /* def FD_SETSIZE */
-               switch (select(_rpc_dtablesize(), &readfds, (int *)0, (int *)0,
-                              (struct timeval *)0)) {
-               case -1:
-                       if (errno == EINTR) {
-                               continue;
-                       }
-                       perror("svc_run: - select failed");
-                       return;
-               case 0:
-                       continue;
-               default:
-                       svc_getreqset(&readfds);
-               }
+      switch (select (_rpc_dtablesize (), &readfds, (fd_set *)NULL,
+                     (fd_set *)NULL, (struct timeval *) 0))
+       {
+       case -1:
+         if (errno == EINTR)
+           {
+             continue;
+           }
+         perror (_("svc_run: - select failed"));
+         return;
+       case 0:
+         continue;
+       default:
+         svc_getreqset (&readfds);
        }
+    }
 }
index 0a30c45..cc28f6a 100644 (file)
@@ -39,105 +39,117 @@ static char sccsid[] = "@(#)svc_simple.c 1.18 87/08/11 Copyr 1984 Sun Micro";
  */
 
 #include <stdio.h>
+#include <string.h>
 #include <rpc/rpc.h>
+#include <rpc/pmap_clnt.h>
 #include <sys/socket.h>
 #include <netdb.h>
 
-static struct proglst {
-       char *(*p_progname)();
-       int  p_prognum;
-       int  p_procnum;
-       xdrproc_t p_inproc, p_outproc;
-       struct proglst *p_nxt;
-} *proglst;
-static void universal();
+static struct proglst
+  {
+    char *(*p_progname) (char *);
+    int p_prognum;
+    int p_procnum;
+    xdrproc_t p_inproc, p_outproc;
+    struct proglst *p_nxt;
+  }
+ *proglst;
+
+static void universal (struct svc_req *rqstp, SVCXPRT *transp);
 static SVCXPRT *transp;
 
-registerrpc(prognum, versnum, procnum, progname, inproc, outproc)
-       char *(*progname)();
-       xdrproc_t inproc, outproc;
+int
+registerrpc (u_long prognum, u_long versnum, u_long procnum,
+            char *(*progname) (char *), xdrproc_t inproc, xdrproc_t outproc)
 {
-       struct proglst *pl;
+  struct proglst *pl;
 
-       if (procnum == NULLPROC) {
-               (void) fprintf(stderr,
-                   _("can't reassign procedure number %d\n"), NULLPROC);
-               return (-1);
-       }
-       if (transp == 0) {
-               transp = svcudp_create(RPC_ANYSOCK);
-               if (transp == NULL) {
-                       (void) fprintf(stderr, _("couldn't create an rpc server\n"));
-                       return (-1);
-               }
-       }
-       (void) pmap_unset((u_long)prognum, (u_long)versnum);
-       if (!svc_register(transp, (u_long)prognum, (u_long)versnum,
-           universal, IPPROTO_UDP)) {
-               (void) fprintf(stderr, _("couldn't register prog %d vers %d\n"),
-                   prognum, versnum);
-               return (-1);
+  if (procnum == NULLPROC)
+    {
+      (void) fprintf (stderr,
+                     _("can't reassign procedure number %d\n"), NULLPROC);
+      return -1;
+    }
+  if (transp == 0)
+    {
+      transp = svcudp_create (RPC_ANYSOCK);
+      if (transp == NULL)
+       {
+         (void) fputs (_("couldn't create an rpc server\n"), stderr);
+         return -1;
        }
-       pl = (struct proglst *)malloc(sizeof(struct proglst));
-       if (pl == NULL) {
-               (void) fprintf(stderr, _("registerrpc: out of memory\n"));
-               return (-1);
-       }
-       pl->p_progname = progname;
-       pl->p_prognum = prognum;
-       pl->p_procnum = procnum;
-       pl->p_inproc = inproc;
-       pl->p_outproc = outproc;
-       pl->p_nxt = proglst;
-       proglst = pl;
-       return (0);
+    }
+  (void) pmap_unset ((u_long) prognum, (u_long) versnum);
+  if (!svc_register (transp, (u_long) prognum, (u_long) versnum,
+                    universal, IPPROTO_UDP))
+    {
+      (void) fprintf (stderr, _("couldn't register prog %d vers %d\n"),
+                     prognum, versnum);
+      return -1;
+    }
+  pl = (struct proglst *) malloc (sizeof (struct proglst));
+  if (pl == NULL)
+    {
+      (void) fprintf (stderr, _("registerrpc: out of memory\n"));
+      return -1;
+    }
+  pl->p_progname = progname;
+  pl->p_prognum = prognum;
+  pl->p_procnum = procnum;
+  pl->p_inproc = inproc;
+  pl->p_outproc = outproc;
+  pl->p_nxt = proglst;
+  proglst = pl;
+  return 0;
 }
 
 static void
-universal(rqstp, transp)
-       struct svc_req *rqstp;
-       SVCXPRT *transp;
+universal (struct svc_req *rqstp, SVCXPRT *transp)
 {
-       int prog, proc;
-       char *outdata;
-       char xdrbuf[UDPMSGSIZE];
-       struct proglst *pl;
+  int prog, proc;
+  char *outdata;
+  char xdrbuf[UDPMSGSIZE];
+  struct proglst *pl;
 
-       /*
-        * enforce "procnum 0 is echo" convention
-        */
-       if (rqstp->rq_proc == NULLPROC) {
-               if (svc_sendreply(transp, xdr_void, (char *)NULL) == FALSE) {
-                       (void) fprintf(stderr, "xxx\n");
-                       exit(1);
-               }
-               return;
+  /*
+   * enforce "procnum 0 is echo" convention
+   */
+  if (rqstp->rq_proc == NULLPROC)
+    {
+      if (svc_sendreply (transp, (xdrproc_t)xdr_void, (char *) NULL) == FALSE)
+       {
+         (void) fprintf (stderr, "xxx\n");
+         exit (1);
        }
-       prog = rqstp->rq_prog;
-       proc = rqstp->rq_proc;
-       for (pl = proglst; pl != NULL; pl = pl->p_nxt)
-               if (pl->p_prognum == prog && pl->p_procnum == proc) {
-                       /* decode arguments into a CLEAN buffer */
-                       bzero(xdrbuf, sizeof(xdrbuf)); /* required ! */
-                       if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) {
-                               svcerr_decode(transp);
-                               return;
-                       }
-                       outdata = (*(pl->p_progname))(xdrbuf);
-                       if (outdata == NULL && pl->p_outproc != xdr_void)
-                               /* there was an error */
-                               return;
-                       if (!svc_sendreply(transp, pl->p_outproc, outdata)) {
-                               (void) fprintf(stderr,
-                                   _("trouble replying to prog %d\n"),
-                                   pl->p_prognum);
-                               exit(1);
-                       }
-                       /* free the decoded arguments */
-                       (void)svc_freeargs(transp, pl->p_inproc, xdrbuf);
-                       return;
-               }
-       (void) fprintf(stderr, _("never registered prog %d\n"), prog);
-       exit(1);
+      return;
+    }
+  prog = rqstp->rq_prog;
+  proc = rqstp->rq_proc;
+  for (pl = proglst; pl != NULL; pl = pl->p_nxt)
+    if (pl->p_prognum == prog && pl->p_procnum == proc)
+      {
+       /* decode arguments into a CLEAN buffer */
+       bzero (xdrbuf, sizeof (xdrbuf));        /* required ! */
+       if (!svc_getargs (transp, pl->p_inproc, xdrbuf))
+         {
+           svcerr_decode (transp);
+           return;
+         }
+       outdata = (*(pl->p_progname)) (xdrbuf);
+       if (outdata == NULL && pl->p_outproc != (xdrproc_t)xdr_void)
+         /* there was an error */
+         return;
+       if (!svc_sendreply (transp, pl->p_outproc, outdata))
+         {
+           (void) fprintf (stderr,
+                           _ ("trouble replying to prog %d\n"),
+                           pl->p_prognum);
+           exit (1);
+         }
+       /* free the decoded arguments */
+       (void) svc_freeargs (transp, pl->p_inproc, xdrbuf);
+       return;
+      }
+  (void) fprintf (stderr, _ ("never registered prog %d\n"), prog);
+  exit (1);
 }
-
index 278e16f..758b6ba 100644 (file)
@@ -42,66 +42,70 @@ static char sccsid[] = "@(#)svc_tcp.c 1.21 87/08/11 Copyr 1984 Sun Micro";
  */
 
 #include <stdio.h>
+#include <unistd.h>
+#include <string.h>
 #include <rpc/rpc.h>
 #include <sys/socket.h>
 #include <errno.h>
-#define abort ((bool_t (*) ()) abort)
-#ifndef errno
-extern errno;
-#endif
+#include <stdlib.h>
 
 /*
  * Ops vector for TCP/IP based rpc service handle
  */
-static bool_t          svctcp_recv();
-static enum xprt_stat  svctcp_stat();
-static bool_t          svctcp_getargs();
-static bool_t          svctcp_reply();
-static bool_t          svctcp_freeargs();
-static void            svctcp_destroy();
-
-static struct xp_ops svctcp_op = {
-       svctcp_recv,
-       svctcp_stat,
-       svctcp_getargs,
-       svctcp_reply,
-       svctcp_freeargs,
-       svctcp_destroy
+static bool_t svctcp_recv (SVCXPRT *, struct rpc_msg *);
+static enum xprt_stat svctcp_stat (SVCXPRT *);
+static bool_t svctcp_getargs (SVCXPRT *, xdrproc_t, caddr_t);
+static bool_t svctcp_reply (SVCXPRT *, struct rpc_msg *);
+static bool_t svctcp_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
+static void svctcp_destroy (SVCXPRT *);
+
+static const struct xp_ops svctcp_op =
+{
+  svctcp_recv,
+  svctcp_stat,
+  svctcp_getargs,
+  svctcp_reply,
+  svctcp_freeargs,
+  svctcp_destroy
 };
 
 /*
  * Ops vector for TCP/IP rendezvous handler
  */
-static bool_t          rendezvous_request();
-static enum xprt_stat  rendezvous_stat();
-
-static struct xp_ops svctcp_rendezvous_op = {
-       rendezvous_request,
-       rendezvous_stat,
-       abort,
-       abort,
-       abort,
-       svctcp_destroy
+static bool_t rendezvous_request (SVCXPRT *, struct rpc_msg *);
+static enum xprt_stat rendezvous_stat (SVCXPRT *);
+
+static const struct xp_ops svctcp_rendezvous_op =
+{
+  rendezvous_request,
+  rendezvous_stat,
+  (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) abort,
+  (bool_t (*) (SVCXPRT *, struct rpc_msg *)) abort,
+  (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) abort,
+  svctcp_destroy
 };
 
-static int readtcp(), writetcp();
-static SVCXPRT *makefd_xprt();
+static int readtcp (char*, char *, int);
+static int writetcp (char *, char *, int);
+static SVCXPRT *makefd_xprt (int, u_int, u_int);
 
-struct tcp_rendezvous { /* kept in xprt->xp_p1 */
-       u_int sendsize;
-       u_int recvsize;
-};
+struct tcp_rendezvous
+  {                            /* kept in xprt->xp_p1 */
+    u_int sendsize;
+    u_int recvsize;
+  };
 
-struct tcp_conn {  /* kept in xprt->xp_p1 */
-       enum xprt_stat strm_stat;
-       u_long x_id;
-       XDR xdrs;
-       char verf_body[MAX_AUTH_BYTES];
-};
+struct tcp_conn
+  {                            /* kept in xprt->xp_p1 */
+    enum xprt_stat strm_stat;
+    u_long x_id;
+    XDR xdrs;
+    char verf_body[MAX_AUTH_BYTES];
+  };
 
 /*
  * Usage:
- *     xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
+ *      xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
  *
  * Creates, registers, and returns a (rpc) tcp based transporter.
  * Once *xprt is initialized, it is registered as a transporter
@@ -120,57 +124,60 @@ struct tcp_conn {  /* kept in xprt->xp_p1 */
  * 0 => use the system default.
  */
 SVCXPRT *
-svctcp_create(sock, sendsize, recvsize)
-       register int sock;
-       u_int sendsize;
-       u_int recvsize;
+svctcp_create (int sock, u_int sendsize, u_int recvsize)
 {
-       bool_t madesock = FALSE;
-       register SVCXPRT *xprt;
-       register struct tcp_rendezvous *r;
-       struct sockaddr_in addr;
-       int len = sizeof(struct sockaddr_in);
-
-       if (sock == RPC_ANYSOCK) {
-               if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
-                       perror(_("svctcp_.c - udp socket creation problem"));
-                       return ((SVCXPRT *)NULL);
-               }
-               madesock = TRUE;
-       }
-       bzero((char *)&addr, sizeof (addr));
-       addr.sin_family = AF_INET;
-       if (bindresvport(sock, &addr)) {
-               addr.sin_port = 0;
-               (void)bind(sock, (struct sockaddr *)&addr, len);
-       }
-       if ((getsockname(sock, (struct sockaddr *)&addr, &len) != 0)  ||
-           (listen(sock, 2) != 0)) {
-               perror(_("svctcp_.c - cannot getsockname or listen"));
-               if (madesock)
-                      (void)close(sock);
-               return ((SVCXPRT *)NULL);
-       }
-       r = (struct tcp_rendezvous *)mem_alloc(sizeof(*r));
-       if (r == NULL) {
-               (void) fprintf(stderr, _("svctcp_create: out of memory\n"));
-               return (NULL);
-       }
-       r->sendsize = sendsize;
-       r->recvsize = recvsize;
-       xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
-       if (xprt == NULL) {
-               (void) fprintf(stderr, _("svctcp_create: out of memory\n"));
-               return (NULL);
+  bool_t madesock = FALSE;
+  SVCXPRT *xprt;
+  struct tcp_rendezvous *r;
+  struct sockaddr_in addr;
+  int len = sizeof (struct sockaddr_in);
+
+  if (sock == RPC_ANYSOCK)
+    {
+      if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
+       {
+         perror (_("svctcp_.c - udp socket creation problem"));
+         return (SVCXPRT *) NULL;
        }
-       xprt->xp_p2 = NULL;
-       xprt->xp_p1 = (caddr_t)r;
-       xprt->xp_verf = _null_auth;
-       xprt->xp_ops = &svctcp_rendezvous_op;
-       xprt->xp_port = ntohs(addr.sin_port);
-       xprt->xp_sock = sock;
-       xprt_register(xprt);
-       return (xprt);
+      madesock = TRUE;
+    }
+  bzero ((char *) &addr, sizeof (addr));
+  addr.sin_family = AF_INET;
+  if (bindresvport (sock, &addr))
+    {
+      addr.sin_port = 0;
+      (void) bind (sock, (struct sockaddr *) &addr, len);
+    }
+  if ((getsockname (sock, (struct sockaddr *) &addr, &len) != 0) ||
+      (listen (sock, 2) != 0))
+    {
+      perror (_("svctcp_.c - cannot getsockname or listen"));
+      if (madesock)
+       (void) close (sock);
+      return (SVCXPRT *) NULL;
+    }
+  r = (struct tcp_rendezvous *) mem_alloc (sizeof (*r));
+  if (r == NULL)
+    {
+      (void) fputs (_("svctcp_create: out of memory\n"), stderr);
+      return NULL;
+    }
+  r->sendsize = sendsize;
+  r->recvsize = recvsize;
+  xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
+  if (xprt == NULL)
+    {
+      (void) fputs (_("svctcp_create: out of memory\n"), stderr);
+      return NULL;
+    }
+  xprt->xp_p2 = NULL;
+  xprt->xp_p1 = (caddr_t) r;
+  xprt->xp_verf = _null_auth;
+  xprt->xp_ops = &svctcp_rendezvous_op;
+  xprt->xp_port = ntohs (addr.sin_port);
+  xprt->xp_sock = sock;
+  xprt_register (xprt);
+  return xprt;
 }
 
 /*
@@ -178,109 +185,106 @@ svctcp_create(sock, sendsize, recvsize)
  * descriptor as its first input.
  */
 SVCXPRT *
-svcfd_create(fd, sendsize, recvsize)
-       int fd;
-       u_int sendsize;
-       u_int recvsize;
+svcfd_create (int fd, u_int sendsize, u_int recvsize)
 {
-
-       return (makefd_xprt(fd, sendsize, recvsize));
+  return makefd_xprt (fd, sendsize, recvsize);
 }
 
 static SVCXPRT *
-makefd_xprt(fd, sendsize, recvsize)
-       int fd;
-       u_int sendsize;
-       u_int recvsize;
+makefd_xprt (int fd, u_int sendsize, u_int recvsize)
 {
-       register SVCXPRT *xprt;
-       register struct tcp_conn *cd;
-
-       xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
-       if (xprt == (SVCXPRT *)NULL) {
-               (void) fprintf(stderr, _("svc_tcp: makefd_xprt: out of memory\n"));
-               goto done;
-       }
-       cd = (struct tcp_conn *)mem_alloc(sizeof(struct tcp_conn));
-       if (cd == (struct tcp_conn *)NULL) {
-               (void) fprintf(stderr, _("svc_tcp: makefd_xprt: out of memory\n"));
-               mem_free((char *) xprt, sizeof(SVCXPRT));
-               xprt = (SVCXPRT *)NULL;
-               goto done;
-       }
-       cd->strm_stat = XPRT_IDLE;
-       xdrrec_create(&(cd->xdrs), sendsize, recvsize,
-           (caddr_t)xprt, readtcp, writetcp);
-       xprt->xp_p2 = NULL;
-       xprt->xp_p1 = (caddr_t)cd;
-       xprt->xp_verf.oa_base = cd->verf_body;
-       xprt->xp_addrlen = 0;
-       xprt->xp_ops = &svctcp_op;  /* truly deals with calls */
-       xprt->xp_port = 0;  /* this is a connection, not a rendezvouser */
-       xprt->xp_sock = fd;
-       xprt_register(xprt);
-    done:
-       return (xprt);
+  SVCXPRT *xprt;
+  struct tcp_conn *cd;
+
+  xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
+  if (xprt == (SVCXPRT *) NULL)
+    {
+      (void) fputs (_("svc_tcp: makefd_xprt: out of memory\n"), stderr);
+      goto done;
+    }
+  cd = (struct tcp_conn *) mem_alloc (sizeof (struct tcp_conn));
+  if (cd == (struct tcp_conn *) NULL)
+    {
+      (void) fputs (_("svc_tcp: makefd_xprt: out of memory\n"), stderr);
+      mem_free ((char *) xprt, sizeof (SVCXPRT));
+      xprt = (SVCXPRT *) NULL;
+      goto done;
+    }
+  cd->strm_stat = XPRT_IDLE;
+  xdrrec_create (&(cd->xdrs), sendsize, recvsize,
+                (caddr_t) xprt, readtcp, writetcp);
+  xprt->xp_p2 = NULL;
+  xprt->xp_p1 = (caddr_t) cd;
+  xprt->xp_verf.oa_base = cd->verf_body;
+  xprt->xp_addrlen = 0;
+  xprt->xp_ops = &svctcp_op;   /* truly deals with calls */
+  xprt->xp_port = 0;           /* this is a connection, not a rendezvouser */
+  xprt->xp_sock = fd;
+  xprt_register (xprt);
+done:
+  return xprt;
 }
 
 static bool_t
-rendezvous_request(xprt)
-       register SVCXPRT *xprt;
+rendezvous_request (SVCXPRT *xprt, struct rpc_msg *errmsg)
 {
-       int sock;
-       struct tcp_rendezvous *r;
-       struct sockaddr_in addr;
-       int len;
-
-       r = (struct tcp_rendezvous *)xprt->xp_p1;
-    again:
-       len = sizeof(struct sockaddr_in);
-       if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr,
-           &len)) < 0) {
-               if (errno == EINTR)
-                       goto again;
-              return (FALSE);
-       }
-       /*
-        * make a new transporter (re-uses xprt)
-        */
-       xprt = makefd_xprt(sock, r->sendsize, r->recvsize);
-       xprt->xp_raddr = addr;
-       xprt->xp_addrlen = len;
-       return (FALSE); /* there is never an rpc msg to be processed */
+  int sock;
+  struct tcp_rendezvous *r;
+  struct sockaddr_in addr;
+  int len;
+
+  r = (struct tcp_rendezvous *) xprt->xp_p1;
+again:
+  len = sizeof (struct sockaddr_in);
+  if ((sock = accept (xprt->xp_sock, (struct sockaddr *) &addr,
+                     &len)) < 0)
+    {
+      if (errno == EINTR)
+       goto again;
+      return FALSE;
+    }
+  /*
+   * make a new transporter (re-uses xprt)
+   */
+  xprt = makefd_xprt (sock, r->sendsize, r->recvsize);
+  xprt->xp_raddr = addr;
+  xprt->xp_addrlen = len;
+  return FALSE;                /* there is never an rpc msg to be processed */
 }
 
 static enum xprt_stat
-rendezvous_stat()
+rendezvous_stat (SVCXPRT *xprt)
 {
-
-       return (XPRT_IDLE);
+  return XPRT_IDLE;
 }
 
 static void
-svctcp_destroy(xprt)
-       register SVCXPRT *xprt;
+svctcp_destroy (SVCXPRT *xprt)
 {
-       register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
-
-       xprt_unregister(xprt);
-       (void)close(xprt->xp_sock);
-       if (xprt->xp_port != 0) {
-               /* a rendezvouser socket */
-               xprt->xp_port = 0;
-       } else {
-               /* an actual connection socket */
-               XDR_DESTROY(&(cd->xdrs));
-       }
-       mem_free((caddr_t)cd, sizeof(struct tcp_conn));
-       mem_free((caddr_t)xprt, sizeof(SVCXPRT));
+  struct tcp_conn *cd = (struct tcp_conn *) xprt->xp_p1;
+
+  xprt_unregister (xprt);
+  (void) close (xprt->xp_sock);
+  if (xprt->xp_port != 0)
+    {
+      /* a rendezvouser socket */
+      xprt->xp_port = 0;
+    }
+  else
+    {
+      /* an actual connection socket */
+      XDR_DESTROY (&(cd->xdrs));
+    }
+  mem_free ((caddr_t) cd, sizeof (struct tcp_conn));
+  mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
 }
 
 /*
  * All read operations timeout after 35 seconds.
  * A timeout is fatal for the connection.
  */
-static struct timeval wait_per_try = { 35, 0 };
+static struct timeval wait_per_try =
+{35, 0};
 
 /*
  * reads data from the tcp connection.
@@ -288,43 +292,47 @@ static struct timeval wait_per_try = { 35, 0 };
  * (And a read of zero bytes is a half closed stream => error.)
  */
 static int
-readtcp(xprt, buf, len)
-       register SVCXPRT *xprt;
-       caddr_t buf;
-       register int len;
+readtcp (char *xprtptr, char *buf, int len)
 {
-       register int sock = xprt->xp_sock;
+  SVCXPRT *xprt = (SVCXPRT *)xprtptr;
+  int sock = xprt->xp_sock;
 #ifdef FD_SETSIZE
-       fd_set mask;
-       fd_set readfds;
+  fd_set mask;
+  fd_set readfds;
 
-       FD_ZERO(&mask);
-       FD_SET(sock, &mask);
+  FD_ZERO (&mask);
+  FD_SET (sock, &mask);
 #else
-       register int mask = 1 << sock;
-       int readfds;
+  int mask = 1 << sock;
+  int readfds;
 #endif /* def FD_SETSIZE */
-       do {
-               struct timeval timeout = wait_per_try;
-               readfds = mask;
-               if (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL,
-                          &timeout) <= 0) {
-                       if (errno == EINTR) {
-                               continue;
-                       }
-                       goto fatal_err;
-               }
+  do
+    {
+      struct timeval timeout = wait_per_try;
+      readfds = mask;
+      if (select (_rpc_dtablesize (), &readfds, (fd_set *) NULL,
+                 (fd_set *) NULL, &timeout) <= 0)
+       {
+         if (errno == EINTR)
+           {
+             continue;
+           }
+         goto fatal_err;
+       }
 #ifdef FD_SETSIZE
-       } while (!FD_ISSET(sock, &readfds));
+    }
+  while (!FD_ISSET (sock, &readfds));
 #else
-       } while (readfds != mask);
+    }
+  while (readfds != mask);
 #endif /* def FD_SETSIZE */
-       if ((len = read(sock, buf, len)) > 0) {
-               return (len);
-       }
+  if ((len = read (sock, buf, len)) > 0)
+    {
+      return len;
+    }
 fatal_err:
-       ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
-       return (-1);
+  ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
+  return -1;
 }
 
 /*
@@ -332,91 +340,91 @@ fatal_err:
  * Any error is fatal and the connection is closed.
  */
 static int
-writetcp(xprt, buf, len)
-       register SVCXPRT *xprt;
-       caddr_t buf;
-       int len;
+writetcp (char *xprtptr, char * buf, int len)
 {
-       register int i, cnt;
-
-       for (cnt = len; cnt > 0; cnt -= i, buf += i) {
-               if ((i = write(xprt->xp_sock, buf, cnt)) < 0) {
-                       ((struct tcp_conn *)(xprt->xp_p1))->strm_stat =
-                           XPRT_DIED;
-                       return (-1);
-               }
+  SVCXPRT *xprt = (SVCXPRT *)xprtptr;
+  int i, cnt;
+
+  for (cnt = len; cnt > 0; cnt -= i, buf += i)
+    {
+      if ((i = write (xprt->xp_sock, buf, cnt)) < 0)
+       {
+         ((struct tcp_conn *) (xprt->xp_p1))->strm_stat =
+           XPRT_DIED;
+         return (-1);
        }
-       return (len);
+    }
+  return (len);
 }
 
 static enum xprt_stat
-svctcp_stat(xprt)
-       SVCXPRT *xprt;
+svctcp_stat (SVCXPRT *xprt)
 {
-       register struct tcp_conn *cd =
-           (struct tcp_conn *)(xprt->xp_p1);
-
-       if (cd->strm_stat == XPRT_DIED)
-               return (XPRT_DIED);
-       if (! xdrrec_eof(&(cd->xdrs)))
-               return (XPRT_MOREREQS);
-       return (XPRT_IDLE);
+  struct tcp_conn *cd =
+  (struct tcp_conn *) (xprt->xp_p1);
+
+  if (cd->strm_stat == XPRT_DIED)
+    return (XPRT_DIED);
+  if (!xdrrec_eof (&(cd->xdrs)))
+    return (XPRT_MOREREQS);
+  return (XPRT_IDLE);
 }
 
 static bool_t
-svctcp_recv(xprt, msg)
-       SVCXPRT *xprt;
-       register struct rpc_msg *msg;
+svctcp_recv (xprt, msg)
+     SVCXPRT *xprt;
+     struct rpc_msg *msg;
 {
-       register struct tcp_conn *cd =
-           (struct tcp_conn *)(xprt->xp_p1);
-       register XDR *xdrs = &(cd->xdrs);
-
-       xdrs->x_op = XDR_DECODE;
-       (void)xdrrec_skiprecord(xdrs);
-       if (xdr_callmsg(xdrs, msg)) {
-               cd->x_id = msg->rm_xid;
-               return (TRUE);
-       }
-       return (FALSE);
+  struct tcp_conn *cd =
+  (struct tcp_conn *) (xprt->xp_p1);
+  XDR *xdrs = &(cd->xdrs);
+
+  xdrs->x_op = XDR_DECODE;
+  (void) xdrrec_skiprecord (xdrs);
+  if (xdr_callmsg (xdrs, msg))
+    {
+      cd->x_id = msg->rm_xid;
+      return (TRUE);
+    }
+  return (FALSE);
 }
 
 static bool_t
-svctcp_getargs(xprt, xdr_args, args_ptr)
-       SVCXPRT *xprt;
-       xdrproc_t xdr_args;
-       caddr_t args_ptr;
+svctcp_getargs (xprt, xdr_args, args_ptr)
+     SVCXPRT *xprt;
+     xdrproc_t xdr_args;
+     caddr_t args_ptr;
 {
 
-       return ((*xdr_args)(&(((struct tcp_conn *)(xprt->xp_p1))->xdrs), args_ptr));
+  return ((*xdr_args) (&(((struct tcp_conn *) (xprt->xp_p1))->xdrs), args_ptr));
 }
 
 static bool_t
-svctcp_freeargs(xprt, xdr_args, args_ptr)
-       SVCXPRT *xprt;
-       xdrproc_t xdr_args;
-       caddr_t args_ptr;
+svctcp_freeargs (xprt, xdr_args, args_ptr)
+     SVCXPRT *xprt;
+     xdrproc_t xdr_args;
+     caddr_t args_ptr;
 {
-       register XDR *xdrs =
-           &(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
+  XDR *xdrs =
+  &(((struct tcp_conn *) (xprt->xp_p1))->xdrs);
 
-       xdrs->x_op = XDR_FREE;
-       return ((*xdr_args)(xdrs, args_ptr));
+  xdrs->x_op = XDR_FREE;
+  return ((*xdr_args) (xdrs, args_ptr));
 }
 
 static bool_t
-svctcp_reply(xprt, msg)
-       SVCXPRT *xprt;
-       register struct rpc_msg *msg;
+svctcp_reply (xprt, msg)
+     SVCXPRT *xprt;
+     struct rpc_msg *msg;
 {
-       register struct tcp_conn *cd =
-           (struct tcp_conn *)(xprt->xp_p1);
-       register XDR *xdrs = &(cd->xdrs);
-       register bool_t stat;
-
-       xdrs->x_op = XDR_ENCODE;
-       msg->rm_xid = cd->x_id;
-       stat = xdr_replymsg(xdrs, msg);
-       (void)xdrrec_endofrecord(xdrs, TRUE);
-       return (stat);
+  struct tcp_conn *cd =
+  (struct tcp_conn *) (xprt->xp_p1);
+  XDR *xdrs = &(cd->xdrs);
+  bool_t stat;
+
+  xdrs->x_op = XDR_ENCODE;
+  msg->rm_xid = cd->x_id;
+  stat = xdr_replymsg (xdrs, msg);
+  (void) xdrrec_endofrecord (xdrs, TRUE);
+  return (stat);
 }