Home | History | Annotate | Line # | Download | only in w
w.c revision 1.79
      1 /*	$NetBSD: w.c,v 1.79 2014/02/27 00:49:46 joerg Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1980, 1991, 1993, 1994
      5  *	The Regents of the University of California.  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. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 #ifndef lint
     34 __COPYRIGHT("@(#) Copyright (c) 1980, 1991, 1993, 1994\
     35  The Regents of the University of California.  All rights reserved.");
     36 #endif /* not lint */
     37 
     38 #ifndef lint
     39 #if 0
     40 static char sccsid[] = "@(#)w.c	8.6 (Berkeley) 6/30/94";
     41 #else
     42 __RCSID("$NetBSD: w.c,v 1.79 2014/02/27 00:49:46 joerg Exp $");
     43 #endif
     44 #endif /* not lint */
     45 
     46 /*
     47  * w - print system status (who and what)
     48  *
     49  * This program is similar to the systat command on Tenex/Tops 10/20
     50  *
     51  */
     52 #include <sys/param.h>
     53 #include <sys/types.h>
     54 #include <sys/time.h>
     55 #include <sys/stat.h>
     56 #include <sys/sysctl.h>
     57 #include <sys/proc.h>
     58 #include <sys/ioctl.h>
     59 #include <sys/socket.h>
     60 
     61 #include <netinet/in.h>
     62 #include <arpa/inet.h>
     63 
     64 #include <ctype.h>
     65 #include <err.h>
     66 #include <errno.h>
     67 #include <fcntl.h>
     68 #include <kvm.h>
     69 #include <limits.h>
     70 #include <netdb.h>
     71 #include <nlist.h>
     72 #include <paths.h>
     73 #include <stdio.h>
     74 #include <stdlib.h>
     75 #include <string.h>
     76 #include <time.h>
     77 #include <tzfile.h>
     78 #include <unistd.h>
     79 #ifdef SUPPORT_UTMP
     80 #include <utmp.h>
     81 #endif
     82 #ifdef SUPPORT_UTMPX
     83 #include <utmpx.h>
     84 #endif
     85 #include <vis.h>
     86 
     87 #include "extern.h"
     88 
     89 struct timeval	boottime;
     90 struct winsize	ws;
     91 kvm_t	       *kd;
     92 time_t		now;		/* the current time of day */
     93 int		ttywidth;	/* width of tty */
     94 int		argwidth;	/* width of tty left to print process args */
     95 int		header = 1;	/* true if -h flag: don't print heading */
     96 int		nflag;		/* true if -n flag: don't convert addrs */
     97 int		wflag;		/* true if -w flag: wide printout */
     98 int		sortidle;	/* sort bu idle time */
     99 char	       *sel_user;	/* login of particular user selected */
    100 char		domain[MAXHOSTNAMELEN + 1];
    101 int maxname = 8, maxline = 3, maxhost = 16;
    102 
    103 /*
    104  * One of these per active utmp entry.
    105  */
    106 struct	entry {
    107 	struct	entry *next;
    108 	char name[UTX_USERSIZE + 1];
    109 	char line[UTX_LINESIZE + 1];
    110 	char host[UTX_HOSTSIZE + 1];
    111 	char type[2];
    112 	struct timeval tv;
    113 	dev_t	tdev;			/* dev_t of terminal */
    114 	time_t	idle;			/* idle time of terminal in seconds */
    115 	struct	kinfo_proc2 *tp;	/* `most interesting' tty proc */
    116 	struct	kinfo_proc2 *pp;	/* pid proc */
    117 	pid_t	pid;			/* pid or ~0 if not known */
    118 } *ehead = NULL, **nextp = &ehead;
    119 
    120 static void	pr_args(struct kinfo_proc2 *);
    121 static void	pr_header(time_t *, int);
    122 static int	proc_compare_wrapper(const struct kinfo_proc2 *,
    123     const struct kinfo_proc2 *);
    124 #if defined(SUPPORT_UTMP) || defined(SUPPORT_UTMPX)
    125 static int	ttystat(const char *, struct stat *);
    126 static void	process(struct entry *);
    127 #endif
    128 static void	fixhost(struct entry *ep);
    129 __dead static void	usage(int);
    130 
    131 int
    132 main(int argc, char **argv)
    133 {
    134 	struct kinfo_proc2 *kp;
    135 	struct entry *ep;
    136 	int ch, i, nentries, nusers, wcmd, curtain, use_sysctl;
    137 	char *memf, *nlistf, *usrnp;
    138 	const char *options;
    139 	time_t then;
    140 	size_t len;
    141 #ifdef SUPPORT_UTMP
    142 	struct utmp *ut;
    143 #endif
    144 #ifdef SUPPORT_UTMPX
    145 	struct utmpx *utx;
    146 #endif
    147 	const char *progname;
    148 	char errbuf[_POSIX2_LINE_MAX];
    149 
    150 	setprogname(argv[0]);
    151 
    152 	/* Are we w(1) or uptime(1)? */
    153 	progname = getprogname();
    154 	if (*progname == '-')
    155 		progname++;
    156 	if (*progname == 'u') {
    157 		wcmd = 0;
    158 		options = "";
    159 	} else {
    160 		wcmd = 1;
    161 		options = "hiM:N:nw";
    162 	}
    163 
    164 	memf = nlistf = NULL;
    165 	while ((ch = getopt(argc, argv, options)) != -1)
    166 		switch (ch) {
    167 		case 'h':
    168 			header = 0;
    169 			break;
    170 		case 'i':
    171 			sortidle = 1;
    172 			break;
    173 		case 'M':
    174 			header = 0;
    175 			memf = optarg;
    176 			break;
    177 		case 'N':
    178 			nlistf = optarg;
    179 			break;
    180 		case 'n':
    181 			nflag = 1;
    182 			break;
    183 		case 'w':
    184 			wflag = 1;
    185 			break;
    186 		case '?':
    187 		default:
    188 			usage(wcmd);
    189 		}
    190 	argc -= optind;
    191 	argv += optind;
    192 
    193 	use_sysctl = (memf == NULL && nlistf == NULL);
    194 
    195 	if ((kd = kvm_openfiles(nlistf, memf, NULL,
    196 	    memf == NULL ? KVM_NO_FILES : O_RDONLY, errbuf)) == NULL)
    197 		errx(1, "%s", errbuf);
    198 
    199 	(void)time(&now);
    200 
    201 	if (use_sysctl) {
    202 		len = sizeof(curtain);
    203 		if (sysctlbyname("security.curtain", &curtain, &len,
    204 		    NULL, 0) == -1)
    205 			curtain = 0;
    206 	}
    207 
    208 #ifdef SUPPORT_UTMPX
    209 	setutxent();
    210 #endif
    211 #ifdef SUPPORT_UTMP
    212 	setutent();
    213 #endif
    214 
    215 	if (*argv)
    216 		sel_user = *argv;
    217 
    218 	nusers = 0;
    219 #ifdef SUPPORT_UTMPX
    220 	while ((utx = getutxent()) != NULL) {
    221 		if (utx->ut_type != USER_PROCESS)
    222 			continue;
    223 		++nusers;
    224 		if (sel_user &&
    225 		    strncmp(utx->ut_name, sel_user, sizeof(utx->ut_name)) != 0)
    226 			continue;
    227 		if ((ep = calloc(1, sizeof(struct entry))) == NULL)
    228 			err(1, NULL);
    229 		(void)memcpy(ep->name, utx->ut_name, sizeof(utx->ut_name));
    230 		(void)memcpy(ep->line, utx->ut_line, sizeof(utx->ut_line));
    231 		ep->name[sizeof(utx->ut_name)] = '\0';
    232 		ep->line[sizeof(utx->ut_line)] = '\0';
    233 		if (!nflag || getnameinfo((struct sockaddr *)&utx->ut_ss,
    234 		    utx->ut_ss.ss_len, ep->host, sizeof(ep->host), NULL, 0,
    235 		    NI_NUMERICHOST) != 0) {
    236 			(void)memcpy(ep->host, utx->ut_host,
    237 			    sizeof(utx->ut_host));
    238 			ep->host[sizeof(utx->ut_host)] = '\0';
    239 		}
    240 		fixhost(ep);
    241 		ep->type[0] = 'x';
    242 		ep->tv = utx->ut_tv;
    243 		ep->pid = utx->ut_pid;
    244 		*nextp = ep;
    245 		nextp = &(ep->next);
    246 		if (wcmd != 0)
    247 			process(ep);
    248 	}
    249 #endif
    250 
    251 #ifdef SUPPORT_UTMP
    252 	while ((ut = getutent()) != NULL) {
    253 		if (ut->ut_name[0] == '\0')
    254 			continue;
    255 
    256 		if (sel_user &&
    257 		    strncmp(ut->ut_name, sel_user, sizeof(ut->ut_name)) != 0)
    258 			continue;
    259 
    260 		/* Don't process entries that we have utmpx for */
    261 		for (ep = ehead; ep != NULL; ep = ep->next) {
    262 			if (strncmp(ep->line, ut->ut_line,
    263 			    sizeof(ut->ut_line)) == 0)
    264 				break;
    265 		}
    266 		if (ep != NULL)
    267 			continue;
    268 
    269 		++nusers;
    270 		if ((ep = calloc(1, sizeof(struct entry))) == NULL)
    271 			err(1, NULL);
    272 		(void)memcpy(ep->name, ut->ut_name, sizeof(ut->ut_name));
    273 		(void)memcpy(ep->line, ut->ut_line, sizeof(ut->ut_line));
    274 		(void)memcpy(ep->host, ut->ut_host, sizeof(ut->ut_host));
    275 		ep->name[sizeof(ut->ut_name)] = '\0';
    276 		ep->line[sizeof(ut->ut_line)] = '\0';
    277 		ep->host[sizeof(ut->ut_host)] = '\0';
    278 		fixhost(ep);
    279 		ep->tv.tv_sec = ut->ut_time;
    280 		*nextp = ep;
    281 		nextp = &(ep->next);
    282 		if (wcmd != 0)
    283 			process(ep);
    284 	}
    285 #endif
    286 
    287 #ifdef SUPPORT_UTMPX
    288 	endutxent();
    289 #endif
    290 #ifdef SUPPORT_UTMP
    291 	endutent();
    292 #endif
    293 
    294 	if (header || wcmd == 0) {
    295 		pr_header(&now, nusers);
    296 		if (wcmd == 0)
    297 			exit (0);
    298 	}
    299 
    300 	if ((kp = kvm_getproc2(kd, KERN_PROC_ALL, 0,
    301 	    sizeof(struct kinfo_proc2), &nentries)) == NULL)
    302 		errx(1, "%s", kvm_geterr(kd));
    303 
    304 	/* Include trailing space because TTY header starts one column early. */
    305 	for (i = 0; i < nentries; i++, kp++) {
    306 
    307 		for (ep = ehead; ep != NULL; ep = ep->next) {
    308 			if (ep->tdev != 0 && ep->tdev == kp->p_tdev &&
    309 			    kp->p__pgid == kp->p_tpgid) {
    310 				/*
    311 				 * Proc is in foreground of this
    312 				 * terminal
    313 				 */
    314 				if (proc_compare_wrapper(ep->tp, kp))
    315 					ep->tp = kp;
    316 				break;
    317 			}
    318 			if (ep->pid != 0 && ep->pid == kp->p_pid) {
    319 				ep->pp = kp;
    320 				break;
    321 			}
    322 		}
    323 	}
    324 
    325 	if ((ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1 &&
    326 	    ioctl(STDERR_FILENO, TIOCGWINSZ, &ws) == -1 &&
    327 	    ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) == -1) || ws.ws_col == 0)
    328 		ttywidth = 79;
    329 	else
    330 		ttywidth = ws.ws_col - 1;
    331 
    332 	if (!wflag && maxhost > (ttywidth / 3))
    333 		maxhost = ttywidth / 3;
    334 
    335 	argwidth = printf("%-*s TTY     %-*s %*s  IDLE WHAT\n",
    336 	    maxname, "USER", maxhost, "FROM",
    337 	    7 /* "dddhhXm" */, "LOGIN@");
    338 	argwidth -= sizeof("WHAT\n") - 1 /* NUL */;
    339 	argwidth = ttywidth - argwidth;
    340 	if (argwidth < 4)
    341 		argwidth = 8;
    342 	if (wflag)
    343 		argwidth = -1;
    344 
    345 	/* sort by idle time */
    346 	if (sortidle && ehead != NULL) {
    347 		struct entry *from = ehead, *save;
    348 
    349 		ehead = NULL;
    350 		while (from != NULL) {
    351 			for (nextp = &ehead;
    352 			    (*nextp) && from->idle >= (*nextp)->idle;
    353 			    nextp = &(*nextp)->next)
    354 				continue;
    355 			save = from;
    356 			from = from->next;
    357 			save->next = *nextp;
    358 			*nextp = save;
    359 		}
    360 	}
    361 #if defined(SUPPORT_UTMP) && defined(SUPPORT_UTMPX)
    362 	else if (ehead != NULL) {
    363 		struct entry *from = ehead, *save;
    364 
    365 		ehead = NULL;
    366 		while (from != NULL) {
    367 			for (nextp = &ehead;
    368 			    (*nextp) && strcmp(from->line, (*nextp)->line) > 0;
    369 			    nextp = &(*nextp)->next)
    370 				continue;
    371 			save = from;
    372 			from = from->next;
    373 			save->next = *nextp;
    374 			*nextp = save;
    375 		}
    376 	}
    377 #endif
    378 
    379 	if (!nflag) {
    380 		int	rv;
    381 		char	*p;
    382 
    383 		rv = gethostname(domain, sizeof(domain));
    384 		domain[sizeof(domain) - 1] = '\0';
    385 		if (rv < 0 || (p = strchr(domain, '.')) == 0)
    386 			domain[0] = '\0';
    387 		else
    388 			memmove(domain, p, strlen(p) + 1);
    389 	}
    390 
    391 	for (ep = ehead; ep != NULL; ep = ep->next) {
    392 		if (ep->tp != NULL)
    393 			kp = ep->tp;
    394 		else if (ep->pp != NULL)
    395 			kp = ep->pp;
    396 		else if (ep->pid != 0) {
    397 			if (curtain)
    398 				kp = NULL;
    399 			else {
    400 				warnx("Stale utmp%s entry: %s %s %s",
    401 				    ep->type, ep->name, ep->line, ep->host);
    402 				continue;
    403 			}
    404 		}
    405 		usrnp = (kp == NULL) ? ep->name : kp->p_login;
    406 		(void)printf("%-*s %-7.7s %-*.*s ",
    407 		    maxname, usrnp, ep->line,
    408 		    maxhost, maxhost, ep->host);
    409 		then = (time_t)ep->tv.tv_sec;
    410 		pr_attime(&then, &now);
    411 		pr_idle(ep->idle);
    412 		pr_args(kp);
    413 		(void)printf("\n");
    414 	}
    415 	exit(0);
    416 }
    417 
    418 static void
    419 pr_args(struct kinfo_proc2 *kp)
    420 {
    421 	char **argv;
    422 	int left;
    423 
    424 	if (kp == 0)
    425 		goto nothing;
    426 	left = argwidth;
    427 	argv = kvm_getargv2(kd, kp, (argwidth < 0) ? 0 : argwidth);
    428 	if (argv == 0) {
    429 		fmt_putc('(', &left);
    430 		fmt_puts((char *)kp->p_comm, &left);
    431 		fmt_putc(')', &left);
    432 		return;
    433 	}
    434 	while (*argv) {
    435 		fmt_puts(*argv, &left);
    436 		argv++;
    437 		fmt_putc(' ', &left);
    438 	}
    439 	return;
    440 nothing:
    441 	putchar('-');
    442 }
    443 
    444 static void
    445 pr_header(time_t *nowp, int nusers)
    446 {
    447 	double avenrun[3];
    448 	time_t uptime;
    449 	int days, hrs, mins;
    450 	int mib[2];
    451 	size_t size, i;
    452 	char buf[256];
    453 
    454 	/*
    455 	 * Print time of day.
    456 	 *
    457 	 * SCCS forces the string manipulation below, as it replaces
    458 	 * %, M, and % in a character string with the file name.
    459 	 */
    460 	(void)strftime(buf, sizeof(buf), "%l:%" "M%p", localtime(nowp));
    461 	buf[sizeof(buf) - 1] = '\0';
    462 	(void)printf("%s ", buf);
    463 
    464 	/*
    465 	 * Print how long system has been up.
    466 	 * (Found by looking getting "boottime" from the kernel)
    467 	 */
    468 	mib[0] = CTL_KERN;
    469 	mib[1] = KERN_BOOTTIME;
    470 	size = sizeof(boottime);
    471 	if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 &&
    472 	    boottime.tv_sec != 0) {
    473 		uptime = now - boottime.tv_sec;
    474 		uptime += 30;
    475 		if (uptime > SECSPERMIN) {
    476 			days = uptime / SECSPERDAY;
    477 			uptime %= SECSPERDAY;
    478 			hrs = uptime / SECSPERHOUR;
    479 			uptime %= SECSPERHOUR;
    480 			mins = uptime / SECSPERMIN;
    481 			(void)printf(" up");
    482 			if (days > 0)
    483 				(void)printf(" %d day%s,", days,
    484 				    days > 1 ? "s" : "");
    485 			if (hrs > 0 && mins > 0)
    486 				(void)printf(" %2d:%02d,", hrs, mins);
    487 			else {
    488 				if (hrs > 0)
    489 					(void)printf(" %d hr%s,",
    490 					    hrs, hrs > 1 ? "s" : "");
    491 				if (mins > 0)
    492 					(void)printf(" %d min%s,",
    493 					    mins, mins > 1 ? "s" : "");
    494 			}
    495 		}
    496 	}
    497 
    498 	/* Print number of users logged in to system */
    499 	(void)printf(" %d user%s", nusers, nusers != 1 ? "s" : "");
    500 
    501 	/*
    502 	 * Print 1, 5, and 15 minute load averages.
    503 	 */
    504 	if (getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0])) == -1)
    505 		(void)printf(", no load average information available\n");
    506 	else {
    507 		(void)printf(", load averages:");
    508 		for (i = 0; i < (sizeof(avenrun) / sizeof(avenrun[0])); i++) {
    509 			if (i > 0)
    510 				(void)printf(",");
    511 			(void)printf(" %.2f", avenrun[i]);
    512 		}
    513 		(void)printf("\n");
    514 	}
    515 }
    516 
    517 #if defined(SUPPORT_UTMP) || defined(SUPPORT_UTMPX)
    518 static int
    519 ttystat(const char *line, struct stat *st)
    520 {
    521 	char ttybuf[MAXPATHLEN];
    522 
    523 	(void)snprintf(ttybuf, sizeof(ttybuf), "%s%s", _PATH_DEV, line);
    524 	return stat(ttybuf, st);
    525 }
    526 
    527 static void
    528 process(struct entry *ep)
    529 {
    530 	struct stat st;
    531 	time_t touched;
    532 	int max;
    533 
    534 	if ((max = strlen(ep->name)) > maxname)
    535 		maxname = max;
    536 	if ((max = strlen(ep->line)) > maxline)
    537 		maxline = max;
    538 	if ((max = strlen(ep->host)) > maxhost)
    539 		maxhost = max;
    540 
    541 	ep->tdev = 0;
    542 	ep->idle = (time_t)-1;
    543 
    544 #ifdef SUPPORT_UTMP
    545 	/*
    546 	 * Hack to recognize and correctly parse
    547 	 * ut entry made by ftpd. The "tty" used
    548 	 * by ftpd is not a real tty, just identifier in
    549 	 * form ftpPID. Pid parsed from the "tty name"
    550 	 * is used later to match corresponding process.
    551 	 * NB: This is only used for utmp entries. For utmpx,
    552 	 * we already have the pid.
    553 	 */
    554 	if (ep->pid == 0 && strncmp(ep->line, "ftp", 3) == 0) {
    555 		ep->pid = strtol(ep->line + 3, NULL, 10);
    556 		return;
    557 	}
    558 #endif
    559 	if (ttystat(ep->line, &st) == -1)
    560 		return;
    561 
    562 	ep->tdev = st.st_rdev;
    563 	/*
    564 	 * If this is the console device, attempt to ascertain
    565 	 * the true console device dev_t.
    566 	 */
    567 	if (ep->tdev == 0) {
    568 		int mib[2];
    569 		size_t size;
    570 
    571 		mib[0] = CTL_KERN;
    572 		mib[1] = KERN_CONSDEV;
    573 		size = sizeof(dev_t);
    574 		(void) sysctl(mib, 2, &ep->tdev, &size, NULL, 0);
    575 	}
    576 
    577 	touched = st.st_atime;
    578 	if (touched < ep->tv.tv_sec) {
    579 		/* tty untouched since before login */
    580 		touched = ep->tv.tv_sec;
    581 	}
    582 	if ((ep->idle = now - touched) < 0)
    583 		ep->idle = 0;
    584 }
    585 #endif
    586 
    587 static int
    588 proc_compare_wrapper(const struct kinfo_proc2 *p1,
    589     const struct kinfo_proc2 *p2)
    590 {
    591 	struct kinfo_lwp *l1, *l2;
    592 	int cnt;
    593 
    594 	if (p1 == NULL)
    595 		return 1;
    596 
    597 	l1 = kvm_getlwps(kd, p1->p_pid, 0, sizeof(*l1), &cnt);
    598 	if (l1 == NULL || cnt == 0)
    599 		return 1;
    600 
    601 	l2 = kvm_getlwps(kd, p2->p_pid, 0, sizeof(*l1), &cnt);
    602 	if (l2 == NULL || cnt == 0)
    603 		return 0;
    604 
    605 	return proc_compare(p1, l1, p2, l2);
    606 }
    607 
    608 static void
    609 fixhost(struct entry *ep)
    610 {
    611 	char host_buf[sizeof(ep->host)];
    612 	char *p, *x;
    613 	struct hostent *hp;
    614 	struct in_addr l;
    615 
    616 	strlcpy(host_buf, *ep->host ? ep->host : "-", sizeof(host_buf));
    617 	p = host_buf;
    618 
    619 	/*
    620 	 * XXX: Historical behavior, ':' in hostname means X display number,
    621 	 * IPv6 not handled.
    622 	 */
    623 	for (x = p; x < &host_buf[sizeof(host_buf)]; x++)
    624 		if (*x == '\0' || *x == ':')
    625 			break;
    626 	if (x == p + sizeof(host_buf) || *x != ':')
    627 		x = NULL;
    628 	else
    629 		*x++ = '\0';
    630 
    631 	if (!nflag && inet_aton(p, &l) &&
    632 	    (hp = gethostbyaddr((char *)&l, sizeof(l), AF_INET))) {
    633 		if (domain[0] != '\0') {
    634 			p = hp->h_name;
    635 			p += strlen(hp->h_name);
    636 			p -= strlen(domain);
    637 			if (p > hp->h_name &&
    638 			    strcasecmp(p, domain) == 0)
    639 				*p = '\0';
    640 		}
    641 		p = hp->h_name;
    642 	}
    643 
    644 	if (x)
    645 		(void)snprintf(ep->host, sizeof(ep->host), "%s:%s", p, x);
    646 	else
    647 
    648 		strlcpy(ep->host, p, sizeof(ep->host));
    649 }
    650 
    651 static void
    652 usage(int wcmd)
    653 {
    654 
    655 	if (wcmd)
    656 		(void)fprintf(stderr,
    657 		    "Usage: %s [-hinw] [-M core] [-N system] [user]\n",
    658 		    getprogname());
    659 	else
    660 		(void)fprintf(stderr, "Usage: %s\n", getprogname());
    661 	exit(1);
    662 }
    663