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