Annotation of src/usr.bin/rusers/rusers.c, Revision 1.29
1.29 ! deraadt 1: /* $OpenBSD: rusers.c,v 1.28 2007/05/25 21:27:16 krw 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: #ifndef lint
1.29 ! deraadt 50: static const char rcsid[] = "$OpenBSD: rusers.c,v 1.28 2007/05/25 21:27:16 krw Exp $";
1.1 deraadt 51: #endif /* not lint */
52:
53: #include <sys/param.h>
1.14 millert 54: #include <sys/ioctl.h>
1.1 deraadt 55: #include <sys/socket.h>
1.14 millert 56: #include <rpc/rpc.h>
1.16 millert 57: #include <rpc/pmap_prot.h>
58: #include <rpc/pmap_rmt.h>
1.14 millert 59: #include <rpcsvc/rusers.h>
60: #include <rpcsvc/rnusers.h> /* Old protocol version */
1.16 millert 61: #include <arpa/inet.h>
62: #include <net/if.h>
1.14 millert 63: #include <err.h>
1.16 millert 64: #include <errno.h>
65: #include <ifaddrs.h>
1.1 deraadt 66: #include <netdb.h>
67: #include <stdio.h>
1.14 millert 68: #include <stdlib.h>
1.8 millert 69: #include <string.h>
1.14 millert 70: #include <termios.h>
71: #include <unistd.h>
1.1 deraadt 72:
1.11 pjanzen 73: /* Preferred formatting */
1.14 millert 74: #define HOST_WIDTH 17
1.1 deraadt 75: #define LINE_WIDTH 8
1.11 pjanzen 76: #define NAME_WIDTH 8
1.1 deraadt 77:
1.18 millert 78: #define MAX_BROADCAST_SIZE 1400
79:
80: struct host_info {
81: u_int count;
82: u_int idle;
83: char *host;
84: rusers_utmp *users;
85: } *hostinfo;
86:
1.21 millert 87: void print_entry(struct host_info *, int);
1.14 millert 88: void fmt_idle(int, char *, size_t);
89: void onehost(char *);
90: void allhosts(void);
1.18 millert 91: void sorthosts(void);
1.19 millert 92: void expandhosts(void);
1.16 millert 93: void alarmclock(int);
1.18 millert 94: char *estrndup(const char *, size_t);
95: struct host_info *add_host(char *);
96: int hcompare(const void *, const void *);
97: int icompare(const void *, const void *);
98: int ucompare(const void *, const void *);
1.14 millert 99: bool_t rusers_reply(char *, struct sockaddr_in *);
100: bool_t rusers_reply_3(char *, struct sockaddr_in *);
1.16 millert 101: enum clnt_stat get_reply(int, in_port_t, u_long, struct rpc_msg *,
1.26 deraadt 102: struct rmtcallres *, bool_t (*)(char *, struct sockaddr_in *));
103: enum clnt_stat rpc_setup(int *, XDR *, struct rpc_msg *,
104: struct rmtcallargs *, AUTH *, char *);
1.14 millert 105: __dead void usage(void);
106:
1.18 millert 107: int aflag, hflag, iflag, lflag, uflag;
108: u_int nentries, maxentries;
1.14 millert 109: long termwidth;
110: extern char *__progname;
1.1 deraadt 111:
1.14 millert 112: int
113: main(int argc, char **argv)
114: {
115: struct winsize win;
116: char *cp, *ep;
117: int ch;
118:
1.18 millert 119: while ((ch = getopt(argc, argv, "ahilu")) != -1)
1.14 millert 120: switch (ch) {
121: case 'a':
1.18 millert 122: aflag = 1;
123: break;
124: case 'h':
125: hflag = 1;
126: break;
127: case 'i':
128: iflag = 1;
1.14 millert 129: break;
130: case 'l':
1.18 millert 131: lflag = 1;
132: break;
133: case 'u':
134: uflag = 1;
1.14 millert 135: break;
136: default:
137: usage();
138: /*NOTREACHED*/
139: }
140:
1.18 millert 141: if (hflag + iflag + uflag > 1)
142: usage();
143:
1.14 millert 144: if (isatty(STDOUT_FILENO)) {
145: if ((cp = getenv("COLUMNS")) != NULL && *cp != '\0') {
146: termwidth = strtol(cp, &ep, 10);
147: if (*ep != '\0' || termwidth >= INT_MAX ||
148: termwidth < 0)
149: termwidth = 0;
150: }
151: if (termwidth == 0 &&
152: ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 &&
153: win.ws_col > 0)
154: termwidth = win.ws_col;
155: else
156: termwidth = 80;
1.23 deraadt 157: } else
158: termwidth = 80;
1.14 millert 159: setlinebuf(stdout);
1.18 millert 160:
161: if (argc == optind) {
162: if (hflag || iflag || uflag) {
163: puts("Collecting responses...");
164: allhosts();
165: sorthosts();
166: } else
167: allhosts();
168: } else {
1.21 millert 169: aflag = 1;
1.14 millert 170: for (; optind < argc; optind++)
171: (void) onehost(argv[optind]);
1.21 millert 172: if (hflag || iflag || uflag)
173: sorthosts();
1.14 millert 174: }
1.18 millert 175:
1.14 millert 176: exit(0);
177: }
1.11 pjanzen 178:
1.18 millert 179: struct host_info *
180: add_host(char *host)
1.1 deraadt 181: {
1.18 millert 182: int i;
1.1 deraadt 183:
1.18 millert 184: for (i = 0; i < nentries; i++) {
185: /* Existing entry. */
186: if (strcmp(host, hostinfo[i].host) == 0)
187: return(NULL);
1.1 deraadt 188: }
189:
1.18 millert 190: /* New entry, allocate space if needed and store. */
191: if (nentries == maxentries) {
192: maxentries += 128;
193: hostinfo = realloc(hostinfo,
194: sizeof(*hostinfo) * maxentries);
195: if (hostinfo == NULL)
1.14 millert 196: err(1, NULL);
197: }
1.18 millert 198: if ((hostinfo[nentries].host = strdup(host)) == NULL)
199: err(1, NULL);
200: return(&hostinfo[nentries++]);
1.14 millert 201: }
202:
203: void
204: fmt_idle(int idle, char *idle_time, size_t idle_time_len)
205: {
206: int days, hours, minutes, seconds;
207:
208: switch (idle) {
209: case 0:
210: *idle_time = '\0';
211: break;
212: case INT_MAX:
213: strlcpy(idle_time, "??", idle_time_len);
214: break;
215: default:
216: seconds = idle;
217: days = seconds / (60*60*24);
218: seconds %= (60*60*24);
219: hours = seconds / (60*60);
220: seconds %= (60*60);
221: minutes = seconds / 60;
222: seconds %= 60;
223: if (idle >= (24*60*60))
224: snprintf(idle_time, idle_time_len,
1.21 millert 225: "%d day%s, %d:%02d:%02d", days,
226: days > 1 ? "s" : "", hours, minutes, seconds);
1.14 millert 227: else if (idle >= (60*60))
228: snprintf(idle_time, idle_time_len, "%2d:%02d:%02d",
229: hours, minutes, seconds);
230: else if (idle > 60)
231: snprintf(idle_time, idle_time_len, "%2d:%02d",
232: minutes, seconds);
233: else
234: snprintf(idle_time, idle_time_len, " :%02d", idle);
235: break;
236: }
237: }
238:
1.15 millert 239: bool_t
1.1 deraadt 240: rusers_reply(char *replyp, struct sockaddr_in *raddrp)
241: {
1.14 millert 242: utmpidlearr *up = (utmpidlearr *)replyp;
1.18 millert 243: struct host_info *entry;
1.1 deraadt 244: struct hostent *hp;
1.18 millert 245: rusers_utmp *ut;
246: char *host;
1.14 millert 247: int i;
1.1 deraadt 248:
1.18 millert 249: if (!aflag && up->uia_cnt == 0)
1.1 deraadt 250: return(0);
251:
1.15 millert 252: hp = gethostbyaddr((char *)&raddrp->sin_addr,
1.14 millert 253: sizeof(struct in_addr), AF_INET);
1.18 millert 254: if (hp)
1.1 deraadt 255: host = hp->h_name;
1.18 millert 256: else
1.1 deraadt 257: host = inet_ntoa(raddrp->sin_addr);
1.18 millert 258: if ((entry = add_host(host)) == NULL)
259: return(0);
260:
1.21 millert 261: if (up->uia_cnt == 0)
262: ut = NULL;
1.29 ! deraadt 263: else if ((ut = calloc(up->uia_cnt, sizeof(*ut))) == NULL)
1.18 millert 264: err(1, NULL);
265: entry->users = ut;
266: entry->count = up->uia_cnt;
267: entry->idle = UINT_MAX;
268: for (i = 0; i < up->uia_cnt; i++, ut++) {
269: ut->ut_user = estrndup(up->uia_arr[i]->ui_utmp.ut_name,
270: RNUSERS_MAXUSERLEN);
271: ut->ut_line = estrndup(up->uia_arr[i]->ui_utmp.ut_line,
272: RNUSERS_MAXLINELEN);
273: ut->ut_host = estrndup(up->uia_arr[i]->ui_utmp.ut_host,
274: RNUSERS_MAXHOSTLEN);
275: ut->ut_time = up->uia_arr[i]->ui_utmp.ut_time;
276: ut->ut_idle = up->uia_arr[i]->ui_idle;
277: if (ut->ut_idle < entry->idle)
278: entry->idle = ut->ut_idle;
279: }
280:
281: if (!hflag && !iflag && !uflag) {
1.21 millert 282: print_entry(entry, lflag && entry->count);
1.18 millert 283: for (i = 0, ut = entry->users; i < entry->count; i++, ut++) {
284: free(ut->ut_user);
285: free(ut->ut_line);
286: free(ut->ut_host);
1.14 millert 287: }
1.18 millert 288: free(entry->users);
1.14 millert 289: }
290:
291: return(0);
292: }
1.1 deraadt 293:
1.15 millert 294: bool_t
1.14 millert 295: rusers_reply_3(char *replyp, struct sockaddr_in *raddrp)
296: {
297: utmp_array *up3 = (utmp_array *)replyp;
1.18 millert 298: struct host_info *entry;
1.14 millert 299: struct hostent *hp;
1.18 millert 300: rusers_utmp *ut;
301: char *host;
1.14 millert 302: int i;
303:
1.21 millert 304: if (!aflag && up3->utmp_array_len == 0)
1.14 millert 305: return(0);
1.16 millert 306:
1.15 millert 307: hp = gethostbyaddr((char *)&raddrp->sin_addr,
1.14 millert 308: sizeof(struct in_addr), AF_INET);
1.18 millert 309: if (hp)
1.14 millert 310: host = hp->h_name;
1.18 millert 311: else
1.14 millert 312: host = inet_ntoa(raddrp->sin_addr);
1.18 millert 313: if ((entry = add_host(host)) == NULL)
314: return(0);
315:
1.21 millert 316: if (up3->utmp_array_len == 0)
317: ut = NULL;
1.29 ! deraadt 318: else if ((ut = calloc(up3->utmp_array_len, sizeof(*ut))) == NULL)
1.18 millert 319: err(1, NULL);
320: entry->users = ut;
321: entry->count = up3->utmp_array_len;
322: entry->idle = UINT_MAX;
323: for (i = 0; i < up3->utmp_array_len; i++, ut++) {
324: ut->ut_user = estrndup(up3->utmp_array_val[i].ut_user,
325: RUSERS_MAXUSERLEN);
326: ut->ut_line = estrndup(up3->utmp_array_val[i].ut_line,
327: RUSERS_MAXLINELEN);
328: ut->ut_host = estrndup(up3->utmp_array_val[i].ut_host,
329: RUSERS_MAXHOSTLEN);
330: ut->ut_time = up3->utmp_array_val[i].ut_time;
331: ut->ut_idle = up3->utmp_array_val[i].ut_idle;
332: if (ut->ut_idle < entry->idle)
333: entry->idle = ut->ut_idle;
334: }
335:
336: if (!hflag && !iflag && !uflag) {
1.21 millert 337: print_entry(entry, lflag && entry->count);
1.18 millert 338: for (i = 0, ut = entry->users; i < entry->count; i++, ut++) {
339: free(ut->ut_user);
340: free(ut->ut_line);
341: free(ut->ut_host);
1.14 millert 342: }
1.18 millert 343: free(entry->users);
1.1 deraadt 344: }
345:
346: return(0);
347: }
348:
349: void
350: onehost(char *host)
351: {
1.4 deraadt 352: utmpidlearr up;
1.14 millert 353: utmp_array up3;
1.1 deraadt 354: CLIENT *rusers_clnt;
1.16 millert 355: struct sockaddr_in sin;
1.1 deraadt 356: struct hostent *hp;
1.14 millert 357: struct timeval tv = { 25, 0 };
358: int error;
1.1 deraadt 359:
1.20 deraadt 360: memset(&sin, 0, sizeof sin);
361:
1.1 deraadt 362: hp = gethostbyname(host);
1.11 pjanzen 363: if (hp == NULL)
364: errx(1, "unknown host \"%s\"", host);
1.1 deraadt 365:
1.18 millert 366: /* Try version 3 first. */
1.14 millert 367: rusers_clnt = clnt_create(host, RUSERSPROG, RUSERSVERS_3, "udp");
368: if (rusers_clnt == NULL) {
369: clnt_pcreateerror(__progname);
370: exit(1);
371: }
372:
373: memset(&up3, 0, sizeof(up3));
374: error = clnt_call(rusers_clnt, RUSERSPROC_NAMES, xdr_void, NULL,
375: xdr_utmp_array, &up3, tv);
376: switch (error) {
377: case RPC_SUCCESS:
1.16 millert 378: sin.sin_addr.s_addr = *(int *)hp->h_addr;
379: rusers_reply_3((char *)&up3, &sin);
1.14 millert 380: clnt_destroy(rusers_clnt);
381: return;
382: case RPC_PROGVERSMISMATCH:
383: clnt_destroy(rusers_clnt);
384: break;
385: default:
386: clnt_perror(rusers_clnt, __progname);
387: clnt_destroy(rusers_clnt);
388: exit(1);
389: }
390:
1.18 millert 391: /* Fall back to version 2. */
1.1 deraadt 392: rusers_clnt = clnt_create(host, RUSERSPROG, RUSERSVERS_IDLE, "udp");
393: if (rusers_clnt == NULL) {
1.11 pjanzen 394: clnt_pcreateerror(__progname);
1.1 deraadt 395: exit(1);
396: }
397:
1.14 millert 398: memset(&up, 0, sizeof(up));
399: error = clnt_call(rusers_clnt, RUSERSPROC_NAMES, xdr_void, NULL,
400: xdr_utmpidlearr, &up, tv);
401: if (error != RPC_SUCCESS) {
1.11 pjanzen 402: clnt_perror(rusers_clnt, __progname);
1.12 deraadt 403: clnt_destroy(rusers_clnt);
1.1 deraadt 404: exit(1);
405: }
1.16 millert 406: sin.sin_addr.s_addr = *(int *)hp->h_addr;
407: rusers_reply((char *)&up, &sin);
1.12 deraadt 408: clnt_destroy(rusers_clnt);
1.1 deraadt 409: }
410:
1.16 millert 411: enum clnt_stat
412: get_reply(int sock, in_port_t port, u_long xid, struct rpc_msg *msgp,
1.26 deraadt 413: struct rmtcallres *resp, bool_t (*callback)(char *, struct sockaddr_in *))
1.16 millert 414: {
415: ssize_t inlen;
416: socklen_t fromlen;
417: struct sockaddr_in raddr;
418: char inbuf[UDPMSGSIZE];
419: XDR xdr;
420:
421: retry:
422: msgp->acpted_rply.ar_verf = _null_auth;
423: msgp->acpted_rply.ar_results.where = (caddr_t)resp;
424: msgp->acpted_rply.ar_results.proc = xdr_rmtcallres;
425:
426: fromlen = sizeof(struct sockaddr);
427: inlen = recvfrom(sock, inbuf, sizeof(inbuf), 0,
428: (struct sockaddr *)&raddr, &fromlen);
429: if (inlen < 0) {
430: if (errno == EINTR)
431: goto retry;
432: return (RPC_CANTRECV);
433: }
434: if (inlen < sizeof(u_int32_t))
435: goto retry;
436:
437: /*
438: * If the reply we got matches our request, decode the
439: * replay and pass it to the callback function.
440: */
441: xdrmem_create(&xdr, inbuf, (u_int)inlen, XDR_DECODE);
442: if (xdr_replymsg(&xdr, msgp)) {
443: if ((msgp->rm_xid == xid) &&
444: (msgp->rm_reply.rp_stat == MSG_ACCEPTED) &&
445: (msgp->acpted_rply.ar_stat == SUCCESS)) {
446: raddr.sin_port = htons(port);
447: (void)(*callback)(resp->results_ptr, &raddr);
448: }
449: }
450: xdr.x_op = XDR_FREE;
451: msgp->acpted_rply.ar_results.proc = xdr_void;
452: (void)xdr_replymsg(&xdr, msgp);
453: (void)(*resp->xdr_results)(&xdr, resp->results_ptr);
454: xdr_destroy(&xdr);
455:
456: return(RPC_SUCCESS);
457: }
458:
459: enum clnt_stat
460: rpc_setup(int *fdp, XDR *xdr, struct rpc_msg *msg, struct rmtcallargs *args,
1.26 deraadt 461: AUTH *unix_auth, char *buf)
1.16 millert 462: {
463: int on = 1;
464:
465: if ((*fdp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
466: return(RPC_CANTSEND);
467:
468: if (setsockopt(*fdp, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0)
469: return(RPC_CANTSEND);
470:
471: msg->rm_xid = arc4random();
472: msg->rm_direction = CALL;
473: msg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
474: msg->rm_call.cb_prog = PMAPPROG;
475: msg->rm_call.cb_vers = PMAPVERS;
476: msg->rm_call.cb_proc = PMAPPROC_CALLIT;
477: msg->rm_call.cb_cred = unix_auth->ah_cred;
478: msg->rm_call.cb_verf = unix_auth->ah_verf;
479:
480: xdrmem_create(xdr, buf, MAX_BROADCAST_SIZE, XDR_ENCODE);
481: if (!xdr_callmsg(xdr, msg) || !xdr_rmtcall_args(xdr, args))
482: return(RPC_CANTENCODEARGS);
483:
484: return(RPC_SUCCESS);
485: }
486:
1.1 deraadt 487: void
488: allhosts(void)
489: {
1.16 millert 490: enum clnt_stat stat;
491: struct itimerval timeout;
1.27 otto 492: AUTH *unix_auth;
1.16 millert 493: size_t outlen[2];
494: int sock[2] = { -1, -1 };
495: int i, maxfd, rval;
496: u_long xid[2], port[2];
497: fd_set *fds = NULL;
498: struct sockaddr_in *sin, baddr;
499: struct rmtcallargs args;
500: struct rmtcallres res[2];
501: struct rpc_msg msg[2];
502: struct ifaddrs *ifa, *ifap = NULL;
503: char buf[2][MAX_BROADCAST_SIZE];
1.4 deraadt 504: utmpidlearr up;
1.14 millert 505: utmp_array up3;
1.16 millert 506: XDR xdr;
1.27 otto 507:
508: if ((unix_auth = authunix_create_default()) == NULL)
509: err(1, "can't create auth handle");
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;
1.18 millert 600: while (timerisset(&timeout.it_value)) {
1.16 millert 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
1.21 millert 642: print_entry(struct host_info *entry, int longfmt)
1.18 millert 643: {
644: char date[32], idle_time[64];
645: char remote[RUSERS_MAXHOSTLEN + 3];
646: struct rusers_utmp *ut;
647: int i, len;
648:
1.21 millert 649: if (!longfmt)
1.18 millert 650: printf("%-*.*s ", HOST_WIDTH, HOST_WIDTH, entry->host);
651:
652: for (i = 0, ut = entry->users; i < entry->count; i++, ut++) {
1.21 millert 653: if (longfmt) {
1.18 millert 654: strftime(date, sizeof(date), "%h %d %R",
655: localtime((time_t *)&ut->ut_time));
656: date[sizeof(date) - 1] = '\0';
657: fmt_idle(ut->ut_idle, idle_time, sizeof(idle_time));
658: len = termwidth -
659: (MAX(strlen(ut->ut_user), NAME_WIDTH) + 1 +
660: HOST_WIDTH + 1 + LINE_WIDTH + 1 + strlen(date) +
661: 1 + MAX(8, strlen(idle_time)) + 1 + 2);
662: if (len > 0 && ut->ut_host[0] != '\0')
663: snprintf(remote, sizeof(remote), "(%.*s)",
664: MIN(len, RUSERS_MAXHOSTLEN), ut->ut_host);
665: else
666: remote[0] = '\0';
667: len = HOST_WIDTH - MIN(HOST_WIDTH, strlen(entry->host)) +
668: LINE_WIDTH - MIN(LINE_WIDTH, strlen(ut->ut_line));
669: printf("%-*s %.*s:%.*s%-*s %-12s %8s %s\n",
670: NAME_WIDTH, ut->ut_user, HOST_WIDTH, entry->host,
671: LINE_WIDTH, ut->ut_line, len, "", date,
672: idle_time, remote);
673: } else {
674: fputs(ut->ut_user, stdout);
675: putchar(' ');
676: }
677: }
1.21 millert 678: if (!longfmt)
1.18 millert 679: putchar('\n');
680: }
681:
682: void
1.24 deraadt 683: expandhosts(void)
1.19 millert 684: {
685: struct host_info *new_hostinfo, *entry;
686: u_int count;
687: int i, j;
688:
689: for (i = 0, count = 0; i < nentries; i++)
690: count += hostinfo[i].count;
691:
1.29 ! deraadt 692: new_hostinfo = (struct host_info *)calloc(sizeof(*entry), count);
1.19 millert 693: if (new_hostinfo == NULL)
694: err(1, NULL);
695: for (i = 0, entry = new_hostinfo; i < nentries; i++) {
696: for (j = 0; j < hostinfo[i].count; j++) {
697: memcpy(entry, &hostinfo[i], sizeof(*entry));
698: entry->users = &hostinfo[i].users[j];
699: entry->idle = entry->users->ut_idle;
700: entry->count = 1;
701: entry++;
702: }
703: }
704: free(hostinfo);
705: hostinfo = new_hostinfo;
706: nentries = maxentries = count;
707: }
708:
709: void
1.24 deraadt 710: sorthosts(void)
1.18 millert 711: {
712: int i;
713: int (*compar)(const void *, const void *);
1.19 millert 714:
715: if (iflag && lflag)
716: expandhosts();
1.18 millert 717:
718: if (hflag)
719: compar = hcompare;
720: else if (iflag)
721: compar = icompare;
722: else
723: compar = ucompare;
724: qsort(hostinfo, nentries, sizeof(*hostinfo), compar);
725:
726: for (i = 0; i < nentries; i++)
1.21 millert 727: print_entry(&hostinfo[i], lflag && hostinfo[i].count);
1.18 millert 728: }
729:
730: int
731: hcompare(const void *aa, const void *bb)
732: {
733: const struct host_info *a = (struct host_info *)aa;
734: const struct host_info *b = (struct host_info *)bb;
735: int rval;
736:
737: if ((rval = strcasecmp(a->host, b->host)) != 0)
738: return(rval);
739:
740: if (a->idle < b->idle)
741: return(-1);
742: else if (a->idle > b->idle)
743: return(1);
744:
745: if (a->count > b->count)
746: return(-1);
747: else if (a->count < b->count)
748: return(1);
749:
750: return(0);
751: }
752:
753: int
754: icompare(const void *aa, const void *bb)
755: {
756: const struct host_info *a = (struct host_info *)aa;
757: const struct host_info *b = (struct host_info *)bb;
758:
759: if (a->idle < b->idle)
760: return(-1);
761: else if (a->idle > b->idle)
762: return(1);
763:
764: if (a->count > b->count)
765: return(-1);
766: else if (a->count < b->count)
767: return(1);
768:
769: return(strcasecmp(a->host, b->host));
770: }
771:
772: int
773: ucompare(const void *aa, const void *bb)
774: {
775: const struct host_info *a = (struct host_info *)aa;
776: const struct host_info *b = (struct host_info *)bb;
777:
778: if (a->count > b->count)
779: return(-1);
780: else if (a->count < b->count)
781: return(1);
782:
783: if (a->idle < b->idle)
784: return(-1);
785: else if (a->idle > b->idle)
786: return(1);
787:
788: return(strcasecmp(a->host, b->host));
789: }
790:
791: void
1.16 millert 792: alarmclock(int signo)
793: {
794:
1.28 krw 795: ; /* just interrupt */
1.1 deraadt 796: }
797:
1.18 millert 798: char *
799: estrndup(const char *src, size_t len)
800: {
801: char *dst, *end;
802:
803: if ((end = memchr(src, '\0', len)) != NULL)
804: len = end - src;
805:
806: if ((dst = malloc(len + 1)) == NULL)
807: err(1, NULL);
808: memcpy(dst, src, len);
809: dst[len] = '\0';
810:
811: return(dst);
812: }
813:
1.14 millert 814: void
815: usage(void)
1.1 deraadt 816: {
817:
1.18 millert 818: fprintf(stderr, "usage: %s [-al] [-h | -i | -u] [hosts ...]\n",
819: __progname);
1.14 millert 820: exit(1);
1.1 deraadt 821: }
![[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