1 /* $NetBSD: rpcinfo.c,v 1.15 2000/10/04 20:09:05 mjl Exp $ */ 2 3 /* 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. 10 * 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. 14 * 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. 18 * 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. 22 * 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. 26 * 27 * Sun Microsystems, Inc. 28 * 2550 Garcia Avenue 29 * Mountain View, California 94043 30 */ 31 32 /* 33 * Copyright (c) 1986 - 1991 by Sun Microsystems, Inc. 34 */ 35 36 #include <sys/cdefs.h> 37 /* 38 * rpcinfo: ping a particular rpc program 39 * or dump the registered programs on the remote machine. 40 */ 41 42 /* 43 * We are for now defining PORTMAP here. It doesn't even compile 44 * unless it is defined. 45 */ 46 #ifndef PORTMAP 47 #define PORTMAP 48 #endif 49 50 /* 51 * If PORTMAP is defined, rpcinfo will talk to both portmapper and 52 * rpcbind programs; else it talks only to rpcbind. In the latter case 53 * all the portmapper specific options such as -u, -t, -p become void. 54 */ 55 #include <sys/types.h> 56 #include <sys/param.h> 57 #include <sys/socket.h> 58 #include <sys/un.h> 59 #include <rpc/rpc.h> 60 #include <stdio.h> 61 #include <rpc/rpcb_prot.h> 62 #include <rpc/rpcent.h> 63 #include <rpc/nettype.h> 64 #include <rpc/rpc_com.h> 65 #include <stdlib.h> 66 #include <string.h> 67 #include <unistd.h> 68 #include <err.h> 69 #include <ctype.h> 70 71 #ifdef PORTMAP /* Support for version 2 portmapper */ 72 #include <netinet/in.h> 73 #include <netdb.h> 74 #include <arpa/inet.h> 75 #include <rpc/pmap_prot.h> 76 #include <rpc/pmap_clnt.h> 77 #endif 78 79 #define MAXHOSTLEN 256 80 #define MIN_VERS ((u_long) 0) 81 #define MAX_VERS ((u_long) 4294967295UL) 82 #define UNKNOWN "unknown" 83 84 /* 85 * Functions to be performed. 86 */ 87 #define NONE 0 /* no function */ 88 #define PMAPDUMP 1 /* dump portmapper registrations */ 89 #define TCPPING 2 /* ping TCP service */ 90 #define UDPPING 3 /* ping UDP service */ 91 #define BROADCAST 4 /* ping broadcast service */ 92 #define DELETES 5 /* delete registration for the service */ 93 #define ADDRPING 6 /* pings at the given address */ 94 #define PROGPING 7 /* pings a program on a given host */ 95 #define RPCBDUMP 8 /* dump rpcbind registrations */ 96 #define RPCBDUMP_SHORT 9 /* dump rpcbind registrations - short version */ 97 #define RPCBADDRLIST 10 /* dump addr list about one prog */ 98 #define RPCBGETSTAT 11 /* Get statistics */ 99 100 struct netidlist { 101 char *netid; 102 struct netidlist *next; 103 }; 104 105 struct verslist { 106 int vers; 107 struct verslist *next; 108 }; 109 110 struct rpcbdump_short { 111 u_long prog; 112 struct verslist *vlist; 113 struct netidlist *nlist; 114 struct rpcbdump_short *next; 115 char *owner; 116 }; 117 118 119 120 #ifdef PORTMAP 121 static void ip_ping(u_short, const char *, int, char **); 122 static CLIENT *clnt_com_create(struct sockaddr_in *, u_long, u_long, int *, 123 const char *); 124 static void pmapdump(int, char **); 125 static void get_inet_address(struct sockaddr_in *, char *); 126 #endif 127 128 static bool_t reply_proc(void *, struct netbuf *, struct netconfig *); 129 static void brdcst(int, char **); 130 static void addrping(char *, char *, int, char **); 131 static void progping(char *, int, char **); 132 static CLIENT *clnt_addr_create(char *, struct netconfig *, u_long, u_long); 133 static CLIENT *clnt_rpcbind_create(char *, int, struct netbuf **); 134 static CLIENT *getclnthandle(char *, struct netconfig *, u_long, 135 struct netbuf **); 136 static CLIENT *local_rpcb(u_long, u_long); 137 static int pstatus(CLIENT *, u_long, u_long); 138 static void rpcbdump(int, char *, int, char **); 139 static void rpcbgetstat(int, char **); 140 static void rpcbaddrlist(char *, int, char **); 141 static void deletereg(char *, int, char **); 142 static void print_rmtcallstat(int, rpcb_stat *); 143 static void print_getaddrstat(int, rpcb_stat *); 144 static void usage(void); 145 static u_long getprognum(char *); 146 static u_long getvers(char *); 147 static char *spaces(int); 148 static bool_t add_version(struct rpcbdump_short *, u_long); 149 static bool_t add_netid(struct rpcbdump_short *, char *); 150 151 int 152 main(int argc, char **argv) 153 { 154 register int c; 155 int errflg; 156 int function; 157 char *netid = NULL; 158 char *address = NULL; 159 #ifdef PORTMAP 160 char *strptr; 161 u_short portnum = 0; 162 #endif 163 164 function = NONE; 165 errflg = 0; 166 #ifdef PORTMAP 167 while ((c = getopt(argc, argv, "a:bdlmn:pstT:u")) != -1) { 168 #else 169 while ((c = getopt(argc, argv, "a:bdlmn:sT:")) != -1) { 170 #endif 171 switch (c) { 172 #ifdef PORTMAP 173 case 'p': 174 if (function != NONE) 175 errflg = 1; 176 else 177 function = PMAPDUMP; 178 break; 179 180 case 't': 181 if (function != NONE) 182 errflg = 1; 183 else 184 function = TCPPING; 185 break; 186 187 case 'u': 188 if (function != NONE) 189 errflg = 1; 190 else 191 function = UDPPING; 192 break; 193 194 case 'n': 195 portnum = (u_short) strtol(optarg, &strptr, 10); 196 if (strptr == optarg || *strptr != '\0') 197 errx(1, "%s is illegal port number", optarg); 198 break; 199 #endif 200 case 'a': 201 address = optarg; 202 if (function != NONE) 203 errflg = 1; 204 else 205 function = ADDRPING; 206 break; 207 case 'b': 208 if (function != NONE) 209 errflg = 1; 210 else 211 function = BROADCAST; 212 break; 213 214 case 'd': 215 if (function != NONE) 216 errflg = 1; 217 else 218 function = DELETES; 219 break; 220 221 case 'l': 222 if (function != NONE) 223 errflg = 1; 224 else 225 function = RPCBADDRLIST; 226 break; 227 228 case 'm': 229 if (function != NONE) 230 errflg = 1; 231 else 232 function = RPCBGETSTAT; 233 break; 234 235 case 's': 236 if (function != NONE) 237 errflg = 1; 238 else 239 function = RPCBDUMP_SHORT; 240 break; 241 242 case 'T': 243 netid = optarg; 244 break; 245 case '?': 246 errflg = 1; 247 break; 248 } 249 } 250 251 if (errflg || ((function == ADDRPING) && !netid)) 252 usage(); 253 254 if (function == NONE) { 255 if (argc - optind > 1) 256 function = PROGPING; 257 else 258 function = RPCBDUMP; 259 } 260 261 switch (function) { 262 #ifdef PORTMAP 263 case PMAPDUMP: 264 if (portnum != 0) 265 usage(); 266 pmapdump(argc - optind, argv + optind); 267 break; 268 269 case UDPPING: 270 ip_ping(portnum, "udp", argc - optind, argv + optind); 271 break; 272 273 case TCPPING: 274 ip_ping(portnum, "tcp", argc - optind, argv + optind); 275 break; 276 #endif 277 case BROADCAST: 278 brdcst(argc - optind, argv + optind); 279 break; 280 case DELETES: 281 deletereg(netid, argc - optind, argv + optind); 282 break; 283 case ADDRPING: 284 addrping(address, netid, argc - optind, argv + optind); 285 break; 286 case PROGPING: 287 progping(netid, argc - optind, argv + optind); 288 break; 289 case RPCBDUMP: 290 case RPCBDUMP_SHORT: 291 rpcbdump(function, netid, argc - optind, argv + optind); 292 break; 293 case RPCBGETSTAT: 294 rpcbgetstat(argc - optind, argv + optind); 295 break; 296 case RPCBADDRLIST: 297 rpcbaddrlist(netid, argc - optind, argv + optind); 298 break; 299 } 300 return (0); 301 } 302 303 static CLIENT * 304 local_rpcb(u_long prog, u_long vers) 305 { 306 void *localhandle; 307 struct netconfig *nconf; 308 CLIENT *clnt; 309 310 localhandle = setnetconfig(); 311 while ((nconf = getnetconfig(localhandle)) != NULL) { 312 if (nconf->nc_protofmly != NULL && 313 strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) 314 break; 315 } 316 if (nconf == NULL) { 317 warnx("getnetconfig: %s", nc_sperror()); 318 return (NULL); 319 } 320 321 clnt = clnt_tp_create(NULL, prog, vers, nconf); 322 endnetconfig(localhandle); 323 return clnt; 324 } 325 326 #ifdef PORTMAP 327 static CLIENT * 328 clnt_com_create(struct sockaddr_in *addr, u_long prog, u_long vers, 329 int *fdp, const char *trans) 330 { 331 CLIENT *clnt; 332 333 if (strcmp(trans, "tcp") == 0) { 334 clnt = clnttcp_create(addr, prog, vers, fdp, 0, 0); 335 } else { 336 struct timeval to; 337 338 to.tv_sec = 5; 339 to.tv_usec = 0; 340 clnt = clntudp_create(addr, prog, vers, to, fdp); 341 } 342 if (clnt == (CLIENT *)NULL) { 343 clnt_pcreateerror("rpcinfo"); 344 if (vers == MIN_VERS) 345 printf("program %lu is not available\n", prog); 346 else 347 printf("program %lu version %lu is not available\n", 348 prog, vers); 349 exit(1); 350 } 351 return (clnt); 352 } 353 354 /* 355 * If portnum is 0, then go and get the address from portmapper, which happens 356 * transparently through clnt*_create(); If version number is not given, it 357 * tries to find out the version number by making a call to version 0 and if 358 * that fails, it obtains the high order and the low order version number. If 359 * version 0 calls succeeds, it tries for MAXVERS call and repeats the same. 360 */ 361 static void 362 ip_ping(u_short portnum, const char *trans, int argc, char **argv) 363 { 364 CLIENT *client; 365 int fd = RPC_ANYFD; 366 struct timeval to; 367 struct sockaddr_in addr; 368 enum clnt_stat rpc_stat; 369 u_long prognum, vers, minvers, maxvers; 370 struct rpc_err rpcerr; 371 int failure = 0; 372 373 if (argc < 2 || argc > 3) 374 usage(); 375 to.tv_sec = 10; 376 to.tv_usec = 0; 377 prognum = getprognum(argv[1]); 378 get_inet_address(&addr, argv[0]); 379 if (argc == 2) { /* Version number not known */ 380 /* 381 * A call to version 0 should fail with a program/version 382 * mismatch, and give us the range of versions supported. 383 */ 384 vers = MIN_VERS; 385 } else { 386 vers = getvers(argv[2]); 387 } 388 addr.sin_port = htons(portnum); 389 client = clnt_com_create(&addr, prognum, vers, &fd, trans); 390 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 391 (char *)NULL, (xdrproc_t) xdr_void, (char *)NULL, 392 to); 393 if (argc != 2) { 394 /* Version number was known */ 395 if (pstatus(client, prognum, vers) < 0) 396 exit(1); 397 (void) CLNT_DESTROY(client); 398 return; 399 } 400 /* Version number not known */ 401 (void) CLNT_CONTROL(client, CLSET_FD_NCLOSE, (char *)NULL); 402 if (rpc_stat == RPC_PROGVERSMISMATCH) { 403 clnt_geterr(client, &rpcerr); 404 minvers = rpcerr.re_vers.low; 405 maxvers = rpcerr.re_vers.high; 406 } else if (rpc_stat == RPC_SUCCESS) { 407 /* 408 * Oh dear, it DOES support version 0. 409 * Let's try version MAX_VERS. 410 */ 411 (void) CLNT_DESTROY(client); 412 addr.sin_port = htons(portnum); 413 client = clnt_com_create(&addr, prognum, MAX_VERS, &fd, trans); 414 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 415 (char *)NULL, (xdrproc_t) xdr_void, 416 (char *)NULL, to); 417 if (rpc_stat == RPC_PROGVERSMISMATCH) { 418 clnt_geterr(client, &rpcerr); 419 minvers = rpcerr.re_vers.low; 420 maxvers = rpcerr.re_vers.high; 421 } else if (rpc_stat == RPC_SUCCESS) { 422 /* 423 * It also supports version MAX_VERS. 424 * Looks like we have a wise guy. 425 * OK, we give them information on all 426 * 4 billion versions they support... 427 */ 428 minvers = 0; 429 maxvers = MAX_VERS; 430 } else { 431 (void) pstatus(client, prognum, MAX_VERS); 432 exit(1); 433 } 434 } else { 435 (void) pstatus(client, prognum, (u_long)0); 436 exit(1); 437 } 438 (void) CLNT_DESTROY(client); 439 for (vers = minvers; vers <= maxvers; vers++) { 440 addr.sin_port = htons(portnum); 441 client = clnt_com_create(&addr, prognum, vers, &fd, trans); 442 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 443 (char *)NULL, (xdrproc_t) xdr_void, 444 (char *)NULL, to); 445 if (pstatus(client, prognum, vers) < 0) 446 failure = 1; 447 (void) CLNT_DESTROY(client); 448 } 449 if (failure) 450 exit(1); 451 (void) close(fd); 452 return; 453 } 454 455 /* 456 * Dump all the portmapper registerations 457 */ 458 static void 459 pmapdump(int argc, char **argv) 460 { 461 struct sockaddr_in server_addr; 462 struct pmaplist *head = NULL; 463 int socket = RPC_ANYSOCK; 464 struct timeval minutetimeout; 465 register CLIENT *client; 466 struct rpcent *rpc; 467 enum clnt_stat clnt_st; 468 struct rpc_err err; 469 char *host = NULL; 470 471 if (argc > 1) 472 usage(); 473 if (argc == 1) { 474 host = argv[0]; 475 get_inet_address(&server_addr, host); 476 server_addr.sin_port = htons(PMAPPORT); 477 client = clnttcp_create(&server_addr, PMAPPROG, PMAPVERS, 478 &socket, 50, 500); 479 } else 480 client = local_rpcb(PMAPPROG, PMAPVERS); 481 482 if (client == NULL) { 483 if (rpc_createerr.cf_stat == RPC_TLIERROR) { 484 /* 485 * "Misc. TLI error" is not too helpful. Most likely 486 * the connection to the remote server timed out, so 487 * this error is at least less perplexing. 488 */ 489 rpc_createerr.cf_stat = RPC_PMAPFAILURE; 490 rpc_createerr.cf_error.re_status = RPC_FAILED; 491 } 492 clnt_pcreateerror("rpcinfo: can't contact portmapper"); 493 exit(1); 494 } 495 496 minutetimeout.tv_sec = 60; 497 minutetimeout.tv_usec = 0; 498 499 clnt_st = CLNT_CALL(client, PMAPPROC_DUMP, (xdrproc_t) xdr_void, 500 NULL, (xdrproc_t) xdr_pmaplist_ptr, (char *)&head, 501 minutetimeout); 502 if (clnt_st != RPC_SUCCESS) { 503 if ((clnt_st == RPC_PROGVERSMISMATCH) || 504 (clnt_st == RPC_PROGUNAVAIL)) { 505 CLNT_GETERR(client, &err); 506 if (err.re_vers.low > PMAPVERS) { 507 if (host) 508 warnx("%s does not support portmapper." 509 "Try rpcinfo %s instead", host, 510 host); 511 else 512 warnx("local host does not support " 513 "portmapper. Try 'rpcinfo' " 514 "instead"); 515 } 516 exit(1); 517 } 518 clnt_perror(client, "rpcinfo: can't contact portmapper"); 519 exit(1); 520 } 521 if (head == NULL) { 522 printf("No remote programs registered.\n"); 523 } else { 524 printf(" program vers proto port service\n"); 525 for (; head != NULL; head = head->pml_next) { 526 printf("%10ld%5ld", 527 head->pml_map.pm_prog, 528 head->pml_map.pm_vers); 529 if (head->pml_map.pm_prot == IPPROTO_UDP) 530 printf("%6s", "udp"); 531 else if (head->pml_map.pm_prot == IPPROTO_TCP) 532 printf("%6s", "tcp"); 533 else if (head->pml_map.pm_prot == IPPROTO_ST) 534 printf("%6s", "local"); 535 else 536 printf("%6ld", head->pml_map.pm_prot); 537 printf("%7ld", head->pml_map.pm_port); 538 rpc = getrpcbynumber(head->pml_map.pm_prog); 539 if (rpc) 540 printf(" %s\n", rpc->r_name); 541 else 542 printf("\n"); 543 } 544 } 545 } 546 547 static void 548 get_inet_address(struct sockaddr_in *addr, char *host) 549 { 550 struct netconfig *nconf; 551 struct addrinfo hints, *res; 552 int error; 553 554 (void) memset((char *)addr, 0, sizeof (*addr)); 555 addr->sin_addr.s_addr = inet_addr(host); 556 if (addr->sin_addr.s_addr == INADDR_NONE || 557 addr->sin_addr.s_addr == INADDR_ANY) { 558 if ((nconf = __rpc_getconfip("udp")) == NULL && 559 (nconf = __rpc_getconfip("tcp")) == NULL) 560 errx(1, "couldn't find a suitable transport"); 561 else { 562 memset(&hints, 0, sizeof hints); 563 hints.ai_family = AF_INET; 564 if ((error = getaddrinfo(host, "rpcbind", &hints, &res)) 565 != 0) 566 errx(1, "%s: %s", host, gai_strerror(error)); 567 else { 568 memcpy(addr, res->ai_addr, res->ai_addrlen); 569 freeaddrinfo(res); 570 } 571 (void) freenetconfigent(nconf); 572 } 573 } else { 574 addr->sin_family = AF_INET; 575 } 576 } 577 #endif /* PORTMAP */ 578 579 /* 580 * reply_proc collects replies from the broadcast. 581 * to get a unique list of responses the output of rpcinfo should 582 * be piped through sort(1) and then uniq(1). 583 */ 584 585 /*ARGSUSED*/ 586 static bool_t 587 reply_proc(void *res, struct netbuf *who, struct netconfig *nconf) 588 /* void *res; Nothing comes back */ 589 /* struct netbuf *who; Who sent us the reply */ 590 /* struct netconfig *nconf; On which transport the reply came */ 591 { 592 char *uaddr; 593 char hostbuf[NI_MAXHOST]; 594 const char *hostname; 595 struct sockaddr *sa = (struct sockaddr *)who->buf; 596 597 if (getnameinfo(sa, sa->sa_len, hostbuf, NI_MAXHOST, NULL, 0, 0)) { 598 hostname = UNKNOWN; 599 } else { 600 hostname = hostbuf; 601 } 602 uaddr = taddr2uaddr(nconf, who); 603 if (uaddr == NULL) { 604 printf("%s\t%s\n", UNKNOWN, hostname); 605 } else { 606 printf("%s\t%s\n", uaddr, hostname); 607 free((char *)uaddr); 608 } 609 return (FALSE); 610 } 611 612 static void 613 brdcst(int argc, char **argv) 614 { 615 enum clnt_stat rpc_stat; 616 u_long prognum, vers; 617 618 if (argc != 2) 619 usage(); 620 prognum = getprognum(argv[0]); 621 vers = getvers(argv[1]); 622 rpc_stat = rpc_broadcast(prognum, vers, NULLPROC, 623 (xdrproc_t) xdr_void, (char *)NULL, (xdrproc_t) xdr_void, 624 (char *)NULL, (resultproc_t) reply_proc, NULL); 625 if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) 626 errx(1, "broadcast failed: %s", clnt_sperrno(rpc_stat)); 627 exit(0); 628 } 629 630 static bool_t 631 add_version(struct rpcbdump_short *rs, u_long vers) 632 { 633 struct verslist *vl; 634 635 for (vl = rs->vlist; vl; vl = vl->next) 636 if (vl->vers == vers) 637 break; 638 if (vl) 639 return (TRUE); 640 vl = (struct verslist *)malloc(sizeof (struct verslist)); 641 if (vl == NULL) 642 return (FALSE); 643 vl->vers = vers; 644 vl->next = rs->vlist; 645 rs->vlist = vl; 646 return (TRUE); 647 } 648 649 static bool_t 650 add_netid(struct rpcbdump_short *rs, char *netid) 651 { 652 struct netidlist *nl; 653 654 for (nl = rs->nlist; nl; nl = nl->next) 655 if (strcmp(nl->netid, netid) == 0) 656 break; 657 if (nl) 658 return (TRUE); 659 nl = (struct netidlist *)malloc(sizeof (struct netidlist)); 660 if (nl == NULL) 661 return (FALSE); 662 nl->netid = netid; 663 nl->next = rs->nlist; 664 rs->nlist = nl; 665 return (TRUE); 666 } 667 668 static void 669 rpcbdump(int dumptype, char *netid, int argc, char **argv) 670 { 671 rpcblist_ptr head = NULL; 672 struct timeval minutetimeout; 673 register CLIENT *client; 674 struct rpcent *rpc; 675 char *host; 676 struct netidlist *nl; 677 struct verslist *vl; 678 struct rpcbdump_short *rs, *rs_tail; 679 char buf[256]; 680 enum clnt_stat clnt_st; 681 struct rpc_err err; 682 struct rpcbdump_short *rs_head = NULL; 683 684 if (argc > 1) 685 usage(); 686 if (argc == 1) { 687 host = argv[0]; 688 if (netid == NULL) { 689 client = clnt_rpcbind_create(host, RPCBVERS, NULL); 690 } else { 691 struct netconfig *nconf; 692 693 nconf = getnetconfigent(netid); 694 if (nconf == NULL) { 695 nc_perror("rpcinfo: invalid transport"); 696 exit(1); 697 } 698 client = getclnthandle(host, nconf, RPCBVERS, NULL); 699 if (nconf) 700 (void) freenetconfigent(nconf); 701 } 702 } else 703 client = local_rpcb(PMAPPROG, RPCBVERS); 704 705 if (client == (CLIENT *)NULL) { 706 clnt_pcreateerror("rpcinfo: can't contact rpcbind"); 707 exit(1); 708 } 709 710 minutetimeout.tv_sec = 60; 711 minutetimeout.tv_usec = 0; 712 clnt_st = CLNT_CALL(client, RPCBPROC_DUMP, (xdrproc_t) xdr_void, 713 NULL, (xdrproc_t) xdr_rpcblist_ptr, (char *) &head, 714 minutetimeout); 715 if (clnt_st != RPC_SUCCESS) { 716 if ((clnt_st == RPC_PROGVERSMISMATCH) || 717 (clnt_st == RPC_PROGUNAVAIL)) { 718 int vers; 719 720 CLNT_GETERR(client, &err); 721 if (err.re_vers.low == RPCBVERS4) { 722 vers = RPCBVERS4; 723 clnt_control(client, CLSET_VERS, (char *)&vers); 724 clnt_st = CLNT_CALL(client, RPCBPROC_DUMP, 725 (xdrproc_t) xdr_void, NULL, 726 (xdrproc_t) xdr_rpcblist_ptr, (char *) &head, 727 minutetimeout); 728 if (clnt_st != RPC_SUCCESS) 729 goto failed; 730 } else { 731 if (err.re_vers.high == PMAPVERS) { 732 int high, low; 733 struct pmaplist *pmaphead = NULL; 734 rpcblist_ptr list, prev; 735 736 vers = PMAPVERS; 737 clnt_control(client, CLSET_VERS, (char *)&vers); 738 clnt_st = CLNT_CALL(client, PMAPPROC_DUMP, 739 (xdrproc_t) xdr_void, NULL, 740 (xdrproc_t) xdr_pmaplist_ptr, 741 (char *)&pmaphead, minutetimeout); 742 if (clnt_st != RPC_SUCCESS) 743 goto failed; 744 /* 745 * convert to rpcblist_ptr format 746 */ 747 for (head = NULL; pmaphead != NULL; 748 pmaphead = pmaphead->pml_next) { 749 list = (rpcblist *)malloc(sizeof (rpcblist)); 750 if (list == NULL) 751 goto error; 752 if (head == NULL) 753 head = list; 754 else 755 prev->rpcb_next = (rpcblist_ptr) list; 756 757 list->rpcb_next = NULL; 758 list->rpcb_map.r_prog = pmaphead->pml_map.pm_prog; 759 list->rpcb_map.r_vers = pmaphead->pml_map.pm_vers; 760 if (pmaphead->pml_map.pm_prot == IPPROTO_UDP) 761 list->rpcb_map.r_netid = "udp"; 762 else if (pmaphead->pml_map.pm_prot == IPPROTO_TCP) 763 list->rpcb_map.r_netid = "tcp"; 764 else { 765 #define MAXLONG_AS_STRING "2147483648" 766 list->rpcb_map.r_netid = 767 malloc(strlen(MAXLONG_AS_STRING) + 1); 768 if (list->rpcb_map.r_netid == NULL) 769 goto error; 770 sprintf(list->rpcb_map.r_netid, "%6ld", 771 pmaphead->pml_map.pm_prot); 772 } 773 list->rpcb_map.r_owner = UNKNOWN; 774 low = pmaphead->pml_map.pm_port & 0xff; 775 high = (pmaphead->pml_map.pm_port >> 8) & 0xff; 776 list->rpcb_map.r_addr = strdup("0.0.0.0.XXX.XXX"); 777 sprintf(&list->rpcb_map.r_addr[8], "%d.%d", 778 high, low); 779 prev = list; 780 } 781 } 782 } 783 } else { /* any other error */ 784 failed: 785 clnt_perror(client, "rpcinfo: can't contact rpcbind: "); 786 exit(1); 787 } 788 } 789 if (head == NULL) { 790 printf("No remote programs registered.\n"); 791 } else if (dumptype == RPCBDUMP) { 792 printf( 793 " program version netid address service owner\n"); 794 for (; head != NULL; head = head->rpcb_next) { 795 printf("%10u%5u ", 796 head->rpcb_map.r_prog, head->rpcb_map.r_vers); 797 printf("%-9s ", head->rpcb_map.r_netid); 798 printf("%-22s", head->rpcb_map.r_addr); 799 rpc = getrpcbynumber(head->rpcb_map.r_prog); 800 if (rpc) 801 printf(" %-10s", rpc->r_name); 802 else 803 printf(" %-10s", "-"); 804 printf(" %s\n", head->rpcb_map.r_owner); 805 } 806 } else if (dumptype == RPCBDUMP_SHORT) { 807 for (; head != NULL; head = head->rpcb_next) { 808 for (rs = rs_head; rs; rs = rs->next) 809 if (head->rpcb_map.r_prog == rs->prog) 810 break; 811 if (rs == NULL) { 812 rs = (struct rpcbdump_short *) 813 malloc(sizeof (struct rpcbdump_short)); 814 if (rs == NULL) 815 goto error; 816 rs->next = NULL; 817 if (rs_head == NULL) { 818 rs_head = rs; 819 rs_tail = rs; 820 } else { 821 rs_tail->next = rs; 822 rs_tail = rs; 823 } 824 rs->prog = head->rpcb_map.r_prog; 825 rs->owner = head->rpcb_map.r_owner; 826 rs->nlist = NULL; 827 rs->vlist = NULL; 828 } 829 if (add_version(rs, head->rpcb_map.r_vers) == FALSE) 830 goto error; 831 if (add_netid(rs, head->rpcb_map.r_netid) == FALSE) 832 goto error; 833 } 834 printf( 835 " program version(s) netid(s) service owner\n"); 836 for (rs = rs_head; rs; rs = rs->next) { 837 char *p = buf; 838 839 printf("%10ld ", rs->prog); 840 for (vl = rs->vlist; vl; vl = vl->next) { 841 sprintf(p, "%d", vl->vers); 842 p = p + strlen(p); 843 if (vl->next) 844 sprintf(p++, ","); 845 } 846 printf("%-10s", buf); 847 buf[0] = '\0'; 848 for (nl = rs->nlist; nl; nl = nl->next) { 849 strlcat(buf, nl->netid, sizeof(buf)); 850 if (nl->next) 851 strlcat(buf, ",", sizeof(buf)); 852 } 853 printf("%-32s", buf); 854 rpc = getrpcbynumber(rs->prog); 855 if (rpc) 856 printf(" %-11s", rpc->r_name); 857 else 858 printf(" %-11s", "-"); 859 printf(" %s\n", rs->owner); 860 } 861 } 862 clnt_destroy(client); 863 return; 864 error: warnx("no memory"); 865 return; 866 } 867 868 static char nullstring[] = "\000"; 869 870 static void 871 rpcbaddrlist(char *netid, int argc, char **argv) 872 { 873 rpcb_entry_list_ptr head = NULL; 874 struct timeval minutetimeout; 875 register CLIENT *client; 876 struct rpcent *rpc; 877 char *host; 878 RPCB parms; 879 struct netbuf *targaddr; 880 881 if (argc != 3) 882 usage(); 883 host = argv[0]; 884 if (netid == NULL) { 885 client = clnt_rpcbind_create(host, RPCBVERS4, &targaddr); 886 } else { 887 struct netconfig *nconf; 888 889 nconf = getnetconfigent(netid); 890 if (nconf == NULL) { 891 nc_perror("rpcinfo: invalid transport"); 892 exit(1); 893 } 894 client = getclnthandle(host, nconf, RPCBVERS4, &targaddr); 895 if (nconf) 896 (void) freenetconfigent(nconf); 897 } 898 if (client == (CLIENT *)NULL) { 899 clnt_pcreateerror("rpcinfo: can't contact rpcbind"); 900 exit(1); 901 } 902 minutetimeout.tv_sec = 60; 903 minutetimeout.tv_usec = 0; 904 905 parms.r_prog = getprognum(argv[1]); 906 parms.r_vers = getvers(argv[2]); 907 parms.r_netid = client->cl_netid; 908 if (targaddr == NULL) { 909 parms.r_addr = nullstring; /* for XDRing */ 910 } else { 911 /* 912 * We also send the remote system the address we 913 * used to contact it in case it can help it 914 * connect back with us 915 */ 916 struct netconfig *nconf; 917 918 nconf = getnetconfigent(client->cl_netid); 919 if (nconf != NULL) { 920 parms.r_addr = taddr2uaddr(nconf, targaddr); 921 if (parms.r_addr == NULL) 922 parms.r_addr = nullstring; 923 freenetconfigent(nconf); 924 } else { 925 parms.r_addr = nullstring; /* for XDRing */ 926 } 927 free(targaddr->buf); 928 free(targaddr); 929 } 930 parms.r_owner = nullstring; 931 932 if (CLNT_CALL(client, RPCBPROC_GETADDRLIST, (xdrproc_t) xdr_rpcb, 933 (char *) &parms, (xdrproc_t) xdr_rpcb_entry_list_ptr, 934 (char *) &head, minutetimeout) != RPC_SUCCESS) { 935 clnt_perror(client, "rpcinfo: can't contact rpcbind: "); 936 exit(1); 937 } 938 if (head == NULL) { 939 printf("No remote programs registered.\n"); 940 } else { 941 printf( 942 " program vers tp_family/name/class address\t\t service\n"); 943 for (; head != NULL; head = head->rpcb_entry_next) { 944 rpcb_entry *re; 945 char buf[128]; 946 947 re = &head->rpcb_entry_map; 948 printf("%10u%3u ", 949 parms.r_prog, parms.r_vers); 950 sprintf(buf, "%s/%s/%s ", 951 re->r_nc_protofmly, re->r_nc_proto, 952 re->r_nc_semantics == NC_TPI_CLTS ? "clts" : 953 re->r_nc_semantics == NC_TPI_COTS ? "cots" : 954 "cots_ord"); 955 printf("%-24s", buf); 956 printf("%-24s", re->r_maddr); 957 rpc = getrpcbynumber(parms.r_prog); 958 if (rpc) 959 printf(" %-13s", rpc->r_name); 960 else 961 printf(" %-13s", "-"); 962 printf("\n"); 963 } 964 } 965 clnt_destroy(client); 966 return; 967 } 968 969 /* 970 * monitor rpcbind 971 */ 972 static void 973 rpcbgetstat(int argc, char **argv) 974 { 975 rpcb_stat_byvers inf; 976 struct timeval minutetimeout; 977 register CLIENT *client; 978 char *host; 979 int i, j; 980 rpcbs_addrlist *pa; 981 rpcbs_rmtcalllist *pr; 982 int cnt, flen; 983 #define MAXFIELD 64 984 char fieldbuf[MAXFIELD]; 985 #define MAXLINE 256 986 char linebuf[MAXLINE]; 987 char *cp, *lp; 988 const char *pmaphdr[] = { 989 "NULL", "SET", "UNSET", "GETPORT", 990 "DUMP", "CALLIT" 991 }; 992 const char *rpcb3hdr[] = { 993 "NULL", "SET", "UNSET", "GETADDR", "DUMP", "CALLIT", "TIME", 994 "U2T", "T2U" 995 }; 996 const char *rpcb4hdr[] = { 997 "NULL", "SET", "UNSET", "GETADDR", "DUMP", "CALLIT", "TIME", 998 "U2T", "T2U", "VERADDR", "INDRECT", "GETLIST", "GETSTAT" 999 }; 1000 1001 #define TABSTOP 8 1002 1003 if (argc >= 1) { 1004 host = argv[0]; 1005 client = clnt_rpcbind_create(host, RPCBVERS4, NULL); 1006 } else 1007 client = local_rpcb(PMAPPROG, RPCBVERS4); 1008 if (client == (CLIENT *)NULL) { 1009 clnt_pcreateerror("rpcinfo: can't contact rpcbind"); 1010 exit(1); 1011 } 1012 minutetimeout.tv_sec = 60; 1013 minutetimeout.tv_usec = 0; 1014 memset((char *)&inf, 0, sizeof (rpcb_stat_byvers)); 1015 if (CLNT_CALL(client, RPCBPROC_GETSTAT, (xdrproc_t) xdr_void, NULL, 1016 (xdrproc_t) xdr_rpcb_stat_byvers, (char *)&inf, minutetimeout) 1017 != RPC_SUCCESS) { 1018 clnt_perror(client, "rpcinfo: can't contact rpcbind: "); 1019 exit(1); 1020 } 1021 printf("PORTMAP (version 2) statistics\n"); 1022 lp = linebuf; 1023 for (i = 0; i <= rpcb_highproc_2; i++) { 1024 fieldbuf[0] = '\0'; 1025 switch (i) { 1026 case PMAPPROC_SET: 1027 sprintf(fieldbuf, "%d/", inf[RPCBVERS_2_STAT].setinfo); 1028 break; 1029 case PMAPPROC_UNSET: 1030 sprintf(fieldbuf, "%d/", 1031 inf[RPCBVERS_2_STAT].unsetinfo); 1032 break; 1033 case PMAPPROC_GETPORT: 1034 cnt = 0; 1035 for (pa = inf[RPCBVERS_2_STAT].addrinfo; pa; 1036 pa = pa->next) 1037 cnt += pa->success; 1038 sprintf(fieldbuf, "%d/", cnt); 1039 break; 1040 case PMAPPROC_CALLIT: 1041 cnt = 0; 1042 for (pr = inf[RPCBVERS_2_STAT].rmtinfo; pr; 1043 pr = pr->next) 1044 cnt += pr->success; 1045 sprintf(fieldbuf, "%d/", cnt); 1046 break; 1047 default: break; /* For the remaining ones */ 1048 } 1049 cp = &fieldbuf[0] + strlen(fieldbuf); 1050 sprintf(cp, "%d", inf[RPCBVERS_2_STAT].info[i]); 1051 flen = strlen(fieldbuf); 1052 printf("%s%s", pmaphdr[i], 1053 spaces((TABSTOP * (1 + flen / TABSTOP)) 1054 - strlen(pmaphdr[i]))); 1055 sprintf(lp, "%s%s", fieldbuf, 1056 spaces(cnt = ((TABSTOP * (1 + flen / TABSTOP)) 1057 - flen))); 1058 lp += (flen + cnt); 1059 } 1060 printf("\n%s\n\n", linebuf); 1061 1062 if (inf[RPCBVERS_2_STAT].info[PMAPPROC_CALLIT]) { 1063 printf("PMAP_RMTCALL call statistics\n"); 1064 print_rmtcallstat(RPCBVERS_2_STAT, &inf[RPCBVERS_2_STAT]); 1065 printf("\n"); 1066 } 1067 1068 if (inf[RPCBVERS_2_STAT].info[PMAPPROC_GETPORT]) { 1069 printf("PMAP_GETPORT call statistics\n"); 1070 print_getaddrstat(RPCBVERS_2_STAT, &inf[RPCBVERS_2_STAT]); 1071 printf("\n"); 1072 } 1073 1074 printf("RPCBIND (version 3) statistics\n"); 1075 lp = linebuf; 1076 for (i = 0; i <= rpcb_highproc_3; i++) { 1077 fieldbuf[0] = '\0'; 1078 switch (i) { 1079 case RPCBPROC_SET: 1080 sprintf(fieldbuf, "%d/", inf[RPCBVERS_3_STAT].setinfo); 1081 break; 1082 case RPCBPROC_UNSET: 1083 sprintf(fieldbuf, "%d/", 1084 inf[RPCBVERS_3_STAT].unsetinfo); 1085 break; 1086 case RPCBPROC_GETADDR: 1087 cnt = 0; 1088 for (pa = inf[RPCBVERS_3_STAT].addrinfo; pa; 1089 pa = pa->next) 1090 cnt += pa->success; 1091 sprintf(fieldbuf, "%d/", cnt); 1092 break; 1093 case RPCBPROC_CALLIT: 1094 cnt = 0; 1095 for (pr = inf[RPCBVERS_3_STAT].rmtinfo; pr; 1096 pr = pr->next) 1097 cnt += pr->success; 1098 sprintf(fieldbuf, "%d/", cnt); 1099 break; 1100 default: break; /* For the remaining ones */ 1101 } 1102 cp = &fieldbuf[0] + strlen(fieldbuf); 1103 sprintf(cp, "%d", inf[RPCBVERS_3_STAT].info[i]); 1104 flen = strlen(fieldbuf); 1105 printf("%s%s", rpcb3hdr[i], 1106 spaces((TABSTOP * (1 + flen / TABSTOP)) 1107 - strlen(rpcb3hdr[i]))); 1108 sprintf(lp, "%s%s", fieldbuf, 1109 spaces(cnt = ((TABSTOP * (1 + flen / TABSTOP)) 1110 - flen))); 1111 lp += (flen + cnt); 1112 } 1113 printf("\n%s\n\n", linebuf); 1114 1115 if (inf[RPCBVERS_3_STAT].info[RPCBPROC_CALLIT]) { 1116 printf("RPCB_RMTCALL (version 3) call statistics\n"); 1117 print_rmtcallstat(RPCBVERS_3_STAT, &inf[RPCBVERS_3_STAT]); 1118 printf("\n"); 1119 } 1120 1121 if (inf[RPCBVERS_3_STAT].info[RPCBPROC_GETADDR]) { 1122 printf("RPCB_GETADDR (version 3) call statistics\n"); 1123 print_getaddrstat(RPCBVERS_3_STAT, &inf[RPCBVERS_3_STAT]); 1124 printf("\n"); 1125 } 1126 1127 printf("RPCBIND (version 4) statistics\n"); 1128 1129 for (j = 0; j <= 9; j += 9) { /* Just two iterations for printing */ 1130 lp = linebuf; 1131 for (i = j; i <= MAX(8, rpcb_highproc_4 - 9 + j); i++) { 1132 fieldbuf[0] = '\0'; 1133 switch (i) { 1134 case RPCBPROC_SET: 1135 sprintf(fieldbuf, "%d/", 1136 inf[RPCBVERS_4_STAT].setinfo); 1137 break; 1138 case RPCBPROC_UNSET: 1139 sprintf(fieldbuf, "%d/", 1140 inf[RPCBVERS_4_STAT].unsetinfo); 1141 break; 1142 case RPCBPROC_GETADDR: 1143 cnt = 0; 1144 for (pa = inf[RPCBVERS_4_STAT].addrinfo; pa; 1145 pa = pa->next) 1146 cnt += pa->success; 1147 sprintf(fieldbuf, "%d/", cnt); 1148 break; 1149 case RPCBPROC_CALLIT: 1150 cnt = 0; 1151 for (pr = inf[RPCBVERS_4_STAT].rmtinfo; pr; 1152 pr = pr->next) 1153 cnt += pr->success; 1154 sprintf(fieldbuf, "%d/", cnt); 1155 break; 1156 default: break; /* For the remaining ones */ 1157 } 1158 cp = &fieldbuf[0] + strlen(fieldbuf); 1159 /* 1160 * XXX: We also add RPCBPROC_GETADDRLIST queries to 1161 * RPCB_GETADDR because rpcbind includes the 1162 * RPCB_GETADDRLIST successes in RPCB_GETADDR. 1163 */ 1164 if (i != RPCBPROC_GETADDR) 1165 sprintf(cp, "%d", inf[RPCBVERS_4_STAT].info[i]); 1166 else 1167 sprintf(cp, "%d", inf[RPCBVERS_4_STAT].info[i] + 1168 inf[RPCBVERS_4_STAT].info[RPCBPROC_GETADDRLIST]); 1169 flen = strlen(fieldbuf); 1170 printf("%s%s", rpcb4hdr[i], 1171 spaces((TABSTOP * (1 + flen / TABSTOP)) 1172 - strlen(rpcb4hdr[i]))); 1173 sprintf(lp, "%s%s", fieldbuf, 1174 spaces(cnt = ((TABSTOP * (1 + flen / TABSTOP)) 1175 - flen))); 1176 lp += (flen + cnt); 1177 } 1178 printf("\n%s\n", linebuf); 1179 } 1180 1181 if (inf[RPCBVERS_4_STAT].info[RPCBPROC_CALLIT] || 1182 inf[RPCBVERS_4_STAT].info[RPCBPROC_INDIRECT]) { 1183 printf("\n"); 1184 printf("RPCB_RMTCALL (version 4) call statistics\n"); 1185 print_rmtcallstat(RPCBVERS_4_STAT, &inf[RPCBVERS_4_STAT]); 1186 } 1187 1188 if (inf[RPCBVERS_4_STAT].info[RPCBPROC_GETADDR]) { 1189 printf("\n"); 1190 printf("RPCB_GETADDR (version 4) call statistics\n"); 1191 print_getaddrstat(RPCBVERS_4_STAT, &inf[RPCBVERS_4_STAT]); 1192 } 1193 clnt_destroy(client); 1194 } 1195 1196 /* 1197 * Delete registeration for this (prog, vers, netid) 1198 */ 1199 static void 1200 deletereg(char *netid, int argc, char **argv) 1201 { 1202 struct netconfig *nconf = NULL; 1203 1204 if (argc != 2) 1205 usage(); 1206 if (netid) { 1207 nconf = getnetconfigent(netid); 1208 if (nconf == NULL) 1209 errx(1, "netid %s not supported", netid); 1210 } 1211 if ((rpcb_unset(getprognum(argv[0]), getvers(argv[1]), nconf)) == 0) 1212 errx(1, 1213 "could not delete registration for prog %s version %s", 1214 argv[0], argv[1]); 1215 } 1216 1217 /* 1218 * Create and return a handle for the given nconf. 1219 * Exit if cannot create handle. 1220 */ 1221 static CLIENT * 1222 clnt_addr_create(char *address, struct netconfig *nconf, 1223 u_long prog, u_long vers) 1224 { 1225 CLIENT *client; 1226 static struct netbuf *nbuf; 1227 static int fd = RPC_ANYFD; 1228 1229 if (fd == RPC_ANYFD) { 1230 if ((fd = __rpc_nconf2fd(nconf)) == -1) { 1231 rpc_createerr.cf_stat = RPC_TLIERROR; 1232 clnt_pcreateerror("rpcinfo"); 1233 exit(1); 1234 } 1235 /* Convert the uaddr to taddr */ 1236 nbuf = uaddr2taddr(nconf, address); 1237 if (nbuf == NULL) 1238 errx(1, "no address for client handle"); 1239 } 1240 client = clnt_tli_create(fd, nconf, nbuf, prog, vers, 0, 0); 1241 if (client == (CLIENT *)NULL) { 1242 clnt_pcreateerror("rpcinfo"); 1243 exit(1); 1244 } 1245 return (client); 1246 } 1247 1248 /* 1249 * If the version number is given, ping that (prog, vers); else try to find 1250 * the version numbers supported for that prog and ping all the versions. 1251 * Remote rpcbind is not contacted for this service. The requests are 1252 * sent directly to the services themselves. 1253 */ 1254 static void 1255 addrping(char *address, char *netid, int argc, char **argv) 1256 { 1257 CLIENT *client; 1258 struct timeval to; 1259 enum clnt_stat rpc_stat; 1260 u_long prognum, versnum, minvers, maxvers; 1261 struct rpc_err rpcerr; 1262 int failure = 0; 1263 struct netconfig *nconf; 1264 int fd; 1265 1266 if (argc < 1 || argc > 2 || (netid == NULL)) 1267 usage(); 1268 nconf = getnetconfigent(netid); 1269 if (nconf == (struct netconfig *)NULL) 1270 errx(1, "could not find %s", netid); 1271 to.tv_sec = 10; 1272 to.tv_usec = 0; 1273 prognum = getprognum(argv[0]); 1274 if (argc == 1) { /* Version number not known */ 1275 /* 1276 * A call to version 0 should fail with a program/version 1277 * mismatch, and give us the range of versions supported. 1278 */ 1279 versnum = MIN_VERS; 1280 } else { 1281 versnum = getvers(argv[1]); 1282 } 1283 client = clnt_addr_create(address, nconf, prognum, versnum); 1284 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 1285 (char *)NULL, (xdrproc_t) xdr_void, 1286 (char *)NULL, to); 1287 if (argc == 2) { 1288 /* Version number was known */ 1289 if (pstatus(client, prognum, versnum) < 0) 1290 failure = 1; 1291 (void) CLNT_DESTROY(client); 1292 if (failure) 1293 exit(1); 1294 return; 1295 } 1296 /* Version number not known */ 1297 (void) CLNT_CONTROL(client, CLSET_FD_NCLOSE, (char *)NULL); 1298 (void) CLNT_CONTROL(client, CLGET_FD, (char *)&fd); 1299 if (rpc_stat == RPC_PROGVERSMISMATCH) { 1300 clnt_geterr(client, &rpcerr); 1301 minvers = rpcerr.re_vers.low; 1302 maxvers = rpcerr.re_vers.high; 1303 } else if (rpc_stat == RPC_SUCCESS) { 1304 /* 1305 * Oh dear, it DOES support version 0. 1306 * Let's try version MAX_VERS. 1307 */ 1308 (void) CLNT_DESTROY(client); 1309 client = clnt_addr_create(address, nconf, prognum, MAX_VERS); 1310 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 1311 (char *)NULL, (xdrproc_t) xdr_void, 1312 (char *)NULL, to); 1313 if (rpc_stat == RPC_PROGVERSMISMATCH) { 1314 clnt_geterr(client, &rpcerr); 1315 minvers = rpcerr.re_vers.low; 1316 maxvers = rpcerr.re_vers.high; 1317 } else if (rpc_stat == RPC_SUCCESS) { 1318 /* 1319 * It also supports version MAX_VERS. 1320 * Looks like we have a wise guy. 1321 * OK, we give them information on all 1322 * 4 billion versions they support... 1323 */ 1324 minvers = 0; 1325 maxvers = MAX_VERS; 1326 } else { 1327 (void) pstatus(client, prognum, MAX_VERS); 1328 exit(1); 1329 } 1330 } else { 1331 (void) pstatus(client, prognum, (u_long)0); 1332 exit(1); 1333 } 1334 (void) CLNT_DESTROY(client); 1335 for (versnum = minvers; versnum <= maxvers; versnum++) { 1336 client = clnt_addr_create(address, nconf, prognum, versnum); 1337 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 1338 (char *)NULL, (xdrproc_t) xdr_void, 1339 (char *)NULL, to); 1340 if (pstatus(client, prognum, versnum) < 0) 1341 failure = 1; 1342 (void) CLNT_DESTROY(client); 1343 } 1344 (void) close(fd); 1345 if (failure) 1346 exit(1); 1347 return; 1348 } 1349 1350 /* 1351 * If the version number is given, ping that (prog, vers); else try to find 1352 * the version numbers supported for that prog and ping all the versions. 1353 * Remote rpcbind is *contacted* for this service. The requests are 1354 * then sent directly to the services themselves. 1355 */ 1356 static void 1357 progping(char *netid, int argc, char **argv) 1358 { 1359 CLIENT *client; 1360 struct timeval to; 1361 enum clnt_stat rpc_stat; 1362 u_long prognum, versnum, minvers, maxvers; 1363 struct rpc_err rpcerr; 1364 int failure = 0; 1365 struct netconfig *nconf; 1366 1367 if (argc < 2 || argc > 3 || (netid == NULL)) 1368 usage(); 1369 prognum = getprognum(argv[1]); 1370 if (argc == 2) { /* Version number not known */ 1371 /* 1372 * A call to version 0 should fail with a program/version 1373 * mismatch, and give us the range of versions supported. 1374 */ 1375 versnum = MIN_VERS; 1376 } else { 1377 versnum = getvers(argv[2]); 1378 } 1379 if (netid) { 1380 nconf = getnetconfigent(netid); 1381 if (nconf == (struct netconfig *)NULL) 1382 errx(1, "could not find %s", netid); 1383 client = clnt_tp_create(argv[0], prognum, versnum, nconf); 1384 } else { 1385 client = clnt_create(argv[0], prognum, versnum, "NETPATH"); 1386 } 1387 if (client == (CLIENT *)NULL) { 1388 clnt_pcreateerror("rpcinfo"); 1389 exit(1); 1390 } 1391 to.tv_sec = 10; 1392 to.tv_usec = 0; 1393 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 1394 (char *)NULL, (xdrproc_t) xdr_void, 1395 (char *)NULL, to); 1396 if (argc == 3) { 1397 /* Version number was known */ 1398 if (pstatus(client, prognum, versnum) < 0) 1399 failure = 1; 1400 (void) CLNT_DESTROY(client); 1401 if (failure) 1402 exit(1); 1403 return; 1404 } 1405 /* Version number not known */ 1406 if (rpc_stat == RPC_PROGVERSMISMATCH) { 1407 clnt_geterr(client, &rpcerr); 1408 minvers = rpcerr.re_vers.low; 1409 maxvers = rpcerr.re_vers.high; 1410 } else if (rpc_stat == RPC_SUCCESS) { 1411 /* 1412 * Oh dear, it DOES support version 0. 1413 * Let's try version MAX_VERS. 1414 */ 1415 versnum = MAX_VERS; 1416 (void) CLNT_CONTROL(client, CLSET_VERS, (char *)&versnum); 1417 rpc_stat = CLNT_CALL(client, NULLPROC, 1418 (xdrproc_t) xdr_void, (char *)NULL, 1419 (xdrproc_t) xdr_void, (char *)NULL, to); 1420 if (rpc_stat == RPC_PROGVERSMISMATCH) { 1421 clnt_geterr(client, &rpcerr); 1422 minvers = rpcerr.re_vers.low; 1423 maxvers = rpcerr.re_vers.high; 1424 } else if (rpc_stat == RPC_SUCCESS) { 1425 /* 1426 * It also supports version MAX_VERS. 1427 * Looks like we have a wise guy. 1428 * OK, we give them information on all 1429 * 4 billion versions they support... 1430 */ 1431 minvers = 0; 1432 maxvers = MAX_VERS; 1433 } else { 1434 (void) pstatus(client, prognum, MAX_VERS); 1435 exit(1); 1436 } 1437 } else { 1438 (void) pstatus(client, prognum, (u_long)0); 1439 exit(1); 1440 } 1441 for (versnum = minvers; versnum <= maxvers; versnum++) { 1442 (void) CLNT_CONTROL(client, CLSET_VERS, (char *)&versnum); 1443 rpc_stat = CLNT_CALL(client, NULLPROC, (xdrproc_t) xdr_void, 1444 (char *)NULL, (xdrproc_t) xdr_void, 1445 (char *)NULL, to); 1446 if (pstatus(client, prognum, versnum) < 0) 1447 failure = 1; 1448 } 1449 (void) CLNT_DESTROY(client); 1450 if (failure) 1451 exit(1); 1452 return; 1453 } 1454 1455 static void 1456 usage(void) 1457 { 1458 fprintf(stderr, "usage: rpcinfo [-m | -s] [host]\n"); 1459 #ifdef PORTMAP 1460 fprintf(stderr, " rpcinfo -p [host]\n"); 1461 #endif 1462 fprintf(stderr, " rpcinfo -T netid host prognum [versnum]\n"); 1463 fprintf(stderr, " rpcinfo -l host prognum versnum\n"); 1464 #ifdef PORTMAP 1465 fprintf(stderr, 1466 " rpcinfo [-n portnum] -u | -t host prognum [versnum]\n"); 1467 #endif 1468 fprintf(stderr, 1469 " rpcinfo -a serv_address -T netid prognum [version]\n"); 1470 fprintf(stderr, " rpcinfo -b prognum versnum\n"); 1471 fprintf(stderr, " rpcinfo -d [-T netid] prognum versnum\n"); 1472 exit(1); 1473 } 1474 1475 static u_long 1476 getprognum (char *arg) 1477 { 1478 char *strptr; 1479 register struct rpcent *rpc; 1480 register u_long prognum; 1481 char *tptr = arg; 1482 1483 while (*tptr && isdigit(*tptr++)); 1484 if (*tptr || isalpha(*(tptr - 1))) { 1485 rpc = getrpcbyname(arg); 1486 if (rpc == NULL) 1487 errx(1, "%s is unknown service", arg); 1488 prognum = rpc->r_number; 1489 } else { 1490 prognum = strtol(arg, &strptr, 10); 1491 if (strptr == arg || *strptr != '\0') 1492 errx(1, "%s is illegal program number", arg); 1493 } 1494 return (prognum); 1495 } 1496 1497 static u_long 1498 getvers(char *arg) 1499 { 1500 char *strptr; 1501 register u_long vers; 1502 1503 vers = (int) strtol(arg, &strptr, 10); 1504 if (strptr == arg || *strptr != '\0') 1505 errx(1, "%s is illegal version number", arg); 1506 return (vers); 1507 } 1508 1509 /* 1510 * This routine should take a pointer to an "rpc_err" structure, rather than 1511 * a pointer to a CLIENT structure, but "clnt_perror" takes a pointer to 1512 * a CLIENT structure rather than a pointer to an "rpc_err" structure. 1513 * As such, we have to keep the CLIENT structure around in order to print 1514 * a good error message. 1515 */ 1516 static int 1517 pstatus(register CLIENT *client, u_long prog, u_long vers) 1518 { 1519 struct rpc_err rpcerr; 1520 1521 clnt_geterr(client, &rpcerr); 1522 if (rpcerr.re_status != RPC_SUCCESS) { 1523 clnt_perror(client, "rpcinfo"); 1524 printf("program %lu version %lu is not available\n", 1525 prog, vers); 1526 return (-1); 1527 } else { 1528 printf("program %lu version %lu ready and waiting\n", 1529 prog, vers); 1530 return (0); 1531 } 1532 } 1533 1534 static CLIENT * 1535 clnt_rpcbind_create(char *host, int rpcbversnum, struct netbuf **targaddr) 1536 { 1537 static const char *tlist[3] = { 1538 "circuit_n", "circuit_v", "datagram_v" 1539 }; 1540 int i; 1541 struct netconfig *nconf; 1542 CLIENT *clnt = NULL; 1543 void *handle; 1544 1545 rpc_createerr.cf_stat = RPC_SUCCESS; 1546 for (i = 0; i < 3; i++) { 1547 if ((handle = __rpc_setconf(tlist[i])) == NULL) 1548 continue; 1549 while (clnt == (CLIENT *)NULL) { 1550 if ((nconf = __rpc_getconf(handle)) == NULL) { 1551 if (rpc_createerr.cf_stat == RPC_SUCCESS) 1552 rpc_createerr.cf_stat = RPC_UNKNOWNPROTO; 1553 break; 1554 } 1555 clnt = getclnthandle(host, nconf, rpcbversnum, 1556 targaddr); 1557 } 1558 if (clnt) 1559 break; 1560 __rpc_endconf(handle); 1561 } 1562 return (clnt); 1563 } 1564 1565 static CLIENT* 1566 getclnthandle(char *host, struct netconfig *nconf, 1567 u_long rpcbversnum, struct netbuf **targaddr) 1568 { 1569 struct netbuf addr; 1570 struct addrinfo hints, *res; 1571 CLIENT *client = NULL; 1572 1573 /* Get the address of the rpcbind */ 1574 memset(&hints, 0, sizeof hints); 1575 if (getaddrinfo(host, "rpcbind", &hints, &res) != 0) { 1576 rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE; 1577 return (NULL); 1578 } 1579 addr.len = addr.maxlen = res->ai_addrlen; 1580 addr.buf = res->ai_addr; 1581 client = clnt_tli_create(RPC_ANYFD, nconf, &addr, RPCBPROG, 1582 rpcbversnum, 0, 0); 1583 if (client) { 1584 if (targaddr != NULL) { 1585 *targaddr = 1586 (struct netbuf *)malloc(sizeof (struct netbuf)); 1587 if (*targaddr != NULL) { 1588 (*targaddr)->maxlen = addr.maxlen; 1589 (*targaddr)->len = addr.len; 1590 (*targaddr)->buf = (char *)malloc(addr.len); 1591 if ((*targaddr)->buf != NULL) { 1592 memcpy((*targaddr)->buf, addr.buf, 1593 addr.len); 1594 } 1595 } 1596 } 1597 } else { 1598 if (rpc_createerr.cf_stat == RPC_TLIERROR) { 1599 /* 1600 * Assume that the other system is dead; this is a 1601 * better error to display to the user. 1602 */ 1603 rpc_createerr.cf_stat = RPC_RPCBFAILURE; 1604 rpc_createerr.cf_error.re_status = RPC_FAILED; 1605 } 1606 } 1607 freeaddrinfo(res); 1608 return (client); 1609 } 1610 1611 static void 1612 print_rmtcallstat(int rtype, rpcb_stat *infp) 1613 { 1614 register rpcbs_rmtcalllist_ptr pr; 1615 struct rpcent *rpc; 1616 1617 if (rtype == RPCBVERS_4_STAT) 1618 printf( 1619 "prog\t\tvers\tproc\tnetid\tindirect success failure\n"); 1620 else 1621 printf("prog\t\tvers\tproc\tnetid\tsuccess\tfailure\n"); 1622 for (pr = infp->rmtinfo; pr; pr = pr->next) { 1623 rpc = getrpcbynumber(pr->prog); 1624 if (rpc) 1625 printf("%-16s", rpc->r_name); 1626 else 1627 printf("%-16d", pr->prog); 1628 printf("%d\t%d\t%s\t", 1629 pr->vers, pr->proc, pr->netid); 1630 if (rtype == RPCBVERS_4_STAT) 1631 printf("%d\t ", pr->indirect); 1632 printf("%d\t%d\n", pr->success, pr->failure); 1633 } 1634 } 1635 1636 static void 1637 print_getaddrstat(int rtype, rpcb_stat *infp) 1638 { 1639 rpcbs_addrlist_ptr al; 1640 register struct rpcent *rpc; 1641 1642 printf("prog\t\tvers\tnetid\t success\tfailure\n"); 1643 for (al = infp->addrinfo; al; al = al->next) { 1644 rpc = getrpcbynumber(al->prog); 1645 if (rpc) 1646 printf("%-16s", rpc->r_name); 1647 else 1648 printf("%-16d", al->prog); 1649 printf("%d\t%s\t %-12d\t%d\n", 1650 al->vers, al->netid, 1651 al->success, al->failure); 1652 } 1653 } 1654 1655 static char * 1656 spaces(int howmany) 1657 { 1658 static char space_array[] = /* 64 spaces */ 1659 " "; 1660 1661 if (howmany <= 0 || howmany > sizeof (space_array)) { 1662 return (""); 1663 } 1664 return (&space_array[sizeof (space_array) - howmany - 1]); 1665 } 1666