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