Annotation of src/usr.bin/rusers/rusers.c, Revision 1.17
1.17 ! millert 1: /* $OpenBSD: rusers.c,v 1.16 2001/11/06 02:22:25 millert Exp $ */
1.3 deraadt 2:
1.14 millert 3: /*
4: * Copyright (c) 2001 Todd C. Miller <Todd.Miller@courtesan.com>
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
19: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
20: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21: * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
27: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28: */
1.1 deraadt 29: /*-
30: * Copyright (c) 1993 John Brezak
31: * All rights reserved.
1.14 millert 32: *
1.1 deraadt 33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. The name of the author may not be used to endorse or promote products
42: * derived from this software without specific prior written permission.
1.14 millert 43: *
1.1 deraadt 44: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR
45: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
46: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
47: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
48: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
49: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
50: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
52: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
53: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
54: * POSSIBILITY OF SUCH DAMAGE.
55: */
56:
57: #ifndef lint
1.17 ! millert 58: static const char rcsid[] = "$OpenBSD: rusers.c,v 1.16 2001/11/06 02:22:25 millert Exp $";
1.1 deraadt 59: #endif /* not lint */
60:
61: #include <sys/param.h>
1.14 millert 62: #include <sys/ioctl.h>
1.1 deraadt 63: #include <sys/socket.h>
1.14 millert 64: #include <rpc/rpc.h>
1.16 millert 65: #include <rpc/pmap_prot.h>
66: #include <rpc/pmap_rmt.h>
1.14 millert 67: #include <rpcsvc/rusers.h>
68: #include <rpcsvc/rnusers.h> /* Old protocol version */
1.16 millert 69: #include <arpa/inet.h>
70: #include <net/if.h>
1.14 millert 71: #include <err.h>
1.16 millert 72: #include <errno.h>
73: #include <ifaddrs.h>
1.1 deraadt 74: #include <netdb.h>
75: #include <stdio.h>
1.14 millert 76: #include <stdlib.h>
1.8 millert 77: #include <string.h>
1.14 millert 78: #include <termios.h>
79: #include <unistd.h>
1.1 deraadt 80:
1.11 pjanzen 81: /* Preferred formatting */
1.14 millert 82: #define HOST_WIDTH 17
1.1 deraadt 83: #define LINE_WIDTH 8
1.11 pjanzen 84: #define NAME_WIDTH 8
1.1 deraadt 85:
1.14 millert 86: int search_host(struct in_addr);
87: void remember_host(char **);
88: void fmt_idle(int, char *, size_t);
89: void print_longline(int, u_int, char *, char *, char *, char *, int);
90: void onehost(char *);
91: void allhosts(void);
1.16 millert 92: void alarmclock(int);
1.14 millert 93: bool_t rusers_reply(char *, struct sockaddr_in *);
94: bool_t rusers_reply_3(char *, struct sockaddr_in *);
1.16 millert 95: enum clnt_stat get_reply(int, in_port_t, u_long, struct rpc_msg *,
96: struct rmtcallres *, bool_t (*)());
1.14 millert 97: __dead void usage(void);
98:
1.1 deraadt 99: int longopt;
100: int allopt;
1.14 millert 101: long termwidth;
102: extern char *__progname;
1.1 deraadt 103:
104: struct host_list {
105: struct host_list *next;
106: struct in_addr addr;
107: } *hosts;
108:
1.16 millert 109: #define MAX_BROADCAST_SIZE 1400
110:
1.14 millert 111: int
112: main(int argc, char **argv)
113: {
114: struct winsize win;
115: char *cp, *ep;
116: int ch;
117:
118: while ((ch = getopt(argc, argv, "al")) != -1)
119: switch (ch) {
120: case 'a':
121: allopt++;
122: break;
123: case 'l':
124: longopt++;
125: break;
126: default:
127: usage();
128: /*NOTREACHED*/
129: }
130:
131: if (isatty(STDOUT_FILENO)) {
132: if ((cp = getenv("COLUMNS")) != NULL && *cp != '\0') {
133: termwidth = strtol(cp, &ep, 10);
134: if (*ep != '\0' || termwidth >= INT_MAX ||
135: termwidth < 0)
136: termwidth = 0;
137: }
138: if (termwidth == 0 &&
139: ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 &&
140: win.ws_col > 0)
141: termwidth = win.ws_col;
142: else
143: termwidth = 80;
144: }
145: setlinebuf(stdout);
146: if (argc == optind)
147: allhosts();
148: else {
149: for (; optind < argc; optind++)
150: (void) onehost(argv[optind]);
151: }
152: exit(0);
153: }
1.11 pjanzen 154:
1.1 deraadt 155: int
156: search_host(struct in_addr addr)
157: {
158: struct host_list *hp;
159:
160: if (!hosts)
161: return(0);
162:
163: for (hp = hosts; hp != NULL; hp = hp->next) {
164: if (hp->addr.s_addr == addr.s_addr)
165: return(1);
166: }
167: return(0);
168: }
169:
170: void
1.14 millert 171: remember_host(char **ap)
1.1 deraadt 172: {
173: struct host_list *hp;
174:
1.14 millert 175: for (; *ap; ap++) {
176: if (!(hp = malloc(sizeof(struct host_list))))
177: err(1, NULL);
178: hp->addr.s_addr = *(in_addr_t *)*ap;
179: hp->next = hosts;
180: hosts = hp;
181: }
182: }
183:
184: void
185: fmt_idle(int idle, char *idle_time, size_t idle_time_len)
186: {
187: int days, hours, minutes, seconds;
188:
189: switch (idle) {
190: case 0:
191: *idle_time = '\0';
192: break;
193: case INT_MAX:
194: strlcpy(idle_time, "??", idle_time_len);
195: break;
196: default:
197: seconds = idle;
198: days = seconds / (60*60*24);
199: seconds %= (60*60*24);
200: hours = seconds / (60*60);
201: seconds %= (60*60);
202: minutes = seconds / 60;
203: seconds %= 60;
204: if (idle >= (24*60*60))
205: snprintf(idle_time, idle_time_len,
206: "%d days, %d:%02d:%02d",
207: days, hours, minutes, seconds);
208: else if (idle >= (60*60))
209: snprintf(idle_time, idle_time_len, "%2d:%02d:%02d",
210: hours, minutes, seconds);
211: else if (idle > 60)
212: snprintf(idle_time, idle_time_len, "%2d:%02d",
213: minutes, seconds);
214: else
215: snprintf(idle_time, idle_time_len, " :%02d", idle);
216: break;
217: }
218: }
219:
220: void
221: print_longline(int ut_time, u_int idle, char *host, char *user, char *line,
222: char *remhost, int remhostmax)
223: {
224: char date[32], idle_time[64];
225: char remote[RUSERS_MAXHOSTLEN + 1];
226: int len;
227:
228: strftime(date, sizeof(date), "%h %d %R", localtime((time_t *)&ut_time));
229: date[sizeof(date) - 1] = '\0';
230: fmt_idle(idle, idle_time, sizeof(idle_time));
231: len = termwidth -
232: (MAX(strlen(user), NAME_WIDTH) + 1 + HOST_WIDTH + 1 + LINE_WIDTH +
233: 1 + strlen(date) + 1 + MAX(8, strlen(idle_time)) + 1 + 2);
234: if (len > 0 && *remhost != '\0')
235: snprintf(remote, sizeof(remote), "(%.*s)",
236: MIN(len, remhostmax), remhost);
237: else
238: remote[0] = '\0';
239: len = HOST_WIDTH - MIN(HOST_WIDTH, strlen(host)) +
240: LINE_WIDTH - MIN(LINE_WIDTH, strlen(line));
241: printf("%-*s %.*s:%.*s%-*s %-12s %8s %s\n",
242: NAME_WIDTH, user, HOST_WIDTH, host, LINE_WIDTH, line,
243: len, "", date, idle_time, remote);
1.1 deraadt 244: }
245:
1.15 millert 246: bool_t
1.1 deraadt 247: rusers_reply(char *replyp, struct sockaddr_in *raddrp)
248: {
1.14 millert 249: char user[RNUSERS_MAXUSERLEN + 1];
1.13 millert 250: char utline[RNUSERS_MAXLINELEN + 1];
1.14 millert 251: utmpidlearr *up = (utmpidlearr *)replyp;
1.1 deraadt 252: struct hostent *hp;
1.14 millert 253: char *host, *taddrs[2];
254: int i;
1.1 deraadt 255:
256: if (search_host(raddrp->sin_addr))
257: return(0);
258:
259: if (!allopt && !up->uia_cnt)
260: return(0);
261:
1.15 millert 262: hp = gethostbyaddr((char *)&raddrp->sin_addr,
1.14 millert 263: sizeof(struct in_addr), AF_INET);
264: if (hp) {
1.1 deraadt 265: host = hp->h_name;
1.14 millert 266: remember_host(hp->h_addr_list);
267: } else {
1.1 deraadt 268: host = inet_ntoa(raddrp->sin_addr);
1.14 millert 269: taddrs[0] = (char *)&raddrp->sin_addr;
270: taddrs[1] = NULL;
271: remember_host(taddrs);
272: }
1.1 deraadt 273:
274: if (!longopt)
275: printf("%-*.*s ", HOST_WIDTH, HOST_WIDTH, host);
276:
1.14 millert 277: for (i = 0; i < up->uia_cnt; i++) {
278: /* NOTE: strncpy() used below for non-terminated strings. */
279: strncpy(user, up->uia_arr[i]->ui_utmp.ut_name,
280: sizeof(user) - 1);
281: user[sizeof(user) - 1] = '\0';
282: if (longopt) {
283: strncpy(utline, up->uia_arr[i]->ui_utmp.ut_line,
284: sizeof(utline) - 1);
285: utline[sizeof(utline) - 1] = '\0';
286: print_longline(up->uia_arr[i]->ui_utmp.ut_time,
287: up->uia_arr[i]->ui_idle, host, user, utline,
288: up->uia_arr[i]->ui_utmp.ut_host, RNUSERS_MAXHOSTLEN);
289: } else {
290: fputs(user, stdout);
291: putchar(' ');
292: }
293: }
294: if (!longopt)
295: putchar('\n');
296:
297: return(0);
298: }
1.1 deraadt 299:
1.15 millert 300: bool_t
1.14 millert 301: rusers_reply_3(char *replyp, struct sockaddr_in *raddrp)
302: {
303: char user[RUSERS_MAXUSERLEN + 1];
304: char utline[RUSERS_MAXLINELEN + 1];
305: utmp_array *up3 = (utmp_array *)replyp;
306: struct hostent *hp;
307: char *host, *taddrs[2];
308: int i;
309:
310: if (search_host(raddrp->sin_addr))
311: return(0);
1.1 deraadt 312:
1.14 millert 313: if (!allopt && !up3->utmp_array_len)
314: return(0);
1.16 millert 315:
1.15 millert 316: hp = gethostbyaddr((char *)&raddrp->sin_addr,
1.14 millert 317: sizeof(struct in_addr), AF_INET);
318: if (hp) {
319: host = hp->h_name;
320: remember_host(hp->h_addr_list);
321: } else {
322: host = inet_ntoa(raddrp->sin_addr);
323: taddrs[0] = (char *)&raddrp->sin_addr;
324: taddrs[1] = NULL;
325: remember_host(taddrs);
326: }
327:
328: if (!longopt)
329: printf("%-*.*s ", HOST_WIDTH, HOST_WIDTH, host);
330:
331: for (i = 0; i < up3->utmp_array_len; i++) {
332: /* NOTE: strncpy() used below for non-terminated strings. */
333: strncpy(user, up3->utmp_array_val[i].ut_user,
334: sizeof(user) - 1);
335: user[sizeof(user) - 1] = '\0';
1.1 deraadt 336: if (longopt) {
1.14 millert 337: strncpy(utline, up3->utmp_array_val[i].ut_line,
1.13 millert 338: sizeof(utline) - 1);
1.11 pjanzen 339: utline[sizeof(utline) - 1] = '\0';
1.14 millert 340: print_longline(up3->utmp_array_val[i].ut_time,
341: up3->utmp_array_val[i].ut_idle, host, user, utline,
342: up3->utmp_array_val[i].ut_host, RUSERS_MAXHOSTLEN);
343: } else {
344: fputs(user, stdout);
345: putchar(' ');
346: }
1.1 deraadt 347: }
348: if (!longopt)
349: putchar('\n');
350:
351: return(0);
352: }
353:
354: void
355: onehost(char *host)
356: {
1.4 deraadt 357: utmpidlearr up;
1.14 millert 358: utmp_array up3;
1.1 deraadt 359: CLIENT *rusers_clnt;
1.16 millert 360: struct sockaddr_in sin;
1.1 deraadt 361: struct hostent *hp;
1.14 millert 362: struct timeval tv = { 25, 0 };
363: int error;
1.1 deraadt 364:
365: hp = gethostbyname(host);
1.11 pjanzen 366: if (hp == NULL)
367: errx(1, "unknown host \"%s\"", host);
1.1 deraadt 368:
1.14 millert 369: /* try version 3 first */
370: rusers_clnt = clnt_create(host, RUSERSPROG, RUSERSVERS_3, "udp");
371: if (rusers_clnt == NULL) {
372: clnt_pcreateerror(__progname);
373: exit(1);
374: }
375:
376: memset(&up3, 0, sizeof(up3));
377: error = clnt_call(rusers_clnt, RUSERSPROC_NAMES, xdr_void, NULL,
378: xdr_utmp_array, &up3, tv);
379: switch (error) {
380: case RPC_SUCCESS:
1.16 millert 381: sin.sin_addr.s_addr = *(int *)hp->h_addr;
382: rusers_reply_3((char *)&up3, &sin);
1.14 millert 383: clnt_destroy(rusers_clnt);
384: return;
385: case RPC_PROGVERSMISMATCH:
386: clnt_destroy(rusers_clnt);
387: break;
388: default:
389: clnt_perror(rusers_clnt, __progname);
390: clnt_destroy(rusers_clnt);
391: exit(1);
392: }
393:
394: /* fall back to version 2 */
1.1 deraadt 395: rusers_clnt = clnt_create(host, RUSERSPROG, RUSERSVERS_IDLE, "udp");
396: if (rusers_clnt == NULL) {
1.11 pjanzen 397: clnt_pcreateerror(__progname);
1.1 deraadt 398: exit(1);
399: }
400:
1.14 millert 401: memset(&up, 0, sizeof(up));
402: error = clnt_call(rusers_clnt, RUSERSPROC_NAMES, xdr_void, NULL,
403: xdr_utmpidlearr, &up, tv);
404: if (error != RPC_SUCCESS) {
1.11 pjanzen 405: clnt_perror(rusers_clnt, __progname);
1.12 deraadt 406: clnt_destroy(rusers_clnt);
1.1 deraadt 407: exit(1);
408: }
1.16 millert 409: sin.sin_addr.s_addr = *(int *)hp->h_addr;
410: rusers_reply((char *)&up, &sin);
1.12 deraadt 411: clnt_destroy(rusers_clnt);
1.1 deraadt 412: }
413:
1.16 millert 414: enum clnt_stat
415: get_reply(int sock, in_port_t port, u_long xid, struct rpc_msg *msgp,
416: struct rmtcallres *resp, bool_t (*callback)())
417: {
418: ssize_t inlen;
419: socklen_t fromlen;
420: struct sockaddr_in raddr;
421: char inbuf[UDPMSGSIZE];
422: XDR xdr;
423:
424: retry:
425: msgp->acpted_rply.ar_verf = _null_auth;
426: msgp->acpted_rply.ar_results.where = (caddr_t)resp;
427: msgp->acpted_rply.ar_results.proc = xdr_rmtcallres;
428:
429: fromlen = sizeof(struct sockaddr);
430: inlen = recvfrom(sock, inbuf, sizeof(inbuf), 0,
431: (struct sockaddr *)&raddr, &fromlen);
432: if (inlen < 0) {
433: if (errno == EINTR)
434: goto retry;
435: return (RPC_CANTRECV);
436: }
437: if (inlen < sizeof(u_int32_t))
438: goto retry;
439:
440: /*
441: * If the reply we got matches our request, decode the
442: * replay and pass it to the callback function.
443: */
444: xdrmem_create(&xdr, inbuf, (u_int)inlen, XDR_DECODE);
445: if (xdr_replymsg(&xdr, msgp)) {
446: if ((msgp->rm_xid == xid) &&
447: (msgp->rm_reply.rp_stat == MSG_ACCEPTED) &&
448: (msgp->acpted_rply.ar_stat == SUCCESS)) {
449: raddr.sin_port = htons(port);
450: (void)(*callback)(resp->results_ptr, &raddr);
451: }
452: }
453: xdr.x_op = XDR_FREE;
454: msgp->acpted_rply.ar_results.proc = xdr_void;
455: (void)xdr_replymsg(&xdr, msgp);
456: (void)(*resp->xdr_results)(&xdr, resp->results_ptr);
457: xdr_destroy(&xdr);
458:
459: return(RPC_SUCCESS);
460: }
461:
462: enum clnt_stat
463: rpc_setup(int *fdp, XDR *xdr, struct rpc_msg *msg, struct rmtcallargs *args,
464: AUTH *unix_auth, char *buf)
465: {
466: int on = 1;
467:
468: if ((*fdp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
469: return(RPC_CANTSEND);
470:
471: if (setsockopt(*fdp, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0)
472: return(RPC_CANTSEND);
473:
474: msg->rm_xid = arc4random();
475: msg->rm_direction = CALL;
476: msg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
477: msg->rm_call.cb_prog = PMAPPROG;
478: msg->rm_call.cb_vers = PMAPVERS;
479: msg->rm_call.cb_proc = PMAPPROC_CALLIT;
480: msg->rm_call.cb_cred = unix_auth->ah_cred;
481: msg->rm_call.cb_verf = unix_auth->ah_verf;
482:
483: xdrmem_create(xdr, buf, MAX_BROADCAST_SIZE, XDR_ENCODE);
484: if (!xdr_callmsg(xdr, msg) || !xdr_rmtcall_args(xdr, args))
485: return(RPC_CANTENCODEARGS);
486:
487: return(RPC_SUCCESS);
488: }
489:
1.1 deraadt 490: void
491: allhosts(void)
492: {
1.16 millert 493: enum clnt_stat stat;
494: struct itimerval timeout;
495: AUTH *unix_auth = authunix_create_default();
496: size_t outlen[2];
497: int sock[2] = { -1, -1 };
498: int i, maxfd, rval;
499: u_long xid[2], port[2];
500: fd_set *fds = NULL;
501: struct sockaddr_in *sin, baddr;
502: struct rmtcallargs args;
503: struct rmtcallres res[2];
504: struct rpc_msg msg[2];
505: struct ifaddrs *ifa, *ifap = NULL;
506: char buf[2][MAX_BROADCAST_SIZE];
1.4 deraadt 507: utmpidlearr up;
1.14 millert 508: utmp_array up3;
1.16 millert 509: XDR xdr;
1.14 millert 510:
1.16 millert 511: if (getifaddrs(&ifap) != 0)
512: err(1, "can't get list of interface addresses");
513:
514: memset(&up, 0, sizeof(up));
1.15 millert 515: memset(&up3, 0, sizeof(up3));
1.16 millert 516: memset(&baddr, 0, sizeof(baddr));
517: memset(&res, 0, sizeof(res));
518: memset(&msg, 0, sizeof(msg));
1.17 ! millert 519: memset(&timeout, 0, sizeof(timeout));
1.16 millert 520:
521: args.prog = RUSERSPROG;
522: args.vers = RUSERSVERS_IDLE;
523: args.proc = RUSERSPROC_NAMES;
524: args.xdr_args = xdr_void;
525: args.args_ptr = NULL;
526:
527: stat = rpc_setup(&sock[0], &xdr, &msg[0], &args, unix_auth, buf[0]);
528: if (stat != RPC_SUCCESS)
529: goto cleanup;
530: xid[0] = msg[0].rm_xid;
531: outlen[0] = xdr_getpos(&xdr);
532: xdr_destroy(&xdr);
533:
534: args.vers = RUSERSVERS_3;
535: stat = rpc_setup(&sock[1], &xdr, &msg[1], &args, unix_auth, buf[1]);
536: if (stat != RPC_SUCCESS)
537: goto cleanup;
538: xid[1] = msg[1].rm_xid;
539: outlen[1] = xdr_getpos(&xdr);
540: xdr_destroy(&xdr);
541:
542: maxfd = MAX(sock[0], sock[1]) + 1;
543: fds = (fd_set *)calloc(howmany(maxfd, NFDBITS), sizeof(fd_mask));
544: if (fds == NULL)
545: err(1, NULL);
546:
547: baddr.sin_len = sizeof(struct sockaddr_in);
548: baddr.sin_family = AF_INET;
549: baddr.sin_port = htons(PMAPPORT);
550: baddr.sin_addr.s_addr = htonl(INADDR_ANY);
551:
552: res[0].port_ptr = &port[0];
553: res[0].xdr_results = xdr_utmpidlearr;
554: res[0].results_ptr = (caddr_t)&up;
555:
556: res[1].port_ptr = &port[1];
557: res[1].xdr_results = xdr_utmp_array;
558: res[1].results_ptr = (caddr_t)&up3;
559:
560: (void)signal(SIGALRM, alarmclock);
561:
562: /*
563: * We do 6 runs through the loop. On even runs we send
564: * a version 3 broadcast. On odd ones we send a version 2
565: * broadcast. This should give version 3 replies enough
566: * of an 'edge' over the old version 2 ones in most cases.
567: * We select() waiting for replies for 5 seconds in between
568: * each broadcast.
569: */
570: for (i = 0; i < 6; i++) {
571: for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
572: if (ifa->ifa_addr->sa_family != AF_INET ||
573: !(ifa->ifa_flags & IFF_BROADCAST) ||
574: !(ifa->ifa_flags & IFF_UP) ||
575: ifa->ifa_broadaddr == NULL ||
576: ifa->ifa_broadaddr->sa_family != AF_INET)
577: continue;
578: sin = (struct sockaddr_in *)ifa->ifa_broadaddr;
579: baddr.sin_addr = sin->sin_addr;
580:
581: /* use protocol 2 or 3 depending on i (odd or even) */
582: if (i & 1) {
583: if (sendto(sock[0], buf[0], outlen[0], 0,
584: (struct sockaddr *)&baddr,
585: sizeof(struct sockaddr)) != outlen[0])
586: err(1, "can't send broadcast packet");
587: } else {
588: if (sendto(sock[1], buf[1], outlen[1], 0,
589: (struct sockaddr *)&baddr,
590: sizeof(struct sockaddr)) != outlen[1])
591: err(1, "can't send broadcast packet");
592: }
593: }
1.14 millert 594:
1.16 millert 595: /*
596: * We stay in the select loop for ~5 seconds
597: */
598: timeout.it_value.tv_sec = 5;
599: timeout.it_value.tv_usec = 0;
600: for (;;) {
601: FD_SET(sock[0], fds);
602: FD_SET(sock[1], fds);
603: setitimer(ITIMER_REAL, &timeout, NULL);
604: rval = select(maxfd, fds, NULL, NULL, NULL);
605: setitimer(ITIMER_REAL, NULL, &timeout);
606: if (rval == -1) {
607: if (errno == EINTR)
608: break;
609: err(1, "select"); /* shouldn't happen */
610: }
611: if (FD_ISSET(sock[1], fds)) {
612: stat = get_reply(sock[1], (in_port_t)port[1],
613: xid[1], &msg[1], &res[1], rusers_reply_3);
614: if (stat != RPC_SUCCESS)
615: goto cleanup;
616: }
617: if (FD_ISSET(sock[0], fds)) {
618: stat = get_reply(sock[0], (in_port_t)port[0],
619: xid[0], &msg[0], &res[0], rusers_reply);
620: if (stat != RPC_SUCCESS)
621: goto cleanup;
622: }
623: }
624: }
625: cleanup:
626: if (ifap != NULL)
627: freeifaddrs(ifap);
628: if (fds != NULL)
629: free(fds);
630: if (sock[0] >= 0)
631: (void)close(sock[0]);
632: if (sock[1] >= 0)
633: (void)close(sock[1]);
634: AUTH_DESTROY(unix_auth);
635: if (stat != RPC_SUCCESS) {
636: clnt_perrno(stat);
637: exit(1);
638: }
639: }
640:
641: void
642: alarmclock(int signo)
643: {
644:
645: ; /* just interupt */
1.1 deraadt 646: }
647:
1.14 millert 648: void
649: usage(void)
1.1 deraadt 650: {
651:
1.14 millert 652: fprintf(stderr, "usage: %s [-la] [hosts ...]\n", __progname);
653: exit(1);
1.1 deraadt 654: }
![[BACK]](/icons/back.gif){kind=icon}
Return to rusers.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / rusers