1 /* $NetBSD: rpcinfo.c,v 1.15 2000/10/04 20:09:05 mjl Exp $ */
4 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
5 * unrestricted use provided that this legend is included on all tape
6 * media and as a part of the software program in whole or part. Users
7 * may copy or modify Sun RPC without charge, but are not authorized
8 * to license or distribute it to anyone else except as part of a product or
9 * program developed by the user.
11 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
12 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
13 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
15 * Sun RPC is provided with no support and without any obligation on the
16 * part of Sun Microsystems, Inc. to assist in its use, correction,
17 * modification or enhancement.
19 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
20 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
21 * OR ANY PART THEREOF.
23 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
24 * or profits or other special, indirect and consequential damages, even if
25 * Sun has been advised of the possibility of such damages.
27 * Sun Microsystems, Inc.
29 * Mountain View, California 94043
33 * Copyright (c) 1986 - 1991 by Sun Microsystems, Inc.
36 /* #ident "@(#)rpcinfo.c 1.18 93/07/05 SMI" */
40 static char sccsid[] = "@(#)rpcinfo.c 1.16 89/04/05 Copyr 1986 Sun Micro";
44 #include <sys/cdefs.h>
45 __FBSDID("$FreeBSD$");
48 * rpcinfo: ping a particular rpc program
49 * or dump the registered programs on the remote machine.
53 * We are for now defining PORTMAP here. It doesn't even compile
54 * unless it is defined.
61 * If PORTMAP is defined, rpcinfo will talk to both portmapper and
62 * rpcbind programs; else it talks only to rpcbind. In the latter case
63 * all the portmapper specific options such as -u, -t, -p become void.
65 #include <sys/types.h>
66 #include <sys/param.h>
67 #include <sys/socket.h>
71 #include <rpc/rpcb_prot.h>
72 #include <rpc/rpcent.h>
73 #include <rpc/nettype.h>
74 #include <rpc/rpc_com.h>
81 #ifdef PORTMAP /* Support for version 2 portmapper */
82 #include <netinet/in.h>
84 #include <arpa/inet.h>
85 #include <rpc/pmap_prot.h>
86 #include <rpc/pmap_clnt.h>
89 #define MAXHOSTLEN 256
90 #define MIN_VERS ((u_long) 0)
91 #define MAX_VERS ((u_long) 4294967295UL)
92 #define UNKNOWN "unknown"
95 * Functions to be performed.
97 #define NONE 0 /* no function */
98 #define PMAPDUMP 1 /* dump portmapper registrations */
99 #define TCPPING 2 /* ping TCP service */
100 #define UDPPING 3 /* ping UDP service */
101 #define BROADCAST 4 /* ping broadcast service */
102 #define DELETES 5 /* delete registration for the service */
103 #define ADDRPING 6 /* pings at the given address */
104 #define PROGPING 7 /* pings a program on a given host */
105 #define RPCBDUMP 8 /* dump rpcbind registrations */
106 #define RPCBDUMP_SHORT 9 /* dump rpcbind registrations - short version */
107 #define RPCBADDRLIST 10 /* dump addr list about one prog */
108 #define RPCBGETSTAT 11 /* Get statistics */
112 struct netidlist *next;
117 struct verslist *next;
120 struct rpcbdump_short {
122 struct verslist *vlist;
123 struct netidlist *nlist;
124 struct rpcbdump_short *next;
131 static void ip_ping(u_short, const char *, int, char **);
132 static CLIENT *clnt_com_create(struct sockaddr_in *, u_long, u_long, int *,
134 static void pmapdump(int, char **);
135 static void get_inet_address(struct sockaddr_in *, char *);
138 static bool_t reply_proc(void *, struct netbuf *, struct netconfig *);
139 static void brdcst(int, char **);
140 static void addrping(char *, char *, int, char **);
141 static void progping(char *, int, char **);
142 static CLIENT *clnt_addr_create(char *, struct netconfig *, u_long, u_long);
143 static CLIENT *clnt_rpcbind_create(char *, int, struct netbuf **);
144 static CLIENT *getclnthandle(char *, struct netconfig *, u_long,
146 static CLIENT *local_rpcb(u_long, u_long);
147 static int pstatus(CLIENT *, u_long, u_long);
148 static void rpcbdump(int, char *, int, char **);
149 static void rpcbgetstat(int, char **);
150 static void rpcbaddrlist(char *, int, char **);
151 static void deletereg(char *, int, char **);
152 static void print_rmtcallstat(int, rpcb_stat *);
153 static void print_getaddrstat(int, rpcb_stat *);
154 static void usage(void);
155 static u_long getprognum(char *);
156 static u_long getvers(char *);
157 static char *spaces(int);
158 static bool_t add_version(struct rpcbdump_short *, u_long);
159 static bool_t add_netid(struct rpcbdump_short *, char *);
162 main(int argc, char **argv)
168 char *address = NULL;
177 while ((c = getopt(argc, argv, "a:bdlmn:pstT:u")) != -1) {
179 while ((c = getopt(argc, argv, "a:bdlmn:sT:")) != -1) {
184 if (function != NONE)
191 if (function != NONE)
198 if (function != NONE)
205 portnum = (u_short) strtol(optarg, &strptr, 10);
206 if (strptr == optarg || *strptr != '\0')
207 errx(1, "%s is illegal port number", optarg);
212 if (function != NONE)
218 if (function != NONE)
221 function = BROADCAST;
225 if (function != NONE)
232 if (function != NONE)
235 function = RPCBADDRLIST;
239 if (function != NONE)
242 function = RPCBGETSTAT;
246 if (function != NONE)
249 function = RPCBDUMP_SHORT;
261 if (errflg || ((function == ADDRPING) && !netid))
264 if (function == NONE) {
265 if (argc - optind > 1)
276 pmapdump(argc - optind, argv + optind);
280 ip_ping(portnum, "udp", argc - optind, argv + optind);
284 ip_ping(portnum, "tcp", argc - optind, argv + optind);
288 brdcst(argc - optind, argv + optind);
291 deletereg(netid, argc - optind, argv + optind);
294 addrping(address, netid, argc - optind, argv + optind);
297 progping(netid, argc - optind, argv + optind);
301 rpcbdump(function, netid, argc - optind, argv + optind);
304 rpcbgetstat(argc - optind, argv + optind);
307 rpcbaddrlist(netid, argc - optind, argv + optind);
314 local_rpcb(u_long prog, u_long vers)
317 struct netconfig *nconf;
320 localhandle = setnetconfig();
321 while ((nconf = getnetconfig(localhandle)) != NULL) {
322 if (nconf->nc_protofmly != NULL &&
323 strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0)
327 warnx("getnetconfig: %s", nc_sperror());
331 clnt = clnt_tp_create(NULL, prog, vers, nconf);
332 endnetconfig(localhandle);
338 clnt_com_create(struct sockaddr_in *addr, u_long prog, u_long vers,
339 int *fdp, const char *trans)
343 if (strcmp(trans, "tcp") == 0) {
344 clnt = clnttcp_create(addr, prog, vers, fdp, 0, 0);
350 clnt = clntudp_create(addr, prog, vers, to, fdp);
352 if (clnt == (CLIENT *)NULL) {
353 clnt_pcreateerror("rpcinfo");
354 if (vers == MIN_VERS)
355 printf("program %lu is not available\n", prog);
357 printf("program %lu version %lu is not available\n",
365 * If portnum is 0, then go and get the address from portmapper, which happens
366 * transparently through clnt*_create(); If version number is not given, it
367 * tries to find out the version number by making a call to version 0 and if
368 * that fails, it obtains the high order and the low order version number. If
369 * version 0 calls succeeds, it tries for MAXVERS call and repeats the same.
372 ip_ping(u_short portnum, const char *trans, int argc, char **argv)
377 struct sockaddr_in addr;
378 enum clnt_stat rpc_stat;
379 u_long prognum, vers, minvers, maxvers;
380 struct rpc_err rpcerr;
383 if (argc < 2 || argc > 3)
387 prognum = getprognum(argv[1]);
388 get_inet_address(&addr, argv[0]);
389 if (argc == 2) { /* Version number not known */
391 * A call to version 0 should fail with a program/version
392 * mismatch, and give us the range of versions supported.
396 vers = getvers(argv[2]);
398 addr.sin_port = htons(portnum);
399 client = clnt_com_create(&addr, prognum, vers, &fd, trans);
400 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
401 (char *)NULL, (xdrproc_t) xdr_void, (char *)NULL,
404 /* Version number was known */
405 if (pstatus(client, prognum, vers) < 0)
407 (void) CLNT_DESTROY(client);
410 /* Version number not known */
411 (void) CLNT_CONTROL(client, CLSET_FD_NCLOSE, (char *)NULL);
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) {
418 * Oh dear, it DOES support version 0.
419 * Let's try version MAX_VERS.
421 (void) CLNT_DESTROY(client);
422 addr.sin_port = htons(portnum);
423 client = clnt_com_create(&addr, prognum, MAX_VERS, &fd, trans);
424 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
425 (char *)NULL, (xdrproc_t) xdr_void,
427 if (rpc_stat == RPC_PROGVERSMISMATCH) {
428 clnt_geterr(client, &rpcerr);
429 minvers = rpcerr.re_vers.low;
430 maxvers = rpcerr.re_vers.high;
431 } else if (rpc_stat == RPC_SUCCESS) {
433 * It also supports version MAX_VERS.
434 * Looks like we have a wise guy.
435 * OK, we give them information on all
436 * 4 billion versions they support...
441 (void) pstatus(client, prognum, MAX_VERS);
445 (void) pstatus(client, prognum, (u_long)0);
448 (void) CLNT_DESTROY(client);
449 for (vers = minvers; vers <= maxvers; vers++) {
450 addr.sin_port = htons(portnum);
451 client = clnt_com_create(&addr, prognum, vers, &fd, trans);
452 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
453 (char *)NULL, (xdrproc_t) xdr_void,
455 if (pstatus(client, prognum, vers) < 0)
457 (void) CLNT_DESTROY(client);
466 * Dump all the portmapper registerations
469 pmapdump(int argc, char **argv)
471 struct sockaddr_in server_addr;
472 struct pmaplist *head = NULL;
473 int socket = RPC_ANYSOCK;
474 struct timeval minutetimeout;
475 register CLIENT *client;
477 enum clnt_stat clnt_st;
485 get_inet_address(&server_addr, host);
486 server_addr.sin_port = htons(PMAPPORT);
487 client = clnttcp_create(&server_addr, PMAPPROG, PMAPVERS,
490 client = local_rpcb(PMAPPROG, PMAPVERS);
492 if (client == NULL) {
493 if (rpc_createerr.cf_stat == RPC_TLIERROR) {
495 * "Misc. TLI error" is not too helpful. Most likely
496 * the connection to the remote server timed out, so
497 * this error is at least less perplexing.
499 rpc_createerr.cf_stat = RPC_PMAPFAILURE;
500 rpc_createerr.cf_error.re_status = RPC_FAILED;
502 clnt_pcreateerror("rpcinfo: can't contact portmapper");
506 minutetimeout.tv_sec = 60;
507 minutetimeout.tv_usec = 0;
509 clnt_st = CLNT_CALL(client, PMAPPROC_DUMP, (xdrproc_t) xdr_void,
510 NULL, (xdrproc_t) xdr_pmaplist_ptr, (char *)&head,
512 if (clnt_st != RPC_SUCCESS) {
513 if ((clnt_st == RPC_PROGVERSMISMATCH) ||
514 (clnt_st == RPC_PROGUNAVAIL)) {
515 CLNT_GETERR(client, &err);
516 if (err.re_vers.low > PMAPVERS) {
518 warnx("%s does not support portmapper."
519 "Try rpcinfo %s instead", host,
522 warnx("local host does not support "
523 "portmapper. Try 'rpcinfo' "
528 clnt_perror(client, "rpcinfo: can't contact portmapper");
532 printf("No remote programs registered.\n");
534 printf(" program vers proto port service\n");
535 for (; head != NULL; head = head->pml_next) {
537 head->pml_map.pm_prog,
538 head->pml_map.pm_vers);
539 if (head->pml_map.pm_prot == IPPROTO_UDP)
540 printf("%6s", "udp");
541 else if (head->pml_map.pm_prot == IPPROTO_TCP)
542 printf("%6s", "tcp");
543 else if (head->pml_map.pm_prot == IPPROTO_ST)
544 printf("%6s", "local");
546 printf("%6ld", head->pml_map.pm_prot);
547 printf("%7ld", head->pml_map.pm_port);
548 rpc = getrpcbynumber(head->pml_map.pm_prog);
550 printf(" %s\n", rpc->r_name);
558 get_inet_address(struct sockaddr_in *addr, char *host)
560 struct netconfig *nconf;
561 struct addrinfo hints, *res;
564 (void) memset((char *)addr, 0, sizeof (*addr));
565 addr->sin_addr.s_addr = inet_addr(host);
566 if (addr->sin_addr.s_addr == INADDR_NONE ||
567 addr->sin_addr.s_addr == INADDR_ANY) {
568 if ((nconf = __rpc_getconfip("udp")) == NULL &&
569 (nconf = __rpc_getconfip("tcp")) == NULL)
570 errx(1, "couldn't find a suitable transport");
572 memset(&hints, 0, sizeof hints);
573 hints.ai_family = AF_INET;
574 if ((error = getaddrinfo(host, "rpcbind", &hints, &res))
576 errx(1, "%s: %s", host, gai_strerror(error));
578 memcpy(addr, res->ai_addr, res->ai_addrlen);
581 (void) freenetconfigent(nconf);
584 addr->sin_family = AF_INET;
590 * reply_proc collects replies from the broadcast.
591 * to get a unique list of responses the output of rpcinfo should
592 * be piped through sort(1) and then uniq(1).
597 reply_proc(void *res, struct netbuf *who, struct netconfig *nconf)
598 /* void *res; Nothing comes back */
599 /* struct netbuf *who; Who sent us the reply */
600 /* struct netconfig *nconf; On which transport the reply came */
603 char hostbuf[NI_MAXHOST];
604 const char *hostname;
605 struct sockaddr *sa = (struct sockaddr *)who->buf;
607 if (getnameinfo(sa, sa->sa_len, hostbuf, NI_MAXHOST, NULL, 0, 0)) {
612 if (!(uaddr = taddr2uaddr(nconf, who))) {
615 printf("%s\t%s\n", uaddr, hostname);
616 if (strcmp(uaddr, UNKNOWN))
622 brdcst(int argc, char **argv)
624 enum clnt_stat rpc_stat;
625 u_long prognum, vers;
629 prognum = getprognum(argv[0]);
630 vers = getvers(argv[1]);
631 rpc_stat = rpc_broadcast(prognum, vers, NULLPROC,
632 (xdrproc_t) xdr_void, (char *)NULL, (xdrproc_t) xdr_void,
633 (char *)NULL, (resultproc_t) reply_proc, NULL);
634 if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT))
635 errx(1, "broadcast failed: %s", clnt_sperrno(rpc_stat));
640 add_version(struct rpcbdump_short *rs, u_long vers)
644 for (vl = rs->vlist; vl; vl = vl->next)
645 if (vl->vers == vers)
649 vl = (struct verslist *)malloc(sizeof (struct verslist));
653 vl->next = rs->vlist;
659 add_netid(struct rpcbdump_short *rs, char *netid)
661 struct netidlist *nl;
663 for (nl = rs->nlist; nl; nl = nl->next)
664 if (strcmp(nl->netid, netid) == 0)
668 nl = (struct netidlist *)malloc(sizeof (struct netidlist));
672 nl->next = rs->nlist;
678 rpcbdump(int dumptype, char *netid, int argc, char **argv)
680 rpcblist_ptr head = NULL;
681 struct timeval minutetimeout;
682 register CLIENT *client;
685 struct netidlist *nl;
687 struct rpcbdump_short *rs, *rs_tail;
689 enum clnt_stat clnt_st;
691 struct rpcbdump_short *rs_head = NULL;
698 client = clnt_rpcbind_create(host, RPCBVERS, NULL);
700 struct netconfig *nconf;
702 nconf = getnetconfigent(netid);
704 nc_perror("rpcinfo: invalid transport");
707 client = getclnthandle(host, nconf, RPCBVERS, NULL);
709 (void) freenetconfigent(nconf);
712 client = local_rpcb(PMAPPROG, RPCBVERS);
714 if (client == (CLIENT *)NULL) {
715 clnt_pcreateerror("rpcinfo: can't contact rpcbind");
719 minutetimeout.tv_sec = 60;
720 minutetimeout.tv_usec = 0;
721 clnt_st = CLNT_CALL(client, RPCBPROC_DUMP, (xdrproc_t) xdr_void,
722 NULL, (xdrproc_t) xdr_rpcblist_ptr, (char *) &head,
724 if (clnt_st != RPC_SUCCESS) {
725 if ((clnt_st == RPC_PROGVERSMISMATCH) ||
726 (clnt_st == RPC_PROGUNAVAIL)) {
729 CLNT_GETERR(client, &err);
730 if (err.re_vers.low == RPCBVERS4) {
732 clnt_control(client, CLSET_VERS, (char *)&vers);
733 clnt_st = CLNT_CALL(client, RPCBPROC_DUMP,
734 (xdrproc_t) xdr_void, NULL,
735 (xdrproc_t) xdr_rpcblist_ptr, (char *) &head,
737 if (clnt_st != RPC_SUCCESS)
740 if (err.re_vers.high == PMAPVERS) {
742 struct pmaplist *pmaphead = NULL;
743 rpcblist_ptr list, prev;
746 clnt_control(client, CLSET_VERS, (char *)&vers);
747 clnt_st = CLNT_CALL(client, PMAPPROC_DUMP,
748 (xdrproc_t) xdr_void, NULL,
749 (xdrproc_t) xdr_pmaplist_ptr,
750 (char *)&pmaphead, minutetimeout);
751 if (clnt_st != RPC_SUCCESS)
754 * convert to rpcblist_ptr format
756 for (head = NULL; pmaphead != NULL;
757 pmaphead = pmaphead->pml_next) {
758 list = (rpcblist *)malloc(sizeof (rpcblist));
764 prev->rpcb_next = (rpcblist_ptr) list;
766 list->rpcb_next = NULL;
767 list->rpcb_map.r_prog = pmaphead->pml_map.pm_prog;
768 list->rpcb_map.r_vers = pmaphead->pml_map.pm_vers;
769 if (pmaphead->pml_map.pm_prot == IPPROTO_UDP)
770 list->rpcb_map.r_netid = "udp";
771 else if (pmaphead->pml_map.pm_prot == IPPROTO_TCP)
772 list->rpcb_map.r_netid = "tcp";
774 #define MAXLONG_AS_STRING "2147483648"
775 list->rpcb_map.r_netid =
776 malloc(strlen(MAXLONG_AS_STRING) + 1);
777 if (list->rpcb_map.r_netid == NULL)
779 sprintf(list->rpcb_map.r_netid, "%6ld",
780 pmaphead->pml_map.pm_prot);
782 list->rpcb_map.r_owner = UNKNOWN;
783 low = pmaphead->pml_map.pm_port & 0xff;
784 high = (pmaphead->pml_map.pm_port >> 8) & 0xff;
785 list->rpcb_map.r_addr = strdup("0.0.0.0.XXX.XXX");
786 sprintf(&list->rpcb_map.r_addr[8], "%d.%d",
792 } else { /* any other error */
794 clnt_perror(client, "rpcinfo: can't contact rpcbind: ");
799 printf("No remote programs registered.\n");
800 } else if (dumptype == RPCBDUMP) {
802 " program version netid address service owner\n");
803 for (; head != NULL; head = head->rpcb_next) {
805 head->rpcb_map.r_prog, head->rpcb_map.r_vers);
806 printf("%-9s ", head->rpcb_map.r_netid);
807 printf("%-22s", head->rpcb_map.r_addr);
808 rpc = getrpcbynumber(head->rpcb_map.r_prog);
810 printf(" %-10s", rpc->r_name);
812 printf(" %-10s", "-");
813 printf(" %s\n", head->rpcb_map.r_owner);
815 } else if (dumptype == RPCBDUMP_SHORT) {
816 for (; head != NULL; head = head->rpcb_next) {
817 for (rs = rs_head; rs; rs = rs->next)
818 if (head->rpcb_map.r_prog == rs->prog)
821 rs = (struct rpcbdump_short *)
822 malloc(sizeof (struct rpcbdump_short));
826 if (rs_head == NULL) {
833 rs->prog = head->rpcb_map.r_prog;
834 rs->owner = head->rpcb_map.r_owner;
838 if (add_version(rs, head->rpcb_map.r_vers) == FALSE)
840 if (add_netid(rs, head->rpcb_map.r_netid) == FALSE)
844 " program version(s) netid(s) service owner\n");
845 for (rs = rs_head; rs; rs = rs->next) {
848 printf("%10ld ", rs->prog);
849 for (vl = rs->vlist; vl; vl = vl->next) {
850 sprintf(p, "%d", vl->vers);
855 printf("%-10s", buf);
857 for (nl = rs->nlist; nl; nl = nl->next) {
858 strcat(buf, nl->netid);
862 printf("%-32s", buf);
863 rpc = getrpcbynumber(rs->prog);
865 printf(" %-11s", rpc->r_name);
867 printf(" %-11s", "-");
868 printf(" %s\n", rs->owner);
871 clnt_destroy(client);
873 error: warnx("no memory");
877 static char nullstring[] = "\000";
880 rpcbaddrlist(char *netid, int argc, char **argv)
882 rpcb_entry_list_ptr head = NULL;
883 struct timeval minutetimeout;
884 register CLIENT *client;
888 struct netbuf *targaddr;
894 client = clnt_rpcbind_create(host, RPCBVERS4, &targaddr);
896 struct netconfig *nconf;
898 nconf = getnetconfigent(netid);
900 nc_perror("rpcinfo: invalid transport");
903 client = getclnthandle(host, nconf, RPCBVERS4, &targaddr);
905 (void) freenetconfigent(nconf);
907 if (client == (CLIENT *)NULL) {
908 clnt_pcreateerror("rpcinfo: can't contact rpcbind");
911 minutetimeout.tv_sec = 60;
912 minutetimeout.tv_usec = 0;
914 parms.r_prog = getprognum(argv[1]);
915 parms.r_vers = getvers(argv[2]);
916 parms.r_netid = client->cl_netid;
917 if (targaddr == NULL) {
918 parms.r_addr = nullstring; /* for XDRing */
921 * We also send the remote system the address we
922 * used to contact it in case it can help it
923 * connect back with us
925 struct netconfig *nconf;
927 nconf = getnetconfigent(client->cl_netid);
929 parms.r_addr = taddr2uaddr(nconf, targaddr);
930 if (parms.r_addr == NULL)
931 parms.r_addr = nullstring;
932 freenetconfigent(nconf);
934 parms.r_addr = nullstring; /* for XDRing */
939 parms.r_owner = nullstring;
941 if (CLNT_CALL(client, RPCBPROC_GETADDRLIST, (xdrproc_t) xdr_rpcb,
942 (char *) &parms, (xdrproc_t) xdr_rpcb_entry_list_ptr,
943 (char *) &head, minutetimeout) != RPC_SUCCESS) {
944 clnt_perror(client, "rpcinfo: can't contact rpcbind: ");
948 printf("No remote programs registered.\n");
951 " program vers tp_family/name/class address\t\t service\n");
952 for (; head != NULL; head = head->rpcb_entry_next) {
956 re = &head->rpcb_entry_map;
958 parms.r_prog, parms.r_vers);
959 sprintf(buf, "%s/%s/%s ",
960 re->r_nc_protofmly, re->r_nc_proto,
961 re->r_nc_semantics == NC_TPI_CLTS ? "clts" :
962 re->r_nc_semantics == NC_TPI_COTS ? "cots" :
964 printf("%-24s", buf);
965 printf("%-24s", re->r_maddr);
966 rpc = getrpcbynumber(parms.r_prog);
968 printf(" %-13s", rpc->r_name);
970 printf(" %-13s", "-");
974 clnt_destroy(client);
982 rpcbgetstat(int argc, char **argv)
984 rpcb_stat_byvers inf;
985 struct timeval minutetimeout;
986 register CLIENT *client;
990 rpcbs_rmtcalllist *pr;
993 char fieldbuf[MAXFIELD];
995 char linebuf[MAXLINE];
997 const char *pmaphdr[] = {
998 "NULL", "SET", "UNSET", "GETPORT",
1001 const char *rpcb3hdr[] = {
1002 "NULL", "SET", "UNSET", "GETADDR", "DUMP", "CALLIT", "TIME",
1005 const char *rpcb4hdr[] = {
1006 "NULL", "SET", "UNSET", "GETADDR", "DUMP", "CALLIT", "TIME",
1007 "U2T", "T2U", "VERADDR", "INDRECT", "GETLIST", "GETSTAT"
1014 client = clnt_rpcbind_create(host, RPCBVERS4, NULL);
1016 client = local_rpcb(PMAPPROG, RPCBVERS4);
1017 if (client == (CLIENT *)NULL) {
1018 clnt_pcreateerror("rpcinfo: can't contact rpcbind");
1021 minutetimeout.tv_sec = 60;
1022 minutetimeout.tv_usec = 0;
1023 memset((char *)&inf, 0, sizeof (rpcb_stat_byvers));
1024 if (CLNT_CALL(client, RPCBPROC_GETSTAT, (xdrproc_t) xdr_void, NULL,
1025 (xdrproc_t) xdr_rpcb_stat_byvers, (char *)&inf, minutetimeout)
1027 clnt_perror(client, "rpcinfo: can't contact rpcbind: ");
1030 printf("PORTMAP (version 2) statistics\n");
1032 for (i = 0; i <= rpcb_highproc_2; i++) {
1036 sprintf(fieldbuf, "%d/", inf[RPCBVERS_2_STAT].setinfo);
1038 case PMAPPROC_UNSET:
1039 sprintf(fieldbuf, "%d/",
1040 inf[RPCBVERS_2_STAT].unsetinfo);
1042 case PMAPPROC_GETPORT:
1044 for (pa = inf[RPCBVERS_2_STAT].addrinfo; pa;
1047 sprintf(fieldbuf, "%d/", cnt);
1049 case PMAPPROC_CALLIT:
1051 for (pr = inf[RPCBVERS_2_STAT].rmtinfo; pr;
1054 sprintf(fieldbuf, "%d/", cnt);
1056 default: break; /* For the remaining ones */
1058 cp = &fieldbuf[0] + strlen(fieldbuf);
1059 sprintf(cp, "%d", inf[RPCBVERS_2_STAT].info[i]);
1060 flen = strlen(fieldbuf);
1061 printf("%s%s", pmaphdr[i],
1062 spaces((TABSTOP * (1 + flen / TABSTOP))
1063 - strlen(pmaphdr[i])));
1064 sprintf(lp, "%s%s", fieldbuf,
1065 spaces(cnt = ((TABSTOP * (1 + flen / TABSTOP))
1069 printf("\n%s\n\n", linebuf);
1071 if (inf[RPCBVERS_2_STAT].info[PMAPPROC_CALLIT]) {
1072 printf("PMAP_RMTCALL call statistics\n");
1073 print_rmtcallstat(RPCBVERS_2_STAT, &inf[RPCBVERS_2_STAT]);
1077 if (inf[RPCBVERS_2_STAT].info[PMAPPROC_GETPORT]) {
1078 printf("PMAP_GETPORT call statistics\n");
1079 print_getaddrstat(RPCBVERS_2_STAT, &inf[RPCBVERS_2_STAT]);
1083 printf("RPCBIND (version 3) statistics\n");
1085 for (i = 0; i <= rpcb_highproc_3; i++) {
1089 sprintf(fieldbuf, "%d/", inf[RPCBVERS_3_STAT].setinfo);
1091 case RPCBPROC_UNSET:
1092 sprintf(fieldbuf, "%d/",
1093 inf[RPCBVERS_3_STAT].unsetinfo);
1095 case RPCBPROC_GETADDR:
1097 for (pa = inf[RPCBVERS_3_STAT].addrinfo; pa;
1100 sprintf(fieldbuf, "%d/", cnt);
1102 case RPCBPROC_CALLIT:
1104 for (pr = inf[RPCBVERS_3_STAT].rmtinfo; pr;
1107 sprintf(fieldbuf, "%d/", cnt);
1109 default: break; /* For the remaining ones */
1111 cp = &fieldbuf[0] + strlen(fieldbuf);
1112 sprintf(cp, "%d", inf[RPCBVERS_3_STAT].info[i]);
1113 flen = strlen(fieldbuf);
1114 printf("%s%s", rpcb3hdr[i],
1115 spaces((TABSTOP * (1 + flen / TABSTOP))
1116 - strlen(rpcb3hdr[i])));
1117 sprintf(lp, "%s%s", fieldbuf,
1118 spaces(cnt = ((TABSTOP * (1 + flen / TABSTOP))
1122 printf("\n%s\n\n", linebuf);
1124 if (inf[RPCBVERS_3_STAT].info[RPCBPROC_CALLIT]) {
1125 printf("RPCB_RMTCALL (version 3) call statistics\n");
1126 print_rmtcallstat(RPCBVERS_3_STAT, &inf[RPCBVERS_3_STAT]);
1130 if (inf[RPCBVERS_3_STAT].info[RPCBPROC_GETADDR]) {
1131 printf("RPCB_GETADDR (version 3) call statistics\n");
1132 print_getaddrstat(RPCBVERS_3_STAT, &inf[RPCBVERS_3_STAT]);
1136 printf("RPCBIND (version 4) statistics\n");
1138 for (j = 0; j <= 9; j += 9) { /* Just two iterations for printing */
1140 for (i = j; i <= MAX(8, rpcb_highproc_4 - 9 + j); i++) {
1144 sprintf(fieldbuf, "%d/",
1145 inf[RPCBVERS_4_STAT].setinfo);
1147 case RPCBPROC_UNSET:
1148 sprintf(fieldbuf, "%d/",
1149 inf[RPCBVERS_4_STAT].unsetinfo);
1151 case RPCBPROC_GETADDR:
1153 for (pa = inf[RPCBVERS_4_STAT].addrinfo; pa;
1156 sprintf(fieldbuf, "%d/", cnt);
1158 case RPCBPROC_CALLIT:
1160 for (pr = inf[RPCBVERS_4_STAT].rmtinfo; pr;
1163 sprintf(fieldbuf, "%d/", cnt);
1165 default: break; /* For the remaining ones */
1167 cp = &fieldbuf[0] + strlen(fieldbuf);
1169 * XXX: We also add RPCBPROC_GETADDRLIST queries to
1170 * RPCB_GETADDR because rpcbind includes the
1171 * RPCB_GETADDRLIST successes in RPCB_GETADDR.
1173 if (i != RPCBPROC_GETADDR)
1174 sprintf(cp, "%d", inf[RPCBVERS_4_STAT].info[i]);
1176 sprintf(cp, "%d", inf[RPCBVERS_4_STAT].info[i] +
1177 inf[RPCBVERS_4_STAT].info[RPCBPROC_GETADDRLIST]);
1178 flen = strlen(fieldbuf);
1179 printf("%s%s", rpcb4hdr[i],
1180 spaces((TABSTOP * (1 + flen / TABSTOP))
1181 - strlen(rpcb4hdr[i])));
1182 sprintf(lp, "%s%s", fieldbuf,
1183 spaces(cnt = ((TABSTOP * (1 + flen / TABSTOP))
1187 printf("\n%s\n", linebuf);
1190 if (inf[RPCBVERS_4_STAT].info[RPCBPROC_CALLIT] ||
1191 inf[RPCBVERS_4_STAT].info[RPCBPROC_INDIRECT]) {
1193 printf("RPCB_RMTCALL (version 4) call statistics\n");
1194 print_rmtcallstat(RPCBVERS_4_STAT, &inf[RPCBVERS_4_STAT]);
1197 if (inf[RPCBVERS_4_STAT].info[RPCBPROC_GETADDR]) {
1199 printf("RPCB_GETADDR (version 4) call statistics\n");
1200 print_getaddrstat(RPCBVERS_4_STAT, &inf[RPCBVERS_4_STAT]);
1202 clnt_destroy(client);
1206 * Delete registeration for this (prog, vers, netid)
1209 deletereg(char *netid, int argc, char **argv)
1211 struct netconfig *nconf = NULL;
1216 nconf = getnetconfigent(netid);
1218 errx(1, "netid %s not supported", netid);
1220 if ((rpcb_unset(getprognum(argv[0]), getvers(argv[1]), nconf)) == 0)
1222 "could not delete registration for prog %s version %s",
1227 * Create and return a handle for the given nconf.
1228 * Exit if cannot create handle.
1231 clnt_addr_create(char *address, struct netconfig *nconf,
1232 u_long prog, u_long vers)
1235 static struct netbuf *nbuf;
1236 static int fd = RPC_ANYFD;
1238 if (fd == RPC_ANYFD) {
1239 if ((fd = __rpc_nconf2fd(nconf)) == -1) {
1240 rpc_createerr.cf_stat = RPC_TLIERROR;
1241 clnt_pcreateerror("rpcinfo");
1244 /* Convert the uaddr to taddr */
1245 nbuf = uaddr2taddr(nconf, address);
1247 errx(1, "no address for client handle");
1249 client = clnt_tli_create(fd, nconf, nbuf, prog, vers, 0, 0);
1250 if (client == (CLIENT *)NULL) {
1251 clnt_pcreateerror("rpcinfo");
1258 * If the version number is given, ping that (prog, vers); else try to find
1259 * the version numbers supported for that prog and ping all the versions.
1260 * Remote rpcbind is not contacted for this service. The requests are
1261 * sent directly to the services themselves.
1264 addrping(char *address, char *netid, int argc, char **argv)
1268 enum clnt_stat rpc_stat;
1269 u_long prognum, versnum, minvers, maxvers;
1270 struct rpc_err rpcerr;
1272 struct netconfig *nconf;
1275 if (argc < 1 || argc > 2 || (netid == NULL))
1277 nconf = getnetconfigent(netid);
1278 if (nconf == (struct netconfig *)NULL)
1279 errx(1, "could not find %s", netid);
1282 prognum = getprognum(argv[0]);
1283 if (argc == 1) { /* Version number not known */
1285 * A call to version 0 should fail with a program/version
1286 * mismatch, and give us the range of versions supported.
1290 versnum = getvers(argv[1]);
1292 client = clnt_addr_create(address, nconf, prognum, versnum);
1293 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
1294 (char *)NULL, (xdrproc_t) xdr_void,
1297 /* Version number was known */
1298 if (pstatus(client, prognum, versnum) < 0)
1300 (void) CLNT_DESTROY(client);
1305 /* Version number not known */
1306 (void) CLNT_CONTROL(client, CLSET_FD_NCLOSE, (char *)NULL);
1307 (void) CLNT_CONTROL(client, CLGET_FD, (char *)&fd);
1308 if (rpc_stat == RPC_PROGVERSMISMATCH) {
1309 clnt_geterr(client, &rpcerr);
1310 minvers = rpcerr.re_vers.low;
1311 maxvers = rpcerr.re_vers.high;
1312 } else if (rpc_stat == RPC_SUCCESS) {
1314 * Oh dear, it DOES support version 0.
1315 * Let's try version MAX_VERS.
1317 (void) CLNT_DESTROY(client);
1318 client = clnt_addr_create(address, nconf, prognum, MAX_VERS);
1319 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
1320 (char *)NULL, (xdrproc_t) xdr_void,
1322 if (rpc_stat == RPC_PROGVERSMISMATCH) {
1323 clnt_geterr(client, &rpcerr);
1324 minvers = rpcerr.re_vers.low;
1325 maxvers = rpcerr.re_vers.high;
1326 } else if (rpc_stat == RPC_SUCCESS) {
1328 * It also supports version MAX_VERS.
1329 * Looks like we have a wise guy.
1330 * OK, we give them information on all
1331 * 4 billion versions they support...
1336 (void) pstatus(client, prognum, MAX_VERS);
1340 (void) pstatus(client, prognum, (u_long)0);
1343 (void) CLNT_DESTROY(client);
1344 for (versnum = minvers; versnum <= maxvers; versnum++) {
1345 client = clnt_addr_create(address, nconf, prognum, versnum);
1346 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
1347 (char *)NULL, (xdrproc_t) xdr_void,
1349 if (pstatus(client, prognum, versnum) < 0)
1351 (void) CLNT_DESTROY(client);
1360 * If the version number is given, ping that (prog, vers); else try to find
1361 * the version numbers supported for that prog and ping all the versions.
1362 * Remote rpcbind is *contacted* for this service. The requests are
1363 * then sent directly to the services themselves.
1366 progping(char *netid, int argc, char **argv)
1370 enum clnt_stat rpc_stat;
1371 u_long prognum, versnum, minvers, maxvers;
1372 struct rpc_err rpcerr;
1374 struct netconfig *nconf;
1376 if (argc < 2 || argc > 3 || (netid == NULL))
1378 prognum = getprognum(argv[1]);
1379 if (argc == 2) { /* Version number not known */
1381 * A call to version 0 should fail with a program/version
1382 * mismatch, and give us the range of versions supported.
1386 versnum = getvers(argv[2]);
1389 nconf = getnetconfigent(netid);
1390 if (nconf == (struct netconfig *)NULL)
1391 errx(1, "could not find %s", netid);
1392 client = clnt_tp_create(argv[0], prognum, versnum, nconf);
1394 client = clnt_create(argv[0], prognum, versnum, "NETPATH");
1396 if (client == (CLIENT *)NULL) {
1397 clnt_pcreateerror("rpcinfo");
1402 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
1403 (char *)NULL, (xdrproc_t) xdr_void,
1406 /* Version number was known */
1407 if (pstatus(client, prognum, versnum) < 0)
1409 (void) CLNT_DESTROY(client);
1414 /* Version number not known */
1415 if (rpc_stat == RPC_PROGVERSMISMATCH) {
1416 clnt_geterr(client, &rpcerr);
1417 minvers = rpcerr.re_vers.low;
1418 maxvers = rpcerr.re_vers.high;
1419 } else if (rpc_stat == RPC_SUCCESS) {
1421 * Oh dear, it DOES support version 0.
1422 * Let's try version MAX_VERS.
1425 (void) CLNT_CONTROL(client, CLSET_VERS, (char *)&versnum);
1426 rpc_stat = CLNT_CALL(client, NULLPROC,
1427 (xdrproc_t) xdr_void, (char *)NULL,
1428 (xdrproc_t) xdr_void, (char *)NULL, to);
1429 if (rpc_stat == RPC_PROGVERSMISMATCH) {
1430 clnt_geterr(client, &rpcerr);
1431 minvers = rpcerr.re_vers.low;
1432 maxvers = rpcerr.re_vers.high;
1433 } else if (rpc_stat == RPC_SUCCESS) {
1435 * It also supports version MAX_VERS.
1436 * Looks like we have a wise guy.
1437 * OK, we give them information on all
1438 * 4 billion versions they support...
1443 (void) pstatus(client, prognum, MAX_VERS);
1447 (void) pstatus(client, prognum, (u_long)0);
1450 for (versnum = minvers; versnum <= maxvers; versnum++) {
1451 (void) CLNT_CONTROL(client, CLSET_VERS, (char *)&versnum);
1452 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void,
1453 (char *)NULL, (xdrproc_t) xdr_void,
1455 if (pstatus(client, prognum, versnum) < 0)
1458 (void) CLNT_DESTROY(client);
1467 fprintf(stderr, "usage: rpcinfo [-m | -s] [host]\n");
1469 fprintf(stderr, " rpcinfo -p [host]\n");
1471 fprintf(stderr, " rpcinfo -T netid host prognum [versnum]\n");
1472 fprintf(stderr, " rpcinfo -l host prognum versnum\n");
1475 " rpcinfo [-n portnum] -u | -t host prognum [versnum]\n");
1478 " rpcinfo -a serv_address -T netid prognum [version]\n");
1479 fprintf(stderr, " rpcinfo -b prognum versnum\n");
1480 fprintf(stderr, " rpcinfo -d [-T netid] prognum versnum\n");
1485 getprognum (char *arg)
1488 register struct rpcent *rpc;
1489 register u_long prognum;
1492 while (*tptr && isdigit(*tptr++));
1493 if (*tptr || isalpha(*(tptr - 1))) {
1494 rpc = getrpcbyname(arg);
1496 errx(1, "%s is unknown service", arg);
1497 prognum = rpc->r_number;
1499 prognum = strtol(arg, &strptr, 10);
1500 if (strptr == arg || *strptr != '\0')
1501 errx(1, "%s is illegal program number", arg);
1510 register u_long vers;
1512 vers = (int) strtol(arg, &strptr, 10);
1513 if (strptr == arg || *strptr != '\0')
1514 errx(1, "%s is illegal version number", arg);
1519 * This routine should take a pointer to an "rpc_err" structure, rather than
1520 * a pointer to a CLIENT structure, but "clnt_perror" takes a pointer to
1521 * a CLIENT structure rather than a pointer to an "rpc_err" structure.
1522 * As such, we have to keep the CLIENT structure around in order to print
1523 * a good error message.
1526 pstatus(register CLIENT *client, u_long prog, u_long vers)
1528 struct rpc_err rpcerr;
1530 clnt_geterr(client, &rpcerr);
1531 if (rpcerr.re_status != RPC_SUCCESS) {
1532 clnt_perror(client, "rpcinfo");
1533 printf("program %lu version %lu is not available\n",
1537 printf("program %lu version %lu ready and waiting\n",
1544 clnt_rpcbind_create(char *host, int rpcbversnum, struct netbuf **targaddr)
1546 static const char *tlist[3] = {
1547 "circuit_n", "circuit_v", "datagram_v"
1550 struct netconfig *nconf;
1551 CLIENT *clnt = NULL;
1554 rpc_createerr.cf_stat = RPC_SUCCESS;
1555 for (i = 0; i < 3; i++) {
1556 if ((handle = __rpc_setconf(tlist[i])) == NULL)
1558 while (clnt == (CLIENT *)NULL) {
1559 if ((nconf = __rpc_getconf(handle)) == NULL) {
1560 if (rpc_createerr.cf_stat == RPC_SUCCESS)
1561 rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
1564 clnt = getclnthandle(host, nconf, rpcbversnum,
1569 __rpc_endconf(handle);
1575 getclnthandle(char *host, struct netconfig *nconf,
1576 u_long rpcbversnum, struct netbuf **targaddr)
1579 struct addrinfo hints, *res;
1580 CLIENT *client = NULL;
1582 /* Get the address of the rpcbind */
1583 memset(&hints, 0, sizeof hints);
1584 if (getaddrinfo(host, "rpcbind", &hints, &res) != 0) {
1585 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
1588 addr.len = addr.maxlen = res->ai_addrlen;
1589 addr.buf = res->ai_addr;
1590 client = clnt_tli_create(RPC_ANYFD, nconf, &addr, RPCBPROG,
1593 if (targaddr != NULL) {
1595 (struct netbuf *)malloc(sizeof (struct netbuf));
1596 if (*targaddr != NULL) {
1597 (*targaddr)->maxlen = addr.maxlen;
1598 (*targaddr)->len = addr.len;
1599 (*targaddr)->buf = (char *)malloc(addr.len);
1600 if ((*targaddr)->buf != NULL) {
1601 memcpy((*targaddr)->buf, addr.buf,
1607 if (rpc_createerr.cf_stat == RPC_TLIERROR) {
1609 * Assume that the other system is dead; this is a
1610 * better error to display to the user.
1612 rpc_createerr.cf_stat = RPC_RPCBFAILURE;
1613 rpc_createerr.cf_error.re_status = RPC_FAILED;
1621 print_rmtcallstat(int rtype, rpcb_stat *infp)
1623 register rpcbs_rmtcalllist_ptr pr;
1626 if (rtype == RPCBVERS_4_STAT)
1628 "prog\t\tvers\tproc\tnetid\tindirect success failure\n");
1630 printf("prog\t\tvers\tproc\tnetid\tsuccess\tfailure\n");
1631 for (pr = infp->rmtinfo; pr; pr = pr->next) {
1632 rpc = getrpcbynumber(pr->prog);
1634 printf("%-16s", rpc->r_name);
1636 printf("%-16d", pr->prog);
1637 printf("%d\t%d\t%s\t",
1638 pr->vers, pr->proc, pr->netid);
1639 if (rtype == RPCBVERS_4_STAT)
1640 printf("%d\t ", pr->indirect);
1641 printf("%d\t%d\n", pr->success, pr->failure);
1646 print_getaddrstat(int rtype, rpcb_stat *infp)
1648 rpcbs_addrlist_ptr al;
1649 register struct rpcent *rpc;
1651 printf("prog\t\tvers\tnetid\t success\tfailure\n");
1652 for (al = infp->addrinfo; al; al = al->next) {
1653 rpc = getrpcbynumber(al->prog);
1655 printf("%-16s", rpc->r_name);
1657 printf("%-16d", al->prog);
1658 printf("%d\t%s\t %-12d\t%d\n",
1659 al->vers, al->netid,
1660 al->success, al->failure);
1667 static char space_array[] = /* 64 spaces */
1670 if (howmany <= 0 || howmany > sizeof (space_array)) {
1673 return (&space_array[sizeof (space_array) - howmany - 1]);