home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / internet / amitcp3.0b / src.lha / src / util / rpcinfo / rpcinfo.c next >
Encoding:
C/C++ Source or Header  |  1996-09-08  |  17.9 KB  |  708 lines
  1. RCS_ID_C="$Id: rpcinfo.c,v 3.6 1994/05/02 19:52:55 jraja Exp $";
  2. /*
  3.  * rpcinfo.c -- ping a particular rpc program or dump the portmapper
  4.  */
  5.  
  6. #include "rpcinfo_rev.h"
  7.  
  8. static const char version[] = VERSTAG
  9. " Copyright © 1994 AmiTCP/IP Group, <amitcp-group@hut.fi>\n"
  10. "Helsinki University of Technology, Finland.\n"
  11. "Copyright © 1990 The Regents of the University of California.\n"
  12. "All rights reserved.\n";
  13.  
  14. /****** netutil.doc/rpcinfo *************************************************
  15.     NAME
  16.         rpcinfo - report RPC information
  17.     
  18.     SYNOPSIS
  19.         `rpcinfo -p [ host ]'
  20.     
  21.         `rpcinfo [ -n portnum ] -u host program [ version ]'
  22.     
  23.         `rpcinfo [ -n portnum ] -t host program [ version ]'
  24.     
  25.         `rpcinfo -b program version'
  26.     
  27.         `rpcinfo -d program version'
  28.     
  29.     DESCRIPTION
  30.         `rpcinfo' makes an RPC call to an RPC server and reports what it
  31.         finds.
  32.     
  33.     OPTIONS
  34.         `-p'  Probe the portmapper on host, and print a list of all
  35.               registered RPC programs.  If host is not specified, it
  36.               defaults to the value returned by `gethostname()'.
  37.     
  38.         `-u'  Make an RPC call to procedure 0 of program on the specified
  39.               host using UDP, and report whether a response was received.
  40.     
  41.         `-t'  Make an RPC call to procedure 0 of program on the specified
  42.               host using TCP, and report whether a response was received.
  43.     
  44.         `-n'  Use `portnum' as the port number for the `-t' and `-u'
  45.               options instead of the port number given by the portmapper.
  46.     
  47.         `-b'  Make an RPC broadcast to procedure 0 of the specified program
  48.               and version using UDP and report all hosts that respond.
  49.     
  50.         `-d'  Delete registration for the RPC service of the specified
  51.               program and version.  This option can be exercised only by
  52.               the superuser.  The program argument can be either a name or
  53.               a number.  If a version is specified, `rpcinfo' attempts to
  54.               call that version of the specified program.  Otherwise,
  55.               rpcinfo attempts to find all the registered version numbers
  56.               for the specified program by calling version 0 (which is
  57.               presumed not to exist; if it does exist, rpcinfo attempts to
  58.               obtain this information by calling an extremely high version
  59.               number instead) and attempts to call each registered version.
  60.     
  61.         *Note:* the version number is required for -b and -d options.
  62.     
  63.     EXAMPLES
  64.         To show all of the RPC services registered on the local machine
  65.         use:
  66.     
  67.             example% rpcinfo -p
  68.     
  69.         To show all of the RPC services registered on the machine named
  70.         klaxon use:
  71.     
  72.             example% rpcinfo -p klaxon
  73.     
  74.         To show all machines on the local net that are running the Yellow
  75.         Pages service use:
  76.     
  77.             example% rpcinfo -b ypserv 'version' | uniq
  78.     
  79.         where '`version'' is the current Yellow Pages version obtained
  80.         from the results of the `-p' switch above.
  81.     
  82.         To delete the registration for version 1 of the `walld' service
  83.         use:
  84.     
  85.             example% rpcinfo -d walld 1
  86.     
  87.     SEE ALSO
  88.         AmiTCP:db/rpc, netutil.doc/portmap
  89.     
  90. *****************************************************************************
  91. * 
  92. */
  93.  
  94. /*
  95.  * @(#)rpcinfo.c 2.2 88/08/11 4.0 RPCSRC
  96.  * @(#)rpcinfo.c 1.22 87/08/12 SMI";
  97.  * 
  98.  * Copyright (C) 1986, Sun Microsystems, Inc.
  99.  */
  100.  
  101. #include <rpc/rpc.h>
  102. #include <stdio.h>
  103. #include <stdlib.h>
  104. #include <sys/socket.h>
  105. #include <netdb.h>
  106. #include <rpc/pmap_prot.h>
  107. #include <rpc/pmap_clnt.h>
  108. #include <signal.h>
  109. #include <ctype.h>
  110. #include <string.h>
  111. #include <unistd.h>
  112.  
  113. #ifdef AMITCP
  114. #define close CloseSocket
  115. #endif
  116.  
  117. #define MAXHOSTLEN 256
  118.  
  119. #define    MIN_VERS    ((u_long) 0)
  120. #define    MAX_VERS    ((u_long) 4294967295L)
  121.  
  122. static void    udpping(u_short portflag, int argc, char **argv);
  123. static void    tcpping(u_short portflag, int argc, char **argv);
  124. static int    pstatus(CLIENT *client, u_long prognum, u_long vers);
  125. static void    pmapdump(int argc, char **argv);
  126. static bool_t    reply_proc(void *res, struct sockaddr_in *who);
  127. static void    brdcst(int argc, char **argv);
  128. static void    deletereg( int argc, char **argv ) ;
  129. static void    usage(void);
  130. static u_long    getprognum(char *arg);
  131. static u_long    getvers(char *arg);
  132. static void    get_inet_address(struct sockaddr_in *addr, char *host);
  133.  
  134. /*
  135.  * Functions to be performed.
  136.  */
  137. #define    NONE        0    /* no function */
  138. #define    PMAPDUMP    1    /* dump portmapper registrations */
  139. #define    TCPPING        2    /* ping TCP service */
  140. #define    UDPPING        3    /* ping UDP service */
  141. #define    BRDCST        4    /* ping broadcast UDP service */
  142. #define DELETES        5    /* delete registration for the service */
  143.  
  144. int
  145. main(int argc, char **argv)
  146. {
  147.     register int c;
  148.     extern char *optarg;
  149.     extern int optind;
  150.     int errflg;
  151.     int function;
  152.     u_short portnum;
  153.  
  154.     function = NONE;
  155.     portnum = 0;
  156.     errflg = 0;
  157.     while ((c = getopt(argc, argv, "ptubdn:")) != EOF) {
  158.         switch (c) {
  159.  
  160.         case 'p':
  161.             if (function != NONE)
  162.                 errflg = 1;
  163.             else
  164.                 function = PMAPDUMP;
  165.             break;
  166.  
  167.         case 't':
  168.             if (function != NONE)
  169.                 errflg = 1;
  170.             else
  171.                 function = TCPPING;
  172.             break;
  173.  
  174.         case 'u':
  175.             if (function != NONE)
  176.                 errflg = 1;
  177.             else
  178.                 function = UDPPING;
  179.             break;
  180.  
  181.         case 'b':
  182.             if (function != NONE)
  183.                 errflg = 1;
  184.             else
  185.                 function = BRDCST;
  186.             break;
  187.  
  188.         case 'n':
  189.             portnum = (u_short) atoi(optarg);   /* hope we don't get bogus # */
  190.             break;
  191.  
  192.         case 'd':
  193.             if (function != NONE)
  194.                 errflg = 1;
  195.             else
  196.                 function = DELETES;
  197.             break;
  198.  
  199.         case '?':
  200.             errflg = 1;
  201.         }
  202.     }
  203.  
  204.     if (errflg || function == NONE) {
  205.         usage();
  206.         return (1);
  207.     }
  208.  
  209.     switch (function) {
  210.  
  211.     case PMAPDUMP:
  212.         if (portnum != 0) {
  213.             usage();
  214.             return (1);
  215.         }
  216.         pmapdump(argc - optind, argv + optind);
  217.         break;
  218.  
  219.     case UDPPING:
  220.         udpping(portnum, argc - optind, argv + optind);
  221.         break;
  222.  
  223.     case TCPPING:
  224.         tcpping(portnum, argc - optind, argv + optind);
  225.         break;
  226.  
  227.     case BRDCST:
  228.         if (portnum != 0) {
  229.             usage();
  230.             return (1);
  231.         }
  232.         brdcst(argc - optind, argv + optind);
  233.         break;
  234.  
  235.     case DELETES:
  236.         deletereg(argc - optind, argv + optind);
  237.         break;
  238.     }
  239.  
  240.     return (0);
  241. }
  242.         
  243. static void
  244. udpping(u_short portnum, int argc, char **argv)
  245. {
  246.     struct timeval to;
  247.     struct sockaddr_in addr;
  248.     enum clnt_stat rpc_stat;
  249.     CLIENT *client;
  250.     u_long prognum, vers, minvers, maxvers;
  251.     int sock = RPC_ANYSOCK;
  252.     struct rpc_err rpcerr;
  253.     int failure;
  254.     
  255.     if (argc < 2 || argc > 3) {
  256.         usage();
  257.         exit(1);
  258.     }
  259.     prognum = getprognum(argv[1]);
  260.     get_inet_address(&addr, argv[0]);
  261.     /* Open the socket here so it will survive calls to clnt_destroy */
  262.     sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  263.     if (sock < 0) {
  264.         perror("rpcinfo: socket");
  265.         exit(1);
  266.     }
  267.     failure = 0;
  268.     if (argc == 2) {
  269.         /*
  270.          * A call to version 0 should fail with a program/version
  271.          * mismatch, and give us the range of versions supported.
  272.          */
  273.         addr.sin_port = htons(portnum);
  274.         to.tv_sec = 5;
  275.         to.tv_usec = 0;
  276.         if ((client = clntudp_create(&addr, prognum, (u_long)0,
  277.             to, &sock)) == NULL) {
  278.             clnt_pcreateerror("rpcinfo");
  279.             printf("program %lu is not available\n",
  280.                 prognum);
  281.             exit(1);
  282.         }
  283.         to.tv_sec = 10;
  284.         to.tv_usec = 0;
  285.         rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL,
  286.             xdr_void, (char *)NULL, to);
  287.         if (rpc_stat == RPC_PROGVERSMISMATCH) {
  288.             clnt_geterr(client, &rpcerr);
  289.             minvers = rpcerr.re_vers.low;
  290.             maxvers = rpcerr.re_vers.high;
  291.         } else if (rpc_stat == RPC_SUCCESS) {
  292.             /*
  293.              * Oh dear, it DOES support version 0.
  294.              * Let's try version MAX_VERS.
  295.              */
  296.             addr.sin_port = htons(portnum);
  297.             to.tv_sec = 5;
  298.             to.tv_usec = 0;
  299.             if ((client = clntudp_create(&addr, prognum, MAX_VERS,
  300.                 to, &sock)) == NULL) {
  301.                 clnt_pcreateerror("rpcinfo");
  302.                 printf("program %lu version %lu is not available\n",
  303.                     prognum, MAX_VERS);
  304.                 exit(1);
  305.             }
  306.             to.tv_sec = 10;
  307.             to.tv_usec = 0;
  308.             rpc_stat = clnt_call(client, NULLPROC, xdr_void,
  309.                 (char *)NULL, xdr_void, (char *)NULL, to);
  310.             if (rpc_stat == RPC_PROGVERSMISMATCH) {
  311.                 clnt_geterr(client, &rpcerr);
  312.                 minvers = rpcerr.re_vers.low;
  313.                 maxvers = rpcerr.re_vers.high;
  314.             } else if (rpc_stat == RPC_SUCCESS) {
  315.                 /*
  316.                  * It also supports version MAX_VERS.
  317.                  * Looks like we have a wise guy.
  318.                  * OK, we give them information on all
  319.                  * 4 billion versions they support...
  320.                  */
  321.                 minvers = 0;
  322.                 maxvers = MAX_VERS;
  323.             } else {
  324.                 (void) pstatus(client, prognum, MAX_VERS);
  325.                 exit(1);
  326.             }
  327.         } else {
  328.             (void) pstatus(client, prognum, (u_long)0);
  329.             exit(1);
  330.         }
  331.         clnt_destroy(client);
  332.         for (vers = minvers; vers <= maxvers; vers++) {
  333.             addr.sin_port = htons(portnum);
  334.             to.tv_sec = 5;
  335.             to.tv_usec = 0;
  336.             if ((client = clntudp_create(&addr, prognum, vers,
  337.                 to, &sock)) == NULL) {
  338.                 clnt_pcreateerror("rpcinfo");
  339.                 printf("program %lu version %lu is not available\n",
  340.                     prognum, vers);
  341.                 exit(1);
  342.             }
  343.             to.tv_sec = 10;
  344.             to.tv_usec = 0;
  345.             rpc_stat = clnt_call(client, NULLPROC, xdr_void,
  346.                 (char *)NULL, xdr_void, (char *)NULL, to);
  347.             if (pstatus(client, prognum, vers) < 0)
  348.                 failure = 1;
  349.             clnt_destroy(client);
  350.         }
  351.     }
  352.     else {
  353.         vers = getvers(argv[2]);
  354.         addr.sin_port = htons(portnum);
  355.         to.tv_sec = 5;
  356.         to.tv_usec = 0;
  357.         if ((client = clntudp_create(&addr, prognum, vers,
  358.             to, &sock)) == NULL) {
  359.             clnt_pcreateerror("rpcinfo");
  360.             printf("program %lu version %lu is not available\n",
  361.                 prognum, vers);
  362.             exit(1);
  363.         }
  364.         to.tv_sec = 10;
  365.         to.tv_usec = 0;
  366.         rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
  367.             xdr_void, (char *)NULL, to);
  368.         if (pstatus(client, prognum, vers) < 0)
  369.             failure = 1;
  370.     }
  371.     (void) close(sock); /* Close it up again */
  372.     if (failure)
  373.         exit(1);
  374. }
  375.  
  376. static void
  377. tcpping(u_short portnum, int argc, char **argv)
  378. {
  379.     struct timeval to;
  380.     struct sockaddr_in addr;
  381.     enum clnt_stat rpc_stat;
  382.     CLIENT *client;
  383.     u_long prognum, vers, minvers, maxvers;
  384.     int sock = RPC_ANYSOCK;
  385.     struct rpc_err rpcerr;
  386.     int failure;
  387.  
  388.     if (argc < 2 || argc > 3) {
  389.         usage();
  390.         exit(1);
  391.     }
  392.     prognum = getprognum(argv[1]);
  393.     get_inet_address(&addr, argv[0]);
  394.     failure = 0;
  395.     if (argc == 2) {
  396.         /*
  397.          * A call to version 0 should fail with a program/version
  398.          * mismatch, and give us the range of versions supported.
  399.          */
  400.         addr.sin_port = htons(portnum);
  401.         if ((client = clnttcp_create(&addr, prognum, MIN_VERS,
  402.             &sock, 0, 0)) == NULL) {
  403.             clnt_pcreateerror("rpcinfo");
  404.             printf("program %lu is not available\n",
  405.                 prognum);
  406.             exit(1);
  407.         }
  408.         to.tv_sec = 10;
  409.         to.tv_usec = 0;
  410.         rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL,
  411.             xdr_void, (char *)NULL, to);
  412.         if (rpc_stat == RPC_PROGVERSMISMATCH) {
  413.             clnt_geterr(client, &rpcerr);
  414.             minvers = rpcerr.re_vers.low;
  415.             maxvers = rpcerr.re_vers.high;
  416.         } else if (rpc_stat == RPC_SUCCESS) {
  417.             /*
  418.              * Oh dear, it DOES support version 0.
  419.              * Let's try version MAX_VERS.
  420.              */
  421.             addr.sin_port = htons(portnum);
  422.             if ((client = clnttcp_create(&addr, prognum, MAX_VERS,
  423.                 &sock, 0, 0)) == NULL) {
  424.                 clnt_pcreateerror("rpcinfo");
  425.                 printf("program %lu version %lu is not available\n",
  426.                     prognum, MAX_VERS);
  427.                 exit(1);
  428.             }
  429.             to.tv_sec = 10;
  430.             to.tv_usec = 0;
  431.             rpc_stat = clnt_call(client, NULLPROC, xdr_void,
  432.                 (char *)NULL, xdr_void, (char *)NULL, to);
  433.             if (rpc_stat == RPC_PROGVERSMISMATCH) {
  434.                 clnt_geterr(client, &rpcerr);
  435.                 minvers = rpcerr.re_vers.low;
  436.                 maxvers = rpcerr.re_vers.high;
  437.             } else if (rpc_stat == RPC_SUCCESS) {
  438.                 /*
  439.                  * It also supports version MAX_VERS.
  440.                  * Looks like we have a wise guy.
  441.                  * OK, we give them information on all
  442.                  * 4 billion versions they support...
  443.                  */
  444.                 minvers = 0;
  445.                 maxvers = MAX_VERS;
  446.             } else {
  447.                 (void) pstatus(client, prognum, MAX_VERS);
  448.                 exit(1);
  449.             }
  450.         } else {
  451.             (void) pstatus(client, prognum, MIN_VERS);
  452.             exit(1);
  453.         }
  454.         clnt_destroy(client);
  455.         (void) close(sock);
  456.         sock = RPC_ANYSOCK; /* Re-initialize it for later */
  457.         for (vers = minvers; vers <= maxvers; vers++) {
  458.             addr.sin_port = htons(portnum);
  459.             if ((client = clnttcp_create(&addr, prognum, vers,
  460.                 &sock, 0, 0)) == NULL) {
  461.                 clnt_pcreateerror("rpcinfo");
  462.                 printf("program %lu version %lu is not available\n",
  463.                     prognum, vers);
  464.                 exit(1);
  465.             }
  466.             to.tv_usec = 0;
  467.             to.tv_sec = 10;
  468.             rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
  469.                 xdr_void, (char *)NULL, to);
  470.             if (pstatus(client, prognum, vers) < 0)
  471.                 failure = 1;
  472.             clnt_destroy(client);
  473.             (void) close(sock);
  474.             sock = RPC_ANYSOCK;
  475.         }
  476.     }
  477.     else {
  478.         vers = getvers(argv[2]);
  479.         addr.sin_port = htons(portnum);
  480.         if ((client = clnttcp_create(&addr, prognum, vers, &sock,
  481.             0, 0)) == NULL) {
  482.             clnt_pcreateerror("rpcinfo");
  483.             printf("program %lu version %lu is not available\n",
  484.                 prognum, vers);
  485.             exit(1);
  486.         }
  487.         to.tv_usec = 0;
  488.         to.tv_sec = 10;
  489.         rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
  490.             xdr_void, (char *)NULL, to);
  491.         if (pstatus(client, prognum, vers) < 0)
  492.             failure = 1;
  493.     }
  494.     if (failure)
  495.         exit(1);
  496. }
  497.  
  498. /*
  499.  * This routine should take a pointer to an "rpc_err" structure, rather than
  500.  * a pointer to a CLIENT structure, but "clnt_perror" takes a pointer to
  501.  * a CLIENT structure rather than a pointer to an "rpc_err" structure.
  502.  * As such, we have to keep the CLIENT structure around in order to print
  503.  * a good error message.
  504.  */
  505. static int
  506. pstatus(register CLIENT *client, u_long prognum, u_long vers)
  507. {
  508.     struct rpc_err rpcerr;
  509.  
  510.     clnt_geterr(client, &rpcerr);
  511.     if (rpcerr.re_status != RPC_SUCCESS) {
  512.         clnt_perror(client, "rpcinfo");
  513.         printf("program %lu version %lu is not available\n",
  514.             prognum, vers);
  515.         return (-1);
  516.     } else {
  517.         printf("program %lu version %lu ready and waiting\n",
  518.             prognum, vers);
  519.         return (0);
  520.     }
  521. }
  522.  
  523. static void
  524. pmapdump(int argc, char **argv)
  525. {
  526.     struct sockaddr_in server_addr;
  527.     register struct hostent *hp;
  528.     struct pmaplist *head = NULL;
  529.     int socket = RPC_ANYSOCK;
  530.     struct timeval minutetimeout;
  531.     register CLIENT *client;
  532.     struct rpcent *rpc;
  533.     
  534.     if (argc > 1) {
  535.         usage();
  536.         exit(1);
  537.     }
  538.     if (argc == 1)
  539.         get_inet_address(&server_addr, argv[0]);
  540.     else {
  541.         bzero((char *)&server_addr, sizeof server_addr);
  542.         server_addr.sin_family = AF_INET;
  543.         if ((hp = gethostbyname("localhost")) != NULL)
  544.             bcopy(hp->h_addr, (caddr_t)&server_addr.sin_addr,
  545.                 hp->h_length);
  546.         else
  547.             server_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
  548.     }
  549.     minutetimeout.tv_sec = 60;
  550.     minutetimeout.tv_usec = 0;
  551.     server_addr.sin_port = htons(PMAPPORT);
  552.     if ((client = clnttcp_create(&server_addr, PMAPPROG,
  553.         PMAPVERS, &socket, 50, 500)) == NULL) {
  554.         clnt_pcreateerror("rpcinfo: can't contact portmapper");
  555.         exit(1);
  556.     }
  557.     if (clnt_call(client, PMAPPROC_DUMP, xdr_void, NULL,
  558.         xdr_pmaplist, &head, minutetimeout) != RPC_SUCCESS) {
  559.         fprintf(stderr, "rpcinfo: can't contact portmapper: ");
  560.         clnt_perror(client, "rpcinfo");
  561.         exit(1);
  562.     }
  563.     if (head == NULL) {
  564.         printf("No remote programs registered.\n");
  565.     } else {
  566.         printf("   program vers proto   port\n");
  567.         for (; head != NULL; head = head->pml_next) {
  568.             printf("%10ld%5ld",
  569.                 head->pml_map.pm_prog,
  570.                 head->pml_map.pm_vers);
  571.             if (head->pml_map.pm_prot == IPPROTO_UDP)
  572.                 printf("%6s",  "udp");
  573.             else if (head->pml_map.pm_prot == IPPROTO_TCP)
  574.                 printf("%6s", "tcp");
  575.             else
  576.                 printf("%6ld",  head->pml_map.pm_prot);
  577.             printf("%7ld",  head->pml_map.pm_port);
  578.             rpc = getrpcbynumber(head->pml_map.pm_prog);
  579.             if (rpc)
  580.                 printf("  %s\n", rpc->r_name);
  581.             else
  582.                 printf("\n");
  583.         }
  584.     }
  585. }
  586.  
  587. /* 
  588.  * reply_proc collects replies from the broadcast. 
  589.  * to get a unique list of responses the output of rpcinfo should
  590.  * be piped through sort(1) and then uniq(1).
  591.  */
  592.  
  593. /*ARGSUSED*/
  594. static bool_t
  595. reply_proc(void *res, struct sockaddr_in *who)
  596.     /* res - Nothing comes back */
  597.     /* who - Who sent us the reply */
  598. {
  599.     register struct hostent *hp;
  600.  
  601.     hp = gethostbyaddr((char *) &who->sin_addr, sizeof who->sin_addr,
  602.         AF_INET);
  603.     printf("%s %s\n", inet_ntoa(who->sin_addr),
  604.         (hp == NULL) ? "(unknown)" : hp->h_name);
  605.     return(FALSE);
  606. }
  607.  
  608. static void
  609. brdcst(int argc, char **argv)
  610. {
  611.     enum clnt_stat rpc_stat;
  612.     u_long prognum, vers;
  613.  
  614.     if (argc != 2) {
  615.         usage();
  616.         exit(1);
  617.     }
  618.     prognum = getprognum(argv[0]);
  619.     vers = getvers(argv[1]);
  620.     rpc_stat = clnt_broadcast(prognum, vers, NULLPROC, xdr_void,
  621.         (char *)NULL, xdr_void, (char *)NULL, reply_proc);
  622.     if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) {
  623.         fprintf(stderr, "rpcinfo: broadcast failed: %s\n",
  624.             clnt_sperrno(rpc_stat));
  625.         exit(1);
  626.     }
  627.     exit(0);
  628. }
  629.  
  630. static void
  631. deletereg(int argc, char **argv)
  632. {
  633.     u_long prog_num, version_num ;
  634.  
  635.     if (argc != 2) {
  636.         usage() ;
  637.         exit(1) ;
  638.     }
  639.     if (getuid()) { /* This command allowed only to root */
  640.         fprintf(stderr, "Sorry. You are not root\n") ;
  641.         exit(1) ;
  642.     }
  643.     prog_num = getprognum(argv[0]);
  644.     version_num = getvers(argv[1]);
  645.     if ((pmap_unset(prog_num, version_num)) == 0) {
  646.         fprintf(stderr, "rpcinfo: Could not delete registration for prog %s version %s\n",
  647.             argv[0], argv[1]) ;
  648.         exit(1) ;
  649.     }
  650. }
  651.  
  652. static void
  653. usage(void)
  654. {
  655.     fprintf(stderr, "Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n");
  656.     fprintf(stderr, "       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n");
  657.     fprintf(stderr, "       rpcinfo -p [ host ]\n");
  658.     fprintf(stderr, "       rpcinfo -b prognum versnum\n");
  659.     fprintf(stderr, "       rpcinfo -d prognum versnum\n") ;
  660. }
  661.  
  662. static u_long
  663. getprognum(char *arg)
  664. {
  665.     register struct rpcent *rpc;
  666.     register u_long prognum;
  667.  
  668.     if (isalpha(*arg)) {
  669.         rpc = getrpcbyname(arg);
  670.         if (rpc == NULL) {
  671.             fprintf(stderr, "rpcinfo: %s is unknown service\n",
  672.                 arg);
  673.             exit(1);
  674.         }
  675.         prognum = rpc->r_number;
  676.     } else {
  677.         prognum = (u_long) atoi(arg);
  678.     }
  679.  
  680.     return (prognum);
  681. }
  682.  
  683. static u_long
  684. getvers(char *arg)
  685. {
  686.     register u_long vers;
  687.  
  688.     vers = (int) atoi(arg);
  689.     return (vers);
  690. }
  691.  
  692. static void
  693. get_inet_address(struct sockaddr_in *addr, char *host)
  694. {
  695.     register struct hostent *hp;
  696.  
  697.     bzero((char *)addr, sizeof *addr);
  698.     addr->sin_addr.s_addr = (u_long) inet_addr(host);
  699.     if (addr->sin_addr.s_addr == -1 || addr->sin_addr.s_addr == 0) {
  700.         if ((hp = gethostbyname(host)) == NULL) {
  701.             fprintf(stderr, "rpcinfo: %s is unknown host\n", host);
  702.             exit(1);
  703.         }
  704.         bcopy(hp->h_addr, (char *)&addr->sin_addr, hp->h_length);
  705.     }
  706.     addr->sin_family = AF_INET;
  707. }
  708.