![[BACK]](/icons/back.gif){kind=icon}
Return to rpcinfo.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / rpcinfo|
Return to rpcinfo.c CVS log | Up to [local] / src / usr.bin / rpcinfo |
1.1 deraadt 1: #ifndef lint
2: /*static char sccsid[] = "from: @(#)rpcinfo.c 1.22 87/08/12 SMI";*/
3: /*static char sccsid[] = "from: @(#)rpcinfo.c 2.2 88/08/11 4.0 RPCSRC";*/
4: static char rcsid[] = "$Id: rpcinfo.c,v 1.4 1995/05/21 14:46:39 mycroft Exp $";
5: #endif
6:
7: /*
8: * Copyright (C) 1986, Sun Microsystems, Inc.
9: */
10:
11: /*
12: * rpcinfo: ping a particular rpc program
13: * or dump the portmapper
14: */
15:
16: /*
17: * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
18: * unrestricted use provided that this legend is included on all tape
19: * media and as a part of the software program in whole or part. Users
20: * may copy or modify Sun RPC without charge, but are not authorized
21: * to license or distribute it to anyone else except as part of a product or
22: * program developed by the user.
23: *
24: * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
25: * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
26: * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
27: *
28: * Sun RPC is provided with no support and without any obligation on the
29: * part of Sun Microsystems, Inc. to assist in its use, correction,
30: * modification or enhancement.
31: *
32: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
33: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
34: * OR ANY PART THEREOF.
35: *
36: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
37: * or profits or other special, indirect and consequential damages, even if
38: * Sun has been advised of the possibility of such damages.
39: *
40: * Sun Microsystems, Inc.
41: * 2550 Garcia Avenue
42: * Mountain View, California 94043
43: */
44:
45: #include <rpc/rpc.h>
46: #include <stdio.h>
47: #include <sys/socket.h>
48: #include <netdb.h>
49: #include <rpc/pmap_prot.h>
50: #include <rpc/pmap_clnt.h>
51: #include <signal.h>
52: #include <ctype.h>
53: #include <arpa/inet.h>
54:
55: #define MAXHOSTLEN 256
56:
57: #define MIN_VERS ((u_long) 0)
58: #define MAX_VERS ((u_long) 4294967295UL)
59:
60: static void udpping(/*u_short portflag, int argc, char **argv*/);
61: static void tcpping(/*u_short portflag, int argc, char **argv*/);
62: static int pstatus(/*CLIENT *client, u_long prognum, u_long vers*/);
63: static void pmapdump(/*int argc, char **argv*/);
64: static bool_t reply_proc(/*void *res, struct sockaddr_in *who*/);
65: static void brdcst(/*int argc, char **argv*/);
66: static void deletereg(/* int argc, char **argv */) ;
67: static void usage(/*void*/);
68: static u_long getprognum(/*char *arg*/);
69: static u_long getvers(/*char *arg*/);
70: static void get_inet_address(/*struct sockaddr_in *addr, char *host*/);
71:
72: /*
73: * Functions to be performed.
74: */
75: #define NONE 0 /* no function */
76: #define PMAPDUMP 1 /* dump portmapper registrations */
77: #define TCPPING 2 /* ping TCP service */
78: #define UDPPING 3 /* ping UDP service */
79: #define BRDCST 4 /* ping broadcast UDP service */
80: #define DELETES 5 /* delete registration for the service */
81:
82: int
83: main(argc, argv)
84: int argc;
85: char **argv;
86: {
87: register int c;
88: extern char *optarg;
89: extern int optind;
90: int errflg;
91: int function;
92: u_short portnum;
93:
94: function = NONE;
95: portnum = 0;
96: errflg = 0;
97: while ((c = getopt(argc, argv, "ptubdn:")) != EOF) {
98: switch (c) {
99:
100: case 'p':
101: if (function != NONE)
102: errflg = 1;
103: else
104: function = PMAPDUMP;
105: break;
106:
107: case 't':
108: if (function != NONE)
109: errflg = 1;
110: else
111: function = TCPPING;
112: break;
113:
114: case 'u':
115: if (function != NONE)
116: errflg = 1;
117: else
118: function = UDPPING;
119: break;
120:
121: case 'b':
122: if (function != NONE)
123: errflg = 1;
124: else
125: function = BRDCST;
126: break;
127:
128: case 'n':
129: portnum = (u_short) atoi(optarg); /* hope we don't get bogus # */
130: break;
131:
132: case 'd':
133: if (function != NONE)
134: errflg = 1;
135: else
136: function = DELETES;
137: break;
138:
139: case '?':
140: errflg = 1;
141: }
142: }
143:
144: if (errflg || function == NONE) {
145: usage();
146: return (1);
147: }
148:
149: switch (function) {
150:
151: case PMAPDUMP:
152: if (portnum != 0) {
153: usage();
154: return (1);
155: }
156: pmapdump(argc - optind, argv + optind);
157: break;
158:
159: case UDPPING:
160: udpping(portnum, argc - optind, argv + optind);
161: break;
162:
163: case TCPPING:
164: tcpping(portnum, argc - optind, argv + optind);
165: break;
166:
167: case BRDCST:
168: if (portnum != 0) {
169: usage();
170: return (1);
171: }
172: brdcst(argc - optind, argv + optind);
173: break;
174:
175: case DELETES:
176: deletereg(argc - optind, argv + optind);
177: break;
178: }
179:
180: return (0);
181: }
182:
183: static void
184: udpping(portnum, argc, argv)
185: u_short portnum;
186: int argc;
187: char **argv;
188: {
189: struct timeval to;
190: struct sockaddr_in addr;
191: enum clnt_stat rpc_stat;
192: CLIENT *client;
193: u_long prognum, vers, minvers, maxvers;
194: int sock = RPC_ANYSOCK;
195: struct rpc_err rpcerr;
196: int failure;
197:
198: if (argc < 2 || argc > 3) {
199: usage();
200: exit(1);
201: }
202: prognum = getprognum(argv[1]);
203: get_inet_address(&addr, argv[0]);
204: /* Open the socket here so it will survive calls to clnt_destroy */
205: sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP);
206: if (sock < 0) {
207: perror("rpcinfo: socket");
208: exit(1);
209: }
210: failure = 0;
211: if (argc == 2) {
212: /*
213: * A call to version 0 should fail with a program/version
214: * mismatch, and give us the range of versions supported.
215: */
216: addr.sin_port = htons(portnum);
217: to.tv_sec = 5;
218: to.tv_usec = 0;
219: if ((client = clntudp_create(&addr, prognum, (u_long)0,
220: to, &sock)) == NULL) {
221: clnt_pcreateerror("rpcinfo");
222: printf("program %lu is not available\n",
223: prognum);
224: exit(1);
225: }
226: to.tv_sec = 10;
227: to.tv_usec = 0;
228: rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL,
229: xdr_void, (char *)NULL, to);
230: if (rpc_stat == RPC_PROGVERSMISMATCH) {
231: clnt_geterr(client, &rpcerr);
232: minvers = rpcerr.re_vers.low;
233: maxvers = rpcerr.re_vers.high;
234: } else if (rpc_stat == RPC_SUCCESS) {
235: /*
236: * Oh dear, it DOES support version 0.
237: * Let's try version MAX_VERS.
238: */
239: addr.sin_port = htons(portnum);
240: to.tv_sec = 5;
241: to.tv_usec = 0;
242: if ((client = clntudp_create(&addr, prognum, MAX_VERS,
243: to, &sock)) == NULL) {
244: clnt_pcreateerror("rpcinfo");
245: printf("program %lu version %lu is not available\n",
246: prognum, MAX_VERS);
247: exit(1);
248: }
249: to.tv_sec = 10;
250: to.tv_usec = 0;
251: rpc_stat = clnt_call(client, NULLPROC, xdr_void,
252: (char *)NULL, xdr_void, (char *)NULL, to);
253: if (rpc_stat == RPC_PROGVERSMISMATCH) {
254: clnt_geterr(client, &rpcerr);
255: minvers = rpcerr.re_vers.low;
256: maxvers = rpcerr.re_vers.high;
257: } else if (rpc_stat == RPC_SUCCESS) {
258: /*
259: * It also supports version MAX_VERS.
260: * Looks like we have a wise guy.
261: * OK, we give them information on all
262: * 4 billion versions they support...
263: */
264: minvers = 0;
265: maxvers = MAX_VERS;
266: } else {
267: (void) pstatus(client, prognum, MAX_VERS);
268: exit(1);
269: }
270: } else {
271: (void) pstatus(client, prognum, (u_long)0);
272: exit(1);
273: }
274: clnt_destroy(client);
275: for (vers = minvers; vers <= maxvers; vers++) {
276: addr.sin_port = htons(portnum);
277: to.tv_sec = 5;
278: to.tv_usec = 0;
279: if ((client = clntudp_create(&addr, prognum, vers,
280: to, &sock)) == NULL) {
281: clnt_pcreateerror("rpcinfo");
282: printf("program %lu version %lu is not available\n",
283: prognum, vers);
284: exit(1);
285: }
286: to.tv_sec = 10;
287: to.tv_usec = 0;
288: rpc_stat = clnt_call(client, NULLPROC, xdr_void,
289: (char *)NULL, xdr_void, (char *)NULL, to);
290: if (pstatus(client, prognum, vers) < 0)
291: failure = 1;
292: clnt_destroy(client);
293: }
294: }
295: else {
296: vers = getvers(argv[2]);
297: addr.sin_port = htons(portnum);
298: to.tv_sec = 5;
299: to.tv_usec = 0;
300: if ((client = clntudp_create(&addr, prognum, vers,
301: to, &sock)) == NULL) {
302: clnt_pcreateerror("rpcinfo");
303: printf("program %lu version %lu is not available\n",
304: prognum, vers);
305: exit(1);
306: }
307: to.tv_sec = 10;
308: to.tv_usec = 0;
309: rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
310: xdr_void, (char *)NULL, to);
311: if (pstatus(client, prognum, vers) < 0)
312: failure = 1;
313: }
314: (void) close(sock); /* Close it up again */
315: if (failure)
316: exit(1);
317: }
318:
319: static void
320: tcpping(portnum, argc, argv)
321: u_short portnum;
322: int argc;
323: char **argv;
324: {
325: struct timeval to;
326: struct sockaddr_in addr;
327: enum clnt_stat rpc_stat;
328: CLIENT *client;
329: u_long prognum, vers, minvers, maxvers;
330: int sock = RPC_ANYSOCK;
331: struct rpc_err rpcerr;
332: int failure;
333:
334: if (argc < 2 || argc > 3) {
335: usage();
336: exit(1);
337: }
338: prognum = getprognum(argv[1]);
339: get_inet_address(&addr, argv[0]);
340: failure = 0;
341: if (argc == 2) {
342: /*
343: * A call to version 0 should fail with a program/version
344: * mismatch, and give us the range of versions supported.
345: */
346: addr.sin_port = htons(portnum);
347: if ((client = clnttcp_create(&addr, prognum, MIN_VERS,
348: &sock, 0, 0)) == NULL) {
349: clnt_pcreateerror("rpcinfo");
350: printf("program %lu is not available\n",
351: prognum);
352: exit(1);
353: }
354: to.tv_sec = 10;
355: to.tv_usec = 0;
356: rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL,
357: xdr_void, (char *)NULL, to);
358: if (rpc_stat == RPC_PROGVERSMISMATCH) {
359: clnt_geterr(client, &rpcerr);
360: minvers = rpcerr.re_vers.low;
361: maxvers = rpcerr.re_vers.high;
362: } else if (rpc_stat == RPC_SUCCESS) {
363: /*
364: * Oh dear, it DOES support version 0.
365: * Let's try version MAX_VERS.
366: */
367: addr.sin_port = htons(portnum);
368: if ((client = clnttcp_create(&addr, prognum, MAX_VERS,
369: &sock, 0, 0)) == NULL) {
370: clnt_pcreateerror("rpcinfo");
371: printf("program %lu version %lu is not available\n",
372: prognum, MAX_VERS);
373: exit(1);
374: }
375: to.tv_sec = 10;
376: to.tv_usec = 0;
377: rpc_stat = clnt_call(client, NULLPROC, xdr_void,
378: (char *)NULL, xdr_void, (char *)NULL, to);
379: if (rpc_stat == RPC_PROGVERSMISMATCH) {
380: clnt_geterr(client, &rpcerr);
381: minvers = rpcerr.re_vers.low;
382: maxvers = rpcerr.re_vers.high;
383: } else if (rpc_stat == RPC_SUCCESS) {
384: /*
385: * It also supports version MAX_VERS.
386: * Looks like we have a wise guy.
387: * OK, we give them information on all
388: * 4 billion versions they support...
389: */
390: minvers = 0;
391: maxvers = MAX_VERS;
392: } else {
393: (void) pstatus(client, prognum, MAX_VERS);
394: exit(1);
395: }
396: } else {
397: (void) pstatus(client, prognum, MIN_VERS);
398: exit(1);
399: }
400: clnt_destroy(client);
401: (void) close(sock);
402: sock = RPC_ANYSOCK; /* Re-initialize it for later */
403: for (vers = minvers; vers <= maxvers; vers++) {
404: addr.sin_port = htons(portnum);
405: if ((client = clnttcp_create(&addr, prognum, vers,
406: &sock, 0, 0)) == NULL) {
407: clnt_pcreateerror("rpcinfo");
408: printf("program %lu version %lu is not available\n",
409: prognum, vers);
410: exit(1);
411: }
412: to.tv_usec = 0;
413: to.tv_sec = 10;
414: rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
415: xdr_void, (char *)NULL, to);
416: if (pstatus(client, prognum, vers) < 0)
417: failure = 1;
418: clnt_destroy(client);
419: (void) close(sock);
420: sock = RPC_ANYSOCK;
421: }
422: }
423: else {
424: vers = getvers(argv[2]);
425: addr.sin_port = htons(portnum);
426: if ((client = clnttcp_create(&addr, prognum, vers, &sock,
427: 0, 0)) == NULL) {
428: clnt_pcreateerror("rpcinfo");
429: printf("program %lu version %lu is not available\n",
430: prognum, vers);
431: exit(1);
432: }
433: to.tv_usec = 0;
434: to.tv_sec = 10;
435: rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL,
436: xdr_void, (char *)NULL, to);
437: if (pstatus(client, prognum, vers) < 0)
438: failure = 1;
439: }
440: if (failure)
441: exit(1);
442: }
443:
444: /*
445: * This routine should take a pointer to an "rpc_err" structure, rather than
446: * a pointer to a CLIENT structure, but "clnt_perror" takes a pointer to
447: * a CLIENT structure rather than a pointer to an "rpc_err" structure.
448: * As such, we have to keep the CLIENT structure around in order to print
449: * a good error message.
450: */
451: static int
452: pstatus(client, prognum, vers)
453: register CLIENT *client;
454: u_long prognum;
455: u_long vers;
456: {
457: struct rpc_err rpcerr;
458:
459: clnt_geterr(client, &rpcerr);
460: if (rpcerr.re_status != RPC_SUCCESS) {
461: clnt_perror(client, "rpcinfo");
462: printf("program %lu version %lu is not available\n",
463: prognum, vers);
464: return (-1);
465: } else {
466: printf("program %lu version %lu ready and waiting\n",
467: prognum, vers);
468: return (0);
469: }
470: }
471:
472: static void
473: pmapdump(argc, argv)
474: int argc;
475: char **argv;
476: {
477: struct sockaddr_in server_addr;
478: register struct hostent *hp;
479: struct pmaplist *head = NULL;
480: int socket = RPC_ANYSOCK;
481: struct timeval minutetimeout;
482: register CLIENT *client;
483: struct rpcent *rpc;
484:
485: if (argc > 1) {
486: usage();
487: exit(1);
488: }
489: if (argc == 1)
490: get_inet_address(&server_addr, argv[0]);
491: else {
492: bzero((char *)&server_addr, sizeof server_addr);
493: server_addr.sin_family = AF_INET;
494: if ((hp = gethostbyname("localhost")) != NULL)
495: bcopy(hp->h_addr, (caddr_t)&server_addr.sin_addr,
496: hp->h_length);
497: else
498: (void) inet_aton("0.0.0.0", &server_addr.sin_addr);
499: }
500: minutetimeout.tv_sec = 60;
501: minutetimeout.tv_usec = 0;
502: server_addr.sin_port = htons(PMAPPORT);
503: if ((client = clnttcp_create(&server_addr, PMAPPROG,
504: PMAPVERS, &socket, 50, 500)) == NULL) {
505: clnt_pcreateerror("rpcinfo: can't contact portmapper");
506: exit(1);
507: }
508: if (clnt_call(client, PMAPPROC_DUMP, xdr_void, NULL,
509: xdr_pmaplist, &head, minutetimeout) != RPC_SUCCESS) {
510: fprintf(stderr, "rpcinfo: can't contact portmapper: ");
511: clnt_perror(client, "rpcinfo");
512: exit(1);
513: }
514: if (head == NULL) {
515: printf("No remote programs registered.\n");
516: } else {
517: printf(" program vers proto port\n");
518: for (; head != NULL; head = head->pml_next) {
519: printf("%10ld%5ld",
520: head->pml_map.pm_prog,
521: head->pml_map.pm_vers);
522: if (head->pml_map.pm_prot == IPPROTO_UDP)
523: printf("%6s", "udp");
524: else if (head->pml_map.pm_prot == IPPROTO_TCP)
525: printf("%6s", "tcp");
526: else
527: printf("%6ld", head->pml_map.pm_prot);
528: printf("%7ld", head->pml_map.pm_port);
529: rpc = getrpcbynumber(head->pml_map.pm_prog);
530: if (rpc)
531: printf(" %s\n", rpc->r_name);
532: else
533: printf("\n");
534: }
535: }
536: }
537:
538: /*
539: * reply_proc collects replies from the broadcast.
540: * to get a unique list of responses the output of rpcinfo should
541: * be piped through sort(1) and then uniq(1).
542: */
543:
544: /*ARGSUSED*/
545: static bool_t
546: reply_proc(res, who)
547: void *res; /* Nothing comes back */
548: struct sockaddr_in *who; /* Who sent us the reply */
549: {
550: register struct hostent *hp;
551:
552: hp = gethostbyaddr((char *) &who->sin_addr, sizeof who->sin_addr,
553: AF_INET);
554: printf("%s %s\n", inet_ntoa(who->sin_addr),
555: (hp == NULL) ? "(unknown)" : hp->h_name);
556: return(FALSE);
557: }
558:
559: static void
560: brdcst(argc, argv)
561: int argc;
562: char **argv;
563: {
564: enum clnt_stat rpc_stat;
565: u_long prognum, vers;
566:
567: if (argc != 2) {
568: usage();
569: exit(1);
570: }
571: prognum = getprognum(argv[0]);
572: vers = getvers(argv[1]);
573: rpc_stat = clnt_broadcast(prognum, vers, NULLPROC, xdr_void,
574: (char *)NULL, xdr_void, (char *)NULL, reply_proc);
575: if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) {
576: fprintf(stderr, "rpcinfo: broadcast failed: %s\n",
577: clnt_sperrno(rpc_stat));
578: exit(1);
579: }
580: exit(0);
581: }
582:
583: static void
584: deletereg(argc, argv)
585: int argc;
586: char **argv;
587: { u_long prog_num, version_num ;
588:
589: if (argc != 2) {
590: usage() ;
591: exit(1) ;
592: }
593: if (getuid()) { /* This command allowed only to root */
594: fprintf(stderr, "Sorry. You are not root\n") ;
595: exit(1) ;
596: }
597: prog_num = getprognum(argv[0]);
598: version_num = getvers(argv[1]);
599: if ((pmap_unset(prog_num, version_num)) == 0) {
600: fprintf(stderr, "rpcinfo: Could not delete registration for prog %s version %s\n",
601: argv[0], argv[1]) ;
602: exit(1) ;
603: }
604: }
605:
606: static void
607: usage()
608: {
609: fprintf(stderr, "Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n");
610: fprintf(stderr, " rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n");
611: fprintf(stderr, " rpcinfo -p [ host ]\n");
612: fprintf(stderr, " rpcinfo -b prognum versnum\n");
613: fprintf(stderr, " rpcinfo -d prognum versnum\n") ;
614: }
615:
616: static u_long
617: getprognum(arg)
618: char *arg;
619: {
620: register struct rpcent *rpc;
621: register u_long prognum;
622:
623: if (isalpha(*arg)) {
624: rpc = getrpcbyname(arg);
625: if (rpc == NULL) {
626: fprintf(stderr, "rpcinfo: %s is unknown service\n",
627: arg);
628: exit(1);
629: }
630: prognum = rpc->r_number;
631: } else {
632: prognum = (u_long) atoi(arg);
633: }
634:
635: return (prognum);
636: }
637:
638: static u_long
639: getvers(arg)
640: char *arg;
641: {
642: register u_long vers;
643:
644: vers = (int) atoi(arg);
645: return (vers);
646: }
647:
648: static void
649: get_inet_address(addr, host)
650: struct sockaddr_in *addr;
651: char *host;
652: {
653: register struct hostent *hp;
654:
655: bzero((char *)addr, sizeof *addr);
656: if (inet_aton(host, &addr->sin_addr) == 0) {
657: if ((hp = gethostbyname(host)) == NULL) {
658: fprintf(stderr, "rpcinfo: %s is unknown host\n", host);
659: exit(1);
660: }
661: bcopy(hp->h_addr, (char *)&addr->sin_addr, hp->h_length);
662: }
663: addr->sin_family = AF_INET;
664: }