xref: /illumos-gate/usr/src/cmd/cmd-inet/usr.bin/finger.c (revision bc54f855e0de1e590115101c80f152a20722cfb0)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 /*
31  * Copyright (c) 1982, 1986, 1988
32  * The Regents of the University of California
33  * All Rights Reserved
34  *
35  * Portions of this document are derived from
36  * software developed by the University of California, Berkeley, and its
37  * contributors.
38  */
39 
40 /*
41  * Copyright (c) 2018, Joyent, Inc.
42  */
43 
44 /*
45  * This is a finger program.  It prints out useful information about users
46  * by digging it up from various system files.
47  *
48  * There are three output formats, all of which give login name, teletype
49  * line number, and login time.  The short output format is reminiscent
50  * of finger on ITS, and gives one line of information per user containing
51  * in addition to the minimum basic requirements (MBR), the user's full name,
52  * idle time and location.
53  * The quick style output is UNIX who-like, giving only name, teletype and
54  * login time.  Finally, the long style output give the same information
55  * as the short (in more legible format), the home directory and shell
56  * of the user, and, if it exits, a copy of the file .plan in the users
57  * home directory.  Finger may be called with or without a list of people
58  * to finger -- if no list is given, all the people currently logged in
59  * are fingered.
60  *
61  * The program is validly called by one of the following:
62  *
63  *	finger			{short form list of users}
64  *	finger -l		{long form list of users}
65  *	finger -b		{briefer long form list of users}
66  *	finger -q		{quick list of users}
67  *	finger -i		{quick list of users with idle times}
68  *	finger -m		{matches arguments against only username}
69  *	finger -f		{suppress header in non-long form}
70  *	finger -p		{suppress printing of .plan file}
71  *	finger -h		{suppress printing of .project file}
72  *	finger -i		{forces "idle" output format}
73  *	finger namelist		{long format list of specified users}
74  *	finger -s namelist	{short format list of specified users}
75  *	finger -w namelist	{narrow short format list of specified users}
76  *
77  * where 'namelist' is a list of users login names.
78  * The other options can all be given after one '-', or each can have its
79  * own '-'.  The -f option disables the printing of headers for short and
80  * quick outputs.  The -b option briefens long format outputs.  The -p
81  * option turns off plans for long format outputs.
82  */
83 
84 #include <sys/types.h>
85 #include <sys/stat.h>
86 #include <utmpx.h>
87 #include <sys/signal.h>
88 #include <pwd.h>
89 #include <stdio.h>
90 #include <lastlog.h>
91 #include <ctype.h>
92 #include <sys/time.h>
93 #include <time.h>
94 #include <sys/socket.h>
95 #include <netinet/in.h>
96 #include <netdb.h>
97 #include <locale.h>
98 #include <sys/select.h>
99 #include <stdlib.h>
100 #include <strings.h>
101 #include <fcntl.h>
102 #include <curses.h>
103 #include <unctrl.h>
104 #include <maillock.h>
105 #include <deflt.h>
106 #include <unistd.h>
107 #include <arpa/inet.h>
108 #include <macros.h>
109 
110 static char gecos_ignore_c = '*';	/* ignore this in real name */
111 static char gecos_sep_c = ',';		/* separator in pw_gecos field */
112 static char gecos_samename = '&';	/* repeat login name in real name */
113 
114 #define	TALKABLE	0220		/* tty is writable if this mode */
115 
116 #define	NMAX	sizeof (((struct utmpx *)0)->ut_name)
117 #define	LMAX	sizeof (((struct utmpx *)0)->ut_line)
118 #define	HMAX	sizeof (((struct utmpx *)0)->ut_host)
119 
120 struct person {				/* one for each person fingered */
121 	char *name;			/* name */
122 	char tty[LMAX+1];		/* null terminated tty line */
123 	char host[HMAX+1];		/* null terminated remote host name */
124 	char *ttyloc;			/* location of tty line, if any */
125 	time_t loginat;			/* time of (last) login */
126 	time_t idletime;		/* how long idle (if logged in) */
127 	char *realname;			/* pointer to full name */
128 	struct passwd *pwd;		/* structure of /etc/passwd stuff */
129 	char loggedin;			/* person is logged in */
130 	char writable;			/* tty is writable */
131 	char original;			/* this is not a duplicate entry */
132 	struct person *link;		/* link to next person */
133 };
134 
135 char LASTLOG[] = "/var/adm/lastlog";	/* last login info */
136 char PLAN[] = "/.plan";			/* what plan file is */
137 char PROJ[] = "/.project";		/* what project file */
138 
139 int unbrief = 1;			/* -b option default */
140 int header = 1;				/* -f option default */
141 int hack = 1;				/* -h option default */
142 int idle = 0;				/* -i option default */
143 int large = 0;				/* -l option default */
144 int match = 1;				/* -m option default */
145 int plan = 1;				/* -p option default */
146 int unquick = 1;			/* -q option default */
147 int small = 0;				/* -s option default */
148 int wide = 1;				/* -w option default */
149 
150 /*
151  * RFC 1288 says that system administrators should have the option of
152  * separately allowing ASCII characters less than 32 or greater than
153  * 126.  The termpass variable keeps track of this.
154  */
155 char	defaultfile[] = "/etc/default/finger";
156 char	passvar[] = "PASS=";
157 int	termpass = 0;			/* default is ASCII only */
158 char *termopts[] = {
159 #define	TERM_LOW	0
160 	"low",
161 #define	TERM_HIGH	1
162 	"high",
163 	(char *)NULL
164 };
165 #define	TS_LOW	(1 << TERM_LOW)		/* print characters less than 32 */
166 #define	TS_HIGH	(1 << TERM_HIGH)	/* print characters greater than 126 */
167 
168 
169 int unshort;
170 FILE *lf;				/* LASTLOG file pointer */
171 struct person *person1;			/* list of people */
172 size_t nperson;				/* number of people */
173 time_t tloc;				/* current time */
174 
175 char usagestr[] = "Usage: "
176 	"finger [-bfhilmpqsw] [name1 [name2 ...] ]\n";
177 
178 int AlreadyPrinted(uid_t uid);
179 void AnyMail(char *name);
180 void catfile(char *s, mode_t mode, int trunc_at_nl);
181 void decode(struct person *pers);
182 void doall(void);
183 void donames(char **argv);
184 void findidle(struct person *pers);
185 void findwhen(struct person *pers);
186 void fwclose(void);
187 void fwopen(void);
188 void initscreening(void);
189 void ltimeprint(char *before, time_t *dt, char *after);
190 int matchcmp(char *gname, char *login, char *given);
191 int namecmp(char *name1, char *name2);
192 int netfinger(char *name);
193 void personprint(struct person *pers);
194 void print(void);
195 struct passwd *pwdcopy(const struct passwd *pfrom);
196 void quickprint(struct person *pers);
197 void shortprint(struct person *pers);
198 void stimeprint(time_t *dt);
199 void sort_by_username(void);
200 
201 
202 int
main(int argc,char ** argv)203 main(int argc, char **argv)
204 {
205 	int c;
206 
207 	(void) setlocale(LC_ALL, "");
208 	/* parse command line for (optional) arguments */
209 	while ((c = getopt(argc, argv, "bfhilmpqsw")) != EOF)
210 			switch (c) {
211 			case 'b':
212 				unbrief = 0;
213 				break;
214 			case 'f':
215 				header = 0;
216 				break;
217 			case 'h':
218 				hack = 0;
219 				break;
220 			case 'i':
221 				idle = 1;
222 				unquick = 0;
223 				break;
224 			case 'l':
225 				large = 1;
226 				break;
227 			case 'm':
228 				match = 0;
229 				break;
230 			case 'p':
231 				plan = 0;
232 				break;
233 			case 'q':
234 				unquick = 0;
235 				break;
236 			case 's':
237 				small = 1;
238 				break;
239 			case 'w':
240 				wide = 0;
241 				break;
242 			default:
243 				(void) fprintf(stderr, usagestr);
244 				exit(1);
245 			}
246 	if (unquick || idle)
247 		tloc = time(NULL);
248 
249 	/* find out what filtering on .plan/.project files we should do */
250 	initscreening();
251 
252 	/*
253 	 * optind == argc means no names given
254 	 */
255 	if (optind == argc)
256 		doall();
257 	else
258 		donames(&argv[optind]);
259 
260 	sort_by_username();
261 
262 	if (nperson > 0)
263 		print();
264 	return (0);
265 	/* NOTREACHED */
266 }
267 
268 void
doall(void)269 doall(void)
270 {
271 	struct person *p;
272 	struct passwd *pw;
273 	struct utmpx *u;
274 	char name[NMAX + 1];
275 
276 	unshort = large;
277 	setutxent();
278 	if (unquick) {
279 		setpwent();
280 		fwopen();
281 	}
282 	while ((u = getutxent()) != NULL) {
283 		if (u->ut_name[0] == 0 ||
284 		    nonuserx(*u) ||
285 		    u->ut_type != USER_PROCESS)
286 			continue;
287 		if (person1 == NULL)
288 			p = person1 = malloc(sizeof (*p));
289 		else {
290 			p->link = malloc(sizeof (*p));
291 			p = p->link;
292 		}
293 		bcopy(u->ut_name, name, NMAX);
294 		name[NMAX] = 0;
295 		bcopy(u->ut_line, p->tty, LMAX);
296 		p->tty[LMAX] = 0;
297 		bcopy(u->ut_host, p->host, HMAX);
298 		p->host[HMAX] = 0;
299 		p->loginat = u->ut_tv.tv_sec;
300 		p->pwd = NULL;
301 		p->loggedin = 1;
302 		if (unquick && (pw = getpwnam(name))) {
303 			p->pwd = pwdcopy(pw);
304 			decode(p);
305 			p->name = p->pwd->pw_name;
306 		} else
307 			p->name = strdup(name);
308 		p->ttyloc = NULL;
309 
310 		nperson++;
311 	}
312 	if (unquick) {
313 		fwclose();
314 		endpwent();
315 	}
316 	endutxent();
317 	if (nperson == 0) {
318 		(void) printf("No one logged on\n");
319 		return;
320 	}
321 	p->link = NULL;
322 }
323 
324 void
donames(char ** argv)325 donames(char **argv)
326 {
327 	struct person	*p;
328 	struct passwd	*pw;
329 	struct utmpx	*u;
330 
331 	/*
332 	 * get names from command line and check to see if they're
333 	 * logged in
334 	 */
335 	unshort = !small;
336 	for (; *argv != NULL; argv++) {
337 		if (netfinger(*argv))
338 			continue;
339 		if (person1 == NULL)
340 			p = person1 = malloc(sizeof (*p));
341 		else {
342 			p->link = malloc(sizeof (*p));
343 			p = p->link;
344 		}
345 		p->name = *argv;
346 		p->loggedin = 0;
347 		p->original = 1;
348 		p->pwd = NULL;
349 
350 		nperson++;
351 	}
352 	if (nperson == 0)
353 		return;
354 	p->link = NULL;
355 	/*
356 	 * if we are doing it, read /etc/passwd for the useful info
357 	 */
358 	if (unquick) {
359 		setpwent();
360 		if (!match) {
361 			for (p = person1; p != NULL; p = p->link) {
362 				if ((pw = getpwnam(p->name)) != NULL)
363 					p->pwd = pwdcopy(pw);
364 			}
365 		} else {
366 			while ((pw = getpwent()) != NULL) {
367 				for (p = person1; p != NULL; p = p->link) {
368 					if (!p->original)
369 						continue;
370 					if (strcmp(p->name, pw->pw_name) != 0 &&
371 					    !matchcmp(pw->pw_gecos, pw->pw_name,
372 					    p->name)) {
373 						continue;
374 					}
375 					if (p->pwd == NULL) {
376 						p->pwd = pwdcopy(pw);
377 					} else {
378 						struct person *new;
379 						/*
380 						 * Handle multiple login names.
381 						 * Insert new "duplicate" entry
382 						 * behind.
383 						 */
384 						new = malloc(sizeof (*new));
385 						new->pwd = pwdcopy(pw);
386 						new->name = p->name;
387 						new->original = 1;
388 						new->loggedin = 0;
389 						new->ttyloc = NULL;
390 						new->link = p->link;
391 						p->original = 0;
392 						p->link = new;
393 						p = new;
394 
395 						nperson++;
396 					}
397 				}
398 			}
399 		}
400 		endpwent();
401 	}
402 	/* Now get login information */
403 	setutxent();
404 	while ((u = getutxent()) != NULL) {
405 		if (u->ut_name[0] == 0 || u->ut_type != USER_PROCESS)
406 			continue;
407 		for (p = person1; p != NULL; p = p->link) {
408 			p->ttyloc = NULL;
409 			if (p->loggedin == 2)
410 				continue;
411 			if (strncmp((p->pwd != NULL) ?
412 			    p->pwd->pw_name : p->name,
413 			    u->ut_name, NMAX) != 0)
414 				continue;
415 			if (p->loggedin == 0) {
416 				bcopy(u->ut_line, p->tty, LMAX);
417 				p->tty[LMAX] = 0;
418 				bcopy(u->ut_host, p->host, HMAX);
419 				p->host[HMAX] = 0;
420 				p->loginat = u->ut_tv.tv_sec;
421 				p->loggedin = 1;
422 			} else {	/* p->loggedin == 1 */
423 				struct person *new;
424 				new = malloc(sizeof (*new));
425 				new->name = p->name;
426 				bcopy(u->ut_line, new->tty, LMAX);
427 				new->tty[LMAX] = 0;
428 				bcopy(u->ut_host, new->host, HMAX);
429 				new->host[HMAX] = 0;
430 				new->loginat = u->ut_tv.tv_sec;
431 				new->pwd = p->pwd;
432 				new->loggedin = 1;
433 				new->original = 0;
434 				new->link = p->link;
435 				p->loggedin = 2;
436 				p->link = new;
437 				p = new;
438 
439 				nperson++;
440 			}
441 		}
442 	}
443 	endutxent();
444 	if (unquick) {
445 		fwopen();
446 		for (p = person1; p != NULL; p = p->link)
447 			decode(p);
448 		fwclose();
449 	}
450 }
451 
452 void
print(void)453 print(void)
454 {
455 	struct person *p;
456 	char *s;
457 
458 	/*
459 	 * print out what we got
460 	 */
461 	if (header) {
462 		if (unquick) {
463 			if (!unshort) {
464 				if (wide) {
465 					(void) printf("Login       "
466 					    "Name               TTY         "
467 					    "Idle    When    Where\n");
468 				} else {
469 					(void) printf("Login    TTY Idle    "
470 					    "When    Where\n");
471 				}
472 			}
473 		} else {
474 			(void) printf("Login      TTY                When");
475 			if (idle)
476 				(void) printf("             Idle");
477 			(void) putchar('\n');
478 		}
479 	}
480 	for (p = person1; p != NULL; p = p->link) {
481 		if (!unquick) {
482 			quickprint(p);
483 			continue;
484 		}
485 		if (!unshort) {
486 			shortprint(p);
487 			continue;
488 		}
489 		personprint(p);
490 		if (p->pwd != NULL && !AlreadyPrinted(p->pwd->pw_uid)) {
491 			AnyMail(p->pwd->pw_name);
492 			if (hack) {
493 				struct stat sbuf;
494 
495 				s = malloc(strlen(p->pwd->pw_dir) +
496 				    sizeof (PROJ));
497 				if (s != NULL) {
498 					(void) strcpy(s, p->pwd->pw_dir);
499 					(void) strcat(s, PROJ);
500 					if (stat(s, &sbuf) != -1 &&
501 					    (S_ISREG(sbuf.st_mode) ||
502 					    S_ISFIFO(sbuf.st_mode)) &&
503 					    (sbuf.st_mode & S_IROTH)) {
504 						(void) printf("Project: ");
505 						catfile(s, sbuf.st_mode, 1);
506 						(void) putchar('\n');
507 					}
508 					free(s);
509 				}
510 			}
511 			if (plan) {
512 				struct stat sbuf;
513 
514 				s = malloc(strlen(p->pwd->pw_dir) +
515 				    sizeof (PLAN));
516 				if (s != NULL) {
517 					(void) strcpy(s, p->pwd->pw_dir);
518 					(void) strcat(s, PLAN);
519 					if (stat(s, &sbuf) == -1 ||
520 					    (!S_ISREG(sbuf.st_mode) &&
521 					    !S_ISFIFO(sbuf.st_mode)) ||
522 					    ((sbuf.st_mode & S_IROTH) == 0))
523 						(void) printf("No Plan.\n");
524 					else {
525 						(void) printf("Plan:\n");
526 						catfile(s, sbuf.st_mode, 0);
527 					}
528 					free(s);
529 				}
530 			}
531 		}
532 		if (p->link != NULL)
533 			(void) putchar('\n');
534 	}
535 }
536 
537 /*
538  * Duplicate a pwd entry.
539  * Note: Only the useful things (what the program currently uses) are copied.
540  */
541 struct passwd *
pwdcopy(const struct passwd * pfrom)542 pwdcopy(const struct passwd *pfrom)
543 {
544 	struct passwd *pto;
545 
546 	pto = malloc(sizeof (*pto));
547 	pto->pw_name = strdup(pfrom->pw_name);
548 	pto->pw_uid = pfrom->pw_uid;
549 	pto->pw_gecos = strdup(pfrom->pw_gecos);
550 	pto->pw_dir = strdup(pfrom->pw_dir);
551 	pto->pw_shell = strdup(pfrom->pw_shell);
552 	return (pto);
553 }
554 
555 /*
556  * print out information on quick format giving just name, tty, login time
557  * and idle time if idle is set.
558  */
559 void
quickprint(struct person * pers)560 quickprint(struct person *pers)
561 {
562 	(void) printf("%-8.8s  ", pers->name);
563 	if (pers->loggedin) {
564 		if (idle) {
565 			findidle(pers);
566 			(void) printf("%c%-12s %-16.16s",
567 			    pers->writable ? ' ' : '*',
568 			    pers->tty, ctime(&pers->loginat));
569 			ltimeprint("   ", &pers->idletime, "");
570 		} else {
571 			(void) printf(" %-12s %-16.16s",
572 			    pers->tty, ctime(&pers->loginat));
573 		}
574 		(void) putchar('\n');
575 	} else {
576 		(void) printf("          Not Logged In\n");
577 	}
578 }
579 
580 /*
581  * print out information in short format, giving login name, full name,
582  * tty, idle time, login time, and host.
583  */
584 void
shortprint(struct person * pers)585 shortprint(struct person *pers)
586 {
587 	char *p;
588 
589 	if (pers->pwd == NULL) {
590 		(void) printf("%-15s       ???\n", pers->name);
591 		return;
592 	}
593 	(void) printf("%-8s", pers->pwd->pw_name);
594 	if (wide) {
595 		if (pers->realname != NULL) {
596 			(void) printf(" %-20.20s", pers->realname);
597 		} else {
598 			(void) printf("        ???          ");
599 		}
600 	}
601 	(void) putchar(' ');
602 	if (pers->loggedin && !pers->writable) {
603 		(void) putchar('*');
604 	} else {
605 		(void) putchar(' ');
606 	}
607 	if (*pers->tty) {
608 		(void) printf("%-11.11s ", pers->tty);
609 	} else {
610 		(void) printf("            ");  /* 12 spaces */
611 	}
612 	p = ctime(&pers->loginat);
613 	if (pers->loggedin) {
614 		stimeprint(&pers->idletime);
615 		(void) printf(" %3.3s %-5.5s ", p, p + 11);
616 	} else if (pers->loginat == 0) {
617 		(void) printf(" < .  .  .  . >");
618 	} else if (tloc - pers->loginat >= 180 * 24 * 60 * 60) {
619 		(void) printf(" <%-6.6s, %-4.4s>", p + 4, p + 20);
620 	} else {
621 		(void) printf(" <%-12.12s>", p + 4);
622 	}
623 	if (*pers->host) {
624 		(void) printf(" %-20.20s", pers->host);
625 	} else {
626 		if (pers->ttyloc != NULL)
627 			(void) printf(" %-20.20s", pers->ttyloc);
628 	}
629 	(void) putchar('\n');
630 }
631 
632 
633 /*
634  * print out a person in long format giving all possible information.
635  * directory and shell are inhibited if unbrief is clear.
636  */
637 void
personprint(struct person * pers)638 personprint(struct person *pers)
639 {
640 	if (pers->pwd == NULL) {
641 		(void) printf("Login name: %-10s\t\t\tIn real life: ???\n",
642 		    pers->name);
643 		return;
644 	}
645 	(void) printf("Login name: %-10s", pers->pwd->pw_name);
646 	if (pers->loggedin && !pers->writable) {
647 		(void) printf("	(messages off)	");
648 	} else {
649 		(void) printf("			");
650 	}
651 	if (pers->realname != NULL) {
652 		(void) printf("In real life: %s", pers->realname);
653 	}
654 	if (unbrief) {
655 		(void) printf("\nDirectory: %-25s", pers->pwd->pw_dir);
656 		if (*pers->pwd->pw_shell)
657 			(void) printf("\tShell: %-s", pers->pwd->pw_shell);
658 	}
659 	if (pers->loggedin) {
660 		char *ep = ctime(&pers->loginat);
661 		if (*pers->host) {
662 			(void) printf("\nOn since %15.15s on %s from %s",
663 			    &ep[4], pers->tty, pers->host);
664 			ltimeprint("\n", &pers->idletime, " Idle Time");
665 		} else {
666 			(void) printf("\nOn since %15.15s on %-12s",
667 			    &ep[4], pers->tty);
668 			ltimeprint("\n", &pers->idletime, " Idle Time");
669 		}
670 	} else if (pers->loginat == 0) {
671 		(void) printf("\nNever logged in.");
672 	} else if (tloc - pers->loginat > 180 * 24 * 60 * 60) {
673 		char *ep = ctime(&pers->loginat);
674 		(void) printf("\nLast login %10.10s, %4.4s on %s",
675 		    ep, ep+20, pers->tty);
676 		if (*pers->host) {
677 			(void) printf(" from %s", pers->host);
678 		}
679 	} else {
680 		char *ep = ctime(&pers->loginat);
681 		(void) printf("\nLast login %16.16s on %s", ep, pers->tty);
682 		if (*pers->host) {
683 			(void) printf(" from %s", pers->host);
684 		}
685 	}
686 	(void) putchar('\n');
687 }
688 
689 
690 /*
691  * decode the information in the gecos field of /etc/passwd
692  */
693 void
decode(struct person * pers)694 decode(struct person *pers)
695 {
696 	char buffer[256];
697 	char *bp, *gp, *lp;
698 
699 	pers->realname = NULL;
700 	if (pers->pwd == NULL)
701 		return;
702 	gp = pers->pwd->pw_gecos;
703 	bp = buffer;
704 
705 	if (gecos_ignore_c != '\0' &&
706 	    *gp == gecos_ignore_c) {
707 		gp++;
708 	}
709 	while (*gp != '\0' &&
710 	    *gp != gecos_sep_c)	{			/* name */
711 		if (*gp == gecos_samename) {
712 			lp = pers->pwd->pw_name;
713 			if (islower(*lp))
714 				*bp++ = toupper(*lp++);
715 			while (*bp++ = *lp++)
716 				;
717 			bp--;
718 			gp++;
719 		} else {
720 			*bp++ = *gp++;
721 		}
722 	}
723 	*bp++ = 0;
724 	if (bp > (buffer + 1))
725 		pers->realname = strdup(buffer);
726 	if (pers->loggedin)
727 		findidle(pers);
728 	else
729 		findwhen(pers);
730 }
731 
732 /*
733  * find the last log in of a user by checking the LASTLOG file.
734  * the entry is indexed by the uid, so this can only be done if
735  * the uid is known (which it isn't in quick mode)
736  */
737 void
fwopen(void)738 fwopen(void)
739 {
740 	if ((lf = fopen(LASTLOG, "r")) == NULL)
741 		(void) fprintf(stderr, "finger: %s open error\n", LASTLOG);
742 }
743 
744 void
findwhen(struct person * pers)745 findwhen(struct person *pers)
746 {
747 	struct lastlog ll;
748 
749 	if (lf != NULL) {
750 		if (fseeko(lf, (off_t)pers->pwd->pw_uid * (off_t)sizeof (ll),
751 		    SEEK_SET) == 0) {
752 			if (fread((char *)&ll, sizeof (ll), 1, lf) == 1) {
753 				int l_max, h_max;
754 
755 				l_max = min(LMAX, sizeof (ll.ll_line));
756 				h_max = min(HMAX, sizeof (ll.ll_host));
757 
758 				bcopy(ll.ll_line, pers->tty, l_max);
759 				pers->tty[l_max] = '\0';
760 				bcopy(ll.ll_host, pers->host, h_max);
761 				pers->host[h_max] = '\0';
762 				pers->loginat = ll.ll_time;
763 			} else {
764 				if (ferror(lf))
765 					(void) fprintf(stderr,
766 					    "finger: %s read error\n", LASTLOG);
767 				pers->tty[0] = 0;
768 				pers->host[0] = 0;
769 				pers->loginat = 0L;
770 			}
771 		} else {
772 			(void) fprintf(stderr, "finger: %s fseeko error\n",
773 			    LASTLOG);
774 		}
775 	} else {
776 		pers->tty[0] = 0;
777 		pers->host[0] = 0;
778 		pers->loginat = 0L;
779 	}
780 }
781 
782 void
fwclose(void)783 fwclose(void)
784 {
785 	if (lf != NULL)
786 		(void) fclose(lf);
787 }
788 
789 /*
790  * find the idle time of a user by doing a stat on /dev/tty??,
791  * where tty?? has been gotten from UTMPX_FILE, supposedly.
792  */
793 void
findidle(struct person * pers)794 findidle(struct person *pers)
795 {
796 	struct stat ttystatus;
797 	struct stat inputdevstatus;
798 #define	TTYLEN (sizeof ("/dev/") - 1)
799 	static char buffer[TTYLEN + LMAX + 1] = "/dev/";
800 	time_t t;
801 	time_t lastinputtime;
802 
803 	(void) strcpy(buffer + TTYLEN, pers->tty);
804 	buffer[TTYLEN+LMAX] = 0;
805 	if (stat(buffer, &ttystatus) < 0) {
806 		(void) fprintf(stderr, "finger: Can't stat %s\n", buffer);
807 		exit(4);
808 	}
809 	lastinputtime = ttystatus.st_atime;
810 	if (strcmp(pers->tty, "console") == 0) {
811 		/*
812 		 * On the console, the user may be running a window system; if
813 		 * so, their activity will show up in the last-access times of
814 		 * "/dev/kbd" and "/dev/mouse", so take the minimum of the idle
815 		 * times on those two devices and "/dev/console" and treat that
816 		 * as the idle time.
817 		 */
818 		if (stat("/dev/kbd", &inputdevstatus) == 0) {
819 			if (lastinputtime < inputdevstatus.st_atime)
820 				lastinputtime = inputdevstatus.st_atime;
821 		}
822 		if (stat("/dev/mouse", &inputdevstatus) == 0) {
823 			if (lastinputtime < inputdevstatus.st_atime)
824 				lastinputtime = inputdevstatus.st_atime;
825 		}
826 	}
827 	t = time(NULL);
828 	if (t < lastinputtime)
829 		pers->idletime = (time_t)0;
830 	else
831 		pers->idletime = t - lastinputtime;
832 	pers->writable = (ttystatus.st_mode & TALKABLE) == TALKABLE;
833 }
834 
835 /*
836  * print idle time in short format; this program always prints 4 characters;
837  * if the idle time is zero, it prints 4 blanks.
838  */
839 void
stimeprint(time_t * dt)840 stimeprint(time_t *dt)
841 {
842 	struct tm *delta;
843 
844 	delta = gmtime(dt);
845 	if (delta->tm_yday == 0)
846 		if (delta->tm_hour == 0)
847 			if (delta->tm_min == 0)
848 				(void) printf("    ");
849 			else
850 				(void) printf("  %2d", delta->tm_min);
851 		else
852 			if (delta->tm_hour >= 10)
853 				(void) printf("%3d:", delta->tm_hour);
854 			else
855 				(void) printf("%1d:%02d",
856 				    delta->tm_hour, delta->tm_min);
857 	else
858 		(void) printf("%3dd", delta->tm_yday);
859 }
860 
861 /*
862  * print idle time in long format with care being taken not to pluralize
863  * 1 minutes or 1 hours or 1 days.
864  * print "prefix" first.
865  */
866 void
ltimeprint(char * before,time_t * dt,char * after)867 ltimeprint(char *before, time_t *dt, char *after)
868 {
869 	struct tm *delta;
870 
871 	delta = gmtime(dt);
872 	if (delta->tm_yday == 0 && delta->tm_hour == 0 && delta->tm_min == 0 &&
873 	    delta->tm_sec <= 10)
874 		return;
875 	(void) printf("%s", before);
876 	if (delta->tm_yday >= 10)
877 		(void) printf("%d days", delta->tm_yday);
878 	else if (delta->tm_yday > 0)
879 		(void) printf("%d day%s %d hour%s",
880 		    delta->tm_yday, delta->tm_yday == 1 ? "" : "s",
881 		    delta->tm_hour, delta->tm_hour == 1 ? "" : "s");
882 	else
883 		if (delta->tm_hour >= 10)
884 			(void) printf("%d hours", delta->tm_hour);
885 		else if (delta->tm_hour > 0)
886 			(void) printf("%d hour%s %d minute%s",
887 			    delta->tm_hour, delta->tm_hour == 1 ? "" : "s",
888 			    delta->tm_min, delta->tm_min == 1 ? "" : "s");
889 		else
890 			if (delta->tm_min >= 10)
891 				(void) printf("%2d minutes", delta->tm_min);
892 			else if (delta->tm_min == 0)
893 				(void) printf("%2d seconds", delta->tm_sec);
894 			else
895 				(void) printf("%d minute%s %d second%s",
896 				    delta->tm_min,
897 				    delta->tm_min == 1 ? "" : "s",
898 				    delta->tm_sec,
899 				    delta->tm_sec == 1 ? "" : "s");
900 	(void) printf("%s", after);
901 }
902 
903 /*
904  * The grammar of the pw_gecos field is sufficiently complex that the
905  * best way to parse it is by using an explicit finite-state machine,
906  * in which a table defines the rules of interpretation.
907  *
908  * Some special rules are necessary to handle the fact that names
909  * may contain certain punctuation characters.  At this writing,
910  * the possible punctuation characters are '.', '-', and '_'.
911  *
912  * Other rules are needed to account for characters that require special
913  * processing when they appear in the pw_gecos field.  At present, there
914  * are three such characters, with these default values and effects:
915  *
916  *    gecos_ignore_c   '*'    This character is ignored.
917  *    gecos_sep_c      ','    Delimits displayed and nondisplayed contents.
918  *    gecos_samename   '&'    Copies the login name into the output.
919  *
920  * As the program examines each successive character in the returned
921  * pw_gecos value, it fetches (from the table) the FSM rule applicable
922  * for that character in the current machine state, and thus determines
923  * the next state.
924  *
925  * The possible states are:
926  *    S0 start
927  *    S1 in a word
928  *    S2 not in a word
929  *    S3 copy login name into output
930  *    S4 end of GECOS field
931  *
932  * Here follows a depiction of the state transitions.
933  *
934  *
935  *              gecos_ignore_c OR isspace OR any other character
936  *                  +--+
937  *                  |  |
938  *                  |  V
939  *                 +-----+
940  *    NULL OR      | S0  |  isalpha OR isdigit
941  * +---------------|start|------------------------+
942  * |  gecos_sep_c  +-----+                        |     isalpha OR isdigit
943  * |                |  |                          |   +---------------------+
944  * |                |  |                          |   | OR '.' '-' '_'      |
945  * |                |  |isspace                   |   |                     |
946  * |                |  +-------+                  V   V                     |
947  * |                |          |              +-----------+                 |
948  * |                |          |              |    S1     |<--+             |
949  * |                |          |              | in a word |   | isalpha OR  |
950  * |                |          |              +-----------+   | isdigit OR  |
951  * |                |          |               |  |  |  |     | '.' '-' '_' |
952  * |                |    +----- ---------------+  |  |  +-----+             |
953  * |                |    |     |                  |  |                      |
954  * |                |    |     |   gecos_ignore_c |  |                      |
955  * |                |    |     |   isspace        |  |                      |
956  * |                |    |     |   ispunct/other  |  |                      |
957  * |                |    |     |   any other char |  |                      |
958  * |                |    |     |  +---------------+  |                      |
959  * |                |    |     |  |                  |NULL OR gecos_sep_c   |
960  * |                |    |     |  |                  +------------------+   |
961  * |  gecos_samename|    |     V  V                                     |   |
962  * |  +-------------+    |    +---------------+                         |   |
963  * |  |                  |    |       S2      | isspace OR '.' '-' '_'  |   |
964  * |  |  gecos_samename  |    | not in a word |<---------------------+  |   |
965  * |  |  +---------------+    +---------------+ OR gecos_ignore_c    |  |   |
966  * |  |  |                        |    ^  |  |  OR ispunct OR other  |  |   |
967  * |  |  |                        |    |  |  |                       |  |   |
968  * |  |  |  gecos_samename        |    |  |  +-----------------------+  |   |
969  * |  |  |  +---------------------+    |  |                             |   |
970  * |  |  |  |                          |  |                             |   |
971  * |  |  |  |            gecos_ignore_c|  | NULL OR gecos_sep_c         |   |
972  * |  |  |  |            gecos_samename|  +-----------------------+     |   |
973  * |  |  |  |            ispunct/other |                          |     |   |
974  * |  V  V  V            isspace       |                          |     |   |
975  * | +-----------------+ any other char|                          |     |   |
976  * | |      S3         |---------------+  isalpha OR isdigit OR   |     |   |
977  * | |insert login name|------------------------------------------ ----- ---+
978  * | +-----------------+                  '.' '-' '_'             |     |
979  * |                |    NULL OR gecos_sep_c                      |     |
980  * |                +------------------------------------------+  |     |
981  * |                                                           |  |     |
982  * |                                                           V  V     V
983  * |                                                         +------------+
984  * | NULL OR gecos_sep_c                                     |     S4     |
985  * +-------------------------------------------------------->|end of gecos|<--+
986  *                                                           +------------+   |
987  *                                                                      | all |
988  *                                                                      +-----+
989  *
990  *
991  *  The transitions from the above diagram are summarized in
992  *  the following table of target states, which is implemented
993  *  in code as the gecos_fsm array.
994  *
995  * Input:
996  *        +--gecos_ignore_c
997  *        |    +--gecos_sep_c
998  *        |    |    +--gecos_samename
999  *        |    |    |    +--isalpha
1000  *        |    |    |    |    +--isdigit
1001  *        |    |    |    |    |      +--isspace
1002  *        |    |    |    |    |      |    +--punctuation possible in name
1003  *        |    |    |    |    |      |    |    +--other punctuation
1004  *        |    |    |    |    |      |    |    |    +--NULL character
1005  *        |    |    |    |    |      |    |    |    |    +--any other character
1006  *        |    |    |    |    |      |    |    |    |    |
1007  *        V    V    V    V    V      V    V    V    V    V
1008  * From: ---------------------------------------------------
1009  * S0   | S0 | S4 | S3 | S1 | S1 |   S0 | S1 | S2 | S4 | S0 |
1010  * S1   | S2 | S4 | S3 | S1 | S1 |   S2 | S1 | S2 | S4 | S2 |
1011  * S2   | S2 | S4 | S3 | S1 | S1 |   S2 | S2 | S2 | S4 | S2 |
1012  * S3   | S2 | S4 | S2 | S1 | S1 |   S2 | S1 | S2 | S4 | S2 |
1013  * S4   | S4 | S4 | S4 | S4 | S4 |   S4 | S4 | S4 | S4 | S4 |
1014  *
1015  */
1016 
1017 /*
1018  * Data types and structures for scanning the pw_gecos field.
1019  */
1020 typedef enum gecos_state {
1021 	S0,		/* start */
1022 	S1,		/* in a word */
1023 	S2,		/* not in a word */
1024 	S3,		/* copy login */
1025 	S4		/* end of gecos */
1026 } gecos_state_t;
1027 
1028 #define	GFSM_ROWS 5
1029 #define	GFSM_COLS 10
1030 
1031 gecos_state_t gecos_fsm[GFSM_ROWS][GFSM_COLS] = {
1032 	{S0, S4, S3, S1, S1,	S0, S1, S2, S4, S0},	/* S0 */
1033 	{S2, S4, S3, S1, S1,	S2, S1, S2, S4, S2},	/* S1 */
1034 	{S2, S4, S3, S1, S1,	S2, S2, S2, S4, S2},	/* S2 */
1035 	{S2, S4, S2, S1, S1,	S2, S1, S2, S4, S2},	/* S3 */
1036 	{S4, S4, S4, S4, S4,	S4, S4, S4, S4, S4}	/* S4 */
1037 };
1038 
1039 /*
1040  * Scan the pw_gecos field according to defined state table;
1041  * return the next state according the the rules.
1042  */
1043 gecos_state_t
gecos_scan_state(gecos_state_t instate,char ch)1044 gecos_scan_state(gecos_state_t instate, char ch)
1045 {
1046 	if (ch == gecos_ignore_c) {
1047 		return (gecos_fsm[instate][0]);
1048 	} else if (ch == gecos_sep_c) {
1049 		return (gecos_fsm[instate][1]);
1050 	} else if (ch == gecos_samename) {
1051 		return (gecos_fsm[instate][2]);
1052 	} else if (isalpha(ch)) {
1053 		return (gecos_fsm[instate][3]);
1054 	} else if (isdigit(ch)) {
1055 		return (gecos_fsm[instate][4]);
1056 	} else if (isspace(ch)) {
1057 		return (gecos_fsm[instate][5]);
1058 	} else if (ch == '.' || ch == '-' || ch == '_') {
1059 		return (gecos_fsm[instate][6]);
1060 	} else if (ispunct(ch)) {
1061 		return (gecos_fsm[instate][7]);
1062 	} else if (ch == '\0') {
1063 		return (gecos_fsm[instate][8]);
1064 	}
1065 	return (gecos_fsm[instate][9]);
1066 }
1067 
1068 
1069 /*
1070  * Compare the given argument, which is taken to be a username, with
1071  * the login name and with strings in the the pw_gecos field.
1072  */
1073 int
matchcmp(char * gname,char * login,char * given)1074 matchcmp(char *gname, char *login, char *given)
1075 {
1076 	char	buffer[100];
1077 	char	*bp, *lp, *gp;
1078 
1079 	gecos_state_t kstate = S0;
1080 	gecos_state_t kstate_next = S0;
1081 
1082 	if (*gname == '\0' && *given == '\0')
1083 		return (1);
1084 
1085 	bp = buffer;
1086 	gp = gname;
1087 
1088 	do {
1089 		kstate_next = gecos_scan_state(kstate, *gp);
1090 
1091 		switch (kstate_next) {
1092 
1093 		case S0:
1094 			gp++;
1095 			break;
1096 		case S1:
1097 			if (bp < buffer + sizeof (buffer)) {
1098 				*bp++ = *gp++;
1099 			}
1100 			break;
1101 		case S2:
1102 			if (kstate == S1 || kstate == S3) {
1103 				*bp++ = ' ';
1104 			}
1105 			gp++;
1106 			break;
1107 		case S3:
1108 			lp = login;
1109 			do {
1110 				*bp++ = *lp++;
1111 			} while (*bp != '\0' && bp < buffer + sizeof (buffer));
1112 			bp--;
1113 			break;
1114 		case S4:
1115 			*bp++ = '\0';
1116 			break;
1117 		default:
1118 			*bp++ = '\0';
1119 			break;
1120 		}
1121 		kstate = kstate_next;
1122 
1123 	} while ((bp < buffer + sizeof (buffer)) && kstate != S4);
1124 
1125 	gp = strtok(buffer, " ");
1126 
1127 	while (gp != NULL) {
1128 		if (namecmp(gp, given) > 0) {
1129 			return (1);
1130 		}
1131 		gp = strtok(NULL, " ");
1132 	}
1133 	return (0);
1134 }
1135 
1136 /*
1137  * Perform the character-by-character comparison.
1138  * It is intended that "finger foo" should match "foo2", but an argument
1139  * consisting entirely of digits should not be matched too broadly.
1140  * Also, we do not want "finger foo123" to match "Mr. Foo" in the gecos.
1141  */
1142 int
namecmp(char * name1,char * name2)1143 namecmp(char *name1, char *name2)
1144 {
1145 	char c1, c2;
1146 	boolean_t alphaseen = B_FALSE;
1147 	boolean_t digitseen = B_FALSE;
1148 
1149 	for (;;) {
1150 		c1 = *name1++;
1151 		if (isalpha(c1))
1152 			alphaseen = B_TRUE;
1153 		if (isdigit(c1))
1154 			digitseen = B_TRUE;
1155 		if (isupper(c1))
1156 			c1 = tolower(c1);
1157 
1158 		c2 = *name2++;
1159 		if (isupper(c2))
1160 			c2 = tolower(c2);
1161 
1162 		if (c1 != c2)
1163 			break;
1164 		if (c1 == '\0')
1165 			return (1);
1166 	}
1167 	if (!c1) {
1168 		for (name2--; isdigit(*name2); name2++)
1169 			;
1170 		if (*name2 == '\0' && digitseen) {
1171 			return (1);
1172 		}
1173 	} else if (!c2) {
1174 		for (name1--; isdigit(*name1); name1++)
1175 			;
1176 		if (*name1 == '\0' && alphaseen) {
1177 			return (1);
1178 		}
1179 	}
1180 	return (0);
1181 }
1182 
1183 
1184 int
netfinger(char * name)1185 netfinger(char *name)
1186 {
1187 	char *host;
1188 	struct hostent *hp;
1189 	struct sockaddr_in6 sin6;
1190 	struct in6_addr ipv6addr;
1191 	struct in_addr ipv4addr;
1192 	int s;
1193 	FILE *f;
1194 	int c;
1195 	int lastc;
1196 	char abuf[INET6_ADDRSTRLEN];
1197 	int error_num;
1198 
1199 	if (name == NULL)
1200 		return (0);
1201 	host = strrchr(name, '@');
1202 	if (host == NULL)
1203 		return (0);
1204 	*host++ = 0;
1205 
1206 	if ((hp = getipnodebyname(host, AF_INET6, AI_ALL | AI_ADDRCONFIG |
1207 	    AI_V4MAPPED, &error_num)) == NULL) {
1208 		if (error_num == TRY_AGAIN) {
1209 			(void) fprintf(stderr,
1210 			    "unknown host: %s (try again later)\n", host);
1211 		} else {
1212 			(void) fprintf(stderr, "unknown host: %s\n", host);
1213 		}
1214 		return (1);
1215 	}
1216 
1217 	/*
1218 	 * If hp->h_name is a IPv4-mapped IPv6 literal, we'll convert it to
1219 	 * IPv4 literal address.
1220 	 */
1221 	if ((inet_pton(AF_INET6, hp->h_name, &ipv6addr) > 0) &&
1222 	    IN6_IS_ADDR_V4MAPPED(&ipv6addr)) {
1223 		IN6_V4MAPPED_TO_INADDR(&ipv6addr, &ipv4addr);
1224 		(void) printf("[%s] ", inet_ntop(AF_INET, &ipv4addr, abuf,
1225 		    sizeof (abuf)));
1226 	} else {
1227 		(void) printf("[%s] ", hp->h_name);
1228 	}
1229 	bzero(&sin6, sizeof (sin6));
1230 	sin6.sin6_family = hp->h_addrtype;
1231 	bcopy(hp->h_addr_list[0], (char *)&sin6.sin6_addr, hp->h_length);
1232 	sin6.sin6_port = htons(IPPORT_FINGER);
1233 	s = socket(sin6.sin6_family, SOCK_STREAM, 0);
1234 	if (s < 0) {
1235 		(void) fflush(stdout);
1236 		perror("socket");
1237 		freehostent(hp);
1238 		return (1);
1239 	}
1240 	while (connect(s, (struct sockaddr *)&sin6, sizeof (sin6)) < 0) {
1241 
1242 		if (hp && hp->h_addr_list[1]) {
1243 
1244 			hp->h_addr_list++;
1245 			bcopy(hp->h_addr_list[0],
1246 			    (caddr_t)&sin6.sin6_addr, hp->h_length);
1247 			(void) close(s);
1248 			s = socket(sin6.sin6_family, SOCK_STREAM, 0);
1249 			if (s < 0) {
1250 				(void) fflush(stdout);
1251 				perror("socket");
1252 				freehostent(hp);
1253 				return (0);
1254 			}
1255 			continue;
1256 		}
1257 
1258 		(void) fflush(stdout);
1259 		perror("connect");
1260 		(void) close(s);
1261 		freehostent(hp);
1262 		return (1);
1263 	}
1264 	freehostent(hp);
1265 	hp = NULL;
1266 
1267 	(void) printf("\n");
1268 	if (large)
1269 		(void) write(s, "/W ", 3);
1270 	(void) write(s, name, strlen(name));
1271 	(void) write(s, "\r\n", 2);
1272 	f = fdopen(s, "r");
1273 
1274 	lastc = '\n';
1275 	while ((c = getc(f)) != EOF) {
1276 		/* map CRLF -> newline */
1277 		if ((lastc == '\r') && (c != '\n'))
1278 			/* print out saved CR */
1279 			(void) putchar('\r');
1280 		lastc = c;
1281 		if (c == '\r')
1282 			continue;
1283 		(void) putchar(c);
1284 	}
1285 
1286 	if (lastc != '\n')
1287 		(void) putchar('\n');
1288 	(void) fclose(f);
1289 	return (1);
1290 }
1291 
1292 /*
1293  *	AnyMail - takes a username (string pointer thereto), and
1294  *	prints on standard output whether there is any unread mail,
1295  *	and if so, how old it is.	(JCM@Shasta 15 March 80)
1296  */
1297 void
AnyMail(char * name)1298 AnyMail(char *name)
1299 {
1300 	struct stat buf;		/* space for file status buffer */
1301 	char *mbxdir = MAILDIR; 	/* string with path preamble */
1302 	char *mbxpath;			/* space for entire pathname */
1303 
1304 	char *timestr;
1305 
1306 	mbxpath = malloc(strlen(name) + strlen(MAILDIR) + 1);
1307 	if (mbxpath == NULL)
1308 		return;
1309 
1310 	(void) strcpy(mbxpath, mbxdir);	/* copy preamble into path name */
1311 	(void) strcat(mbxpath, name);	/* concatenate user name to path */
1312 
1313 	if (stat(mbxpath, &buf) == -1 || buf.st_size == 0) {
1314 		/* Mailbox is empty or nonexistent */
1315 		(void) printf("No unread mail\n");
1316 	} else {
1317 		if (buf.st_mtime < buf.st_atime) {
1318 			/*
1319 			 * No new mail since the last time the user read it.
1320 			 */
1321 			(void) printf("Mail last read ");
1322 			(void) printf("%s", ctime(&buf.st_atime));
1323 		} else if (buf.st_mtime > buf.st_atime) {
1324 			/*
1325 			 * New mail has definitely arrived since the last time
1326 			 * mail was read.  mtime is the time the most recent
1327 			 * message arrived; atime is either the time the oldest
1328 			 * unread message arrived, or the last time the mail
1329 			 * was read.
1330 			 */
1331 			(void) printf("New mail received ");
1332 			timestr = ctime(&buf.st_mtime); /* time last modified */
1333 			timestr[24] = '\0';	/* suppress newline (ugh) */
1334 			(void) printf("%s", timestr);
1335 			(void) printf(";\n  unread since ");
1336 			(void) printf("%s", ctime(&buf.st_atime));
1337 		} else {
1338 			/*
1339 			 * There is something in mailbox, but we can't really
1340 			 * be sure whether it is mail held there by the user
1341 			 * or a (single) new message that was placed in a newly
1342 			 * recreated mailbox, so punt and call it "unread mail."
1343 			 */
1344 			(void) printf("Unread mail since ");
1345 			(void) printf("%s", ctime(&buf.st_mtime));
1346 		}
1347 	}
1348 	free(mbxpath);
1349 }
1350 
1351 /*
1352  * return true iff we've already printed project/plan for this uid;
1353  * if not, enter this uid into table (so this function has a side-effect.)
1354  */
1355 #define	PPMAX	4096		/* assume no more than 4096 logged-in users */
1356 uid_t	PlanPrinted[PPMAX+1];
1357 int	PPIndex = 0;		/* index of next unused table entry */
1358 
1359 int
AlreadyPrinted(uid_t uid)1360 AlreadyPrinted(uid_t uid)
1361 {
1362 	int i = 0;
1363 
1364 	while (i++ < PPIndex) {
1365 		if (PlanPrinted[i] == uid)
1366 			return (1);
1367 	}
1368 	if (i < PPMAX) {
1369 		PlanPrinted[i] = uid;
1370 		PPIndex++;
1371 	}
1372 	return (0);
1373 }
1374 
1375 #define	FIFOREADTIMEOUT	(60)	/* read timeout on select */
1376 /* BEGIN CSTYLED */
1377 #define	PRINT_CHAR(c)						\
1378 	(							\
1379 		((termpass & TS_HIGH) && ((int)c) > 126)	\
1380 		||						\
1381 		(isascii((int)c) && 				\
1382 			 (isprint((int)c) || isspace((int)c))	\
1383 		)						\
1384 		||						\
1385 		((termpass & TS_LOW) && ((int)c) < 32)		\
1386 	)
1387 /* END CSTYLED */
1388 
1389 
1390 void
catfile(char * s,mode_t mode,int trunc_at_nl)1391 catfile(char *s, mode_t mode, int trunc_at_nl)
1392 {
1393 	if (S_ISFIFO(mode)) {
1394 		int fd;
1395 
1396 		fd = open(s, O_RDONLY | O_NONBLOCK);
1397 		if (fd != -1) {
1398 			fd_set readfds, exceptfds;
1399 			struct timeval tv;
1400 
1401 			FD_ZERO(&readfds);
1402 			FD_ZERO(&exceptfds);
1403 			FD_SET(fd, &readfds);
1404 			FD_SET(fd, &exceptfds);
1405 
1406 			timerclear(&tv);
1407 			tv.tv_sec = FIFOREADTIMEOUT;
1408 
1409 			(void) fflush(stdout);
1410 			while (select(fd + 1, &readfds, (fd_set *) 0,
1411 			    &exceptfds, &tv) != -1) {
1412 				unsigned char buf[BUFSIZ];
1413 				int nread;
1414 
1415 				nread = read(fd, buf, sizeof (buf));
1416 				if (nread > 0) {
1417 					unsigned char *p;
1418 
1419 					FD_SET(fd, &readfds);
1420 					FD_SET(fd, &exceptfds);
1421 					for (p = buf; p < buf + nread; p++) {
1422 						if (trunc_at_nl && *p == '\n')
1423 							goto out;
1424 						if (PRINT_CHAR(*p))
1425 							(void) putchar((int)*p);
1426 						else if (isascii(*p))
1427 							(void) fputs(unctrl(*p),
1428 							    stdout);
1429 					}
1430 				} else
1431 					break;
1432 			}
1433 out:
1434 			(void) close(fd);
1435 		}
1436 	} else {
1437 		int c;
1438 		FILE *fp;
1439 
1440 		fp = fopen(s, "r");
1441 		if (fp) {
1442 			while ((c = getc(fp)) != EOF) {
1443 				if (trunc_at_nl && c == '\n')
1444 					break;
1445 				if (PRINT_CHAR(c))
1446 					(void) putchar((int)c);
1447 				else
1448 					if (isascii(c))
1449 						(void) fputs(unctrl(c), stdout);
1450 			}
1451 			(void) fclose(fp);
1452 		}
1453 	}
1454 }
1455 
1456 
1457 void
initscreening(void)1458 initscreening(void)
1459 {
1460 	char *options, *value;
1461 
1462 	if (defopen(defaultfile) == 0) {
1463 		char	*cp;
1464 		int	flags;
1465 
1466 		/*
1467 		 * ignore case
1468 		 */
1469 		flags = defcntl(DC_GETFLAGS, 0);
1470 		TURNOFF(flags, DC_CASE);
1471 		(void) defcntl(DC_SETFLAGS, flags);
1472 
1473 		if (cp = defread(passvar)) {
1474 			options = cp;
1475 			while (*options != '\0')
1476 				switch (getsubopt(&options, termopts, &value)) {
1477 				case TERM_LOW:
1478 					termpass |= TS_LOW;
1479 					break;
1480 				case TERM_HIGH:
1481 					termpass |= TS_HIGH;
1482 					break;
1483 				}
1484 		}
1485 		(void) defopen(NULL);	/* close default file */
1486 	}
1487 }
1488 
1489 int
person_compare(const void * p1,const void * p2)1490 person_compare(const void *p1, const void *p2)
1491 {
1492 	const struct person *pp1 = *(struct person **)p1;
1493 	const struct person *pp2 = *(struct person **)p2;
1494 	int r;
1495 
1496 	/*
1497 	 * Sort by username.
1498 	 */
1499 	r = strcmp(pp1->name, pp2->name);
1500 
1501 	if (r != 0)
1502 		return (r);
1503 
1504 	/*
1505 	 * If usernames are the same, sort by idle time.
1506 	 */
1507 	r = pp1->idletime - pp2->idletime;
1508 
1509 	return (r);
1510 }
1511 
1512 void
sort_by_username()1513 sort_by_username()
1514 {
1515 	struct person **sortable, *loop;
1516 	size_t i;
1517 
1518 	sortable = malloc(sizeof (sortable[0]) * nperson);
1519 
1520 	if (sortable == NULL)
1521 		return;
1522 
1523 	for (i = 0, loop = person1; i < nperson; i++) {
1524 		struct person *next = loop->link;
1525 
1526 		sortable[i] = loop;
1527 		loop->link = NULL;
1528 
1529 		loop = next;
1530 	}
1531 
1532 	qsort(sortable, nperson, sizeof (sortable[0]), person_compare);
1533 
1534 	for (i = 1; i < nperson; i++)
1535 		sortable[i-1]->link = sortable[i];
1536 	person1 = sortable[0];
1537 
1538 	free(sortable);
1539 }
1540