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