![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to finger.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd|
Return to finger.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd |
1.1 root 1:
2: /* This is a finger program. It prints out useful information about users
3: * by digging it up from various system files. It is not very portable
4: * because the most useful parts of the information (the full user name,
5: * office, and phone numbers) are all stored in the VAX-unused gecos field
6: * of /etc/passwd, which, unfortunately, other UNIXes use for other things.
7: *
8: * There are three output formats, all of which give login name, teletype
9: * line number, and login time. The short output format is reminiscent
10: * of finger on ITS, and gives one line of information per user containing
11: * in addition to the minimum basic requirements (MBR), the full name of
12: * the user, his idle time and office location and phone number. The
13: * quick style output is UNIX who-like, giving only name, teletype and
14: * login time. Finally, the long style output give the same information
15: * as the short (in more legible format), the home directory and shell
16: * of the user, and, if it exits, a copy of the file .plan in the users
17: * home directory. Finger may be called with or without a list of people
18: * to finger -- if no list is given, all the people currently logged in
19: * are fingered.
20: *
21: * The program is validly called by one of the following:
22: *
23: * finger {short form list of users}
24: * finger -l {long form list of users}
25: * finger -b {briefer long form list of users}
26: * finger -q {quick list of users}
27: * finger -i {quick list of users with idle times}
28: * finger namelist {long format list of specified users}
29: * finger -s namelist {short format list of specified users}
30: * finger -w namelist {narrow short format list of specified users}
31: *
32: * where 'namelist' is a list of users login names.
33: * The other options can all be given after one '-', or each can have its
34: * own '-'. The -f option disables the printing of headers for short and
35: * quick outputs. The -b option briefens long format outputs. The -p
36: * option turns off plans for long format outputs.
37: */
38:
39: #include <sys/types.h>
40: #include <sys/stat.h>
41: #include <sgtty.h>
42: #include <utmp.h>
43: #include <signal.h>
44: #include <pwd.h>
45: #include <stdio.h>
46: #include <sccs.h>
47: #include <lastlog.h>
48: #include <time.h>
49:
50: #define ASTERISK '*' /* ignore this in real name */
51: #define BLANK ' ' /* blank character (i.e. space) */
52: #define CAPITALIZE 0137& /* capitalize character macro */
53: #define COMMA ',' /* separator in pw_gecos field */
54: #define COMMAND '-' /* command line flag char */
55: #define CORY 'C' /* cory hall office */
56: #define EVANS 'E' /* evans hall office */
57: #define LINEBREAK 012 /* line feed */
58: #define NULLSTR "" /* the null string, opposed to NULL */
59: #define SAMENAME '&' /* repeat login name in real name */
60: #define TALKABLE 0222 /* tty is writeable if 222 mode */
61:
62: struct person { /* one for each person fingered */
63: char name[ 9 ]; /* login name */
64: char tty[ 9 ]; /* NULL terminated tty line */
65: long loginat; /* time of login (possibly last) */
66: long idletime; /* how long idle (if logged in) */
67: short int loggedin; /* flag for being logged in */
68: short int writeable; /* flag for tty being writeable */
69: char *realname; /* pointer to full name */
70: char *office; /* pointer to office name */
71: char *officephone; /* pointer to office phone no. */
72: char *homephone; /* pointer to home phone no. */
73: char *random; /* for any random stuff in pw_gecos */
74: struct passwd *pwd; /* structure of /etc/passwd stuff */
75: struct person *link; /* link to next person */
76: };
77:
78: struct passwd *NILPWD = 0;
79: struct person *NILPERS = 0;
80:
81: int persize = sizeof( struct person );
82: int pwdsize = sizeof( struct passwd );
83:
84: char LASTLOG[] = "/usr/adm/lastlog"; /* last login info */
85: char USERLOG[] = "/etc/utmp"; /* who is logged in */
86: char outbuf[BUFSIZ]; /* output buffer */
87: char *ctime();
88:
89: int unbrief = 1; /* -b option default */
90: int header = 1; /* -f option default */
91: int hack = 1; /* -h option default */
92: int idle = 0; /* -i option default */
93: int large = 0; /* -l option default */
94: int match = 1; /* -m option default */
95: int plan = 1; /* -p option default */
96: int unquick = 1; /* -q option default */
97: int small = 0; /* -s option default */
98: int wide = 1; /* -w option default */
99:
100: int lf;
101: int llopenerr;
102:
103: long tloc; /* current time */
104:
105:
106:
107: main( argc, argv )
108:
109: int argc;
110: char *argv[];
111:
112: {
113: FILE *fp, *fopen(); /* for plans */
114: struct passwd *getpwent(); /* read /etc/passwd */
115: struct person *person1, *p, *pend; /* people */
116: struct passwd *pw; /* temporary */
117: struct utmp user; /* ditto */
118: char *malloc();
119: char *s, *pn, *ln;
120: char c;
121: char *PLAN = "/.plan"; /* what plan file is */
122: char *PROJ = "/.project"; /* what project file */
123: int PLANLEN = strlen( PLAN );
124: int PROJLEN = strlen( PROJ );
125: int numnames = 0;
126: int orgnumnames;
127: int uf;
128: int usize = sizeof user;
129: int unshort;
130: int i, j;
131: int fngrlogin;
132:
133: setbuf( stdout, outbuf ); /* buffer output */
134:
135: /* parse command line for (optional) arguments */
136:
137: i = 1;
138: if( strcmp( *argv, "sh" ) ) {
139: fngrlogin = 0;
140: while( i++ < argc && (*++argv)[0] == COMMAND ) {
141: for( s = argv[0] + 1; *s != NULL; s++ ) {
142: switch (*s) {
143:
144: case 'b':
145: unbrief = 0;
146: break;
147:
148: case 'f':
149: header = 0;
150: break;
151:
152: case 'h':
153: hack = 0;
154: break;
155:
156: case 'i':
157: idle = 1;
158: unquick = 0;
159: break;
160:
161: case 'l':
162: large = 1;
163: break;
164:
165: case 'm':
166: match = 0;
167: break;
168:
169: case 'p':
170: plan = 0;
171: break;
172:
173: case 'q':
174: unquick = 0;
175: break;
176:
177: case 's':
178: small = 1;
179: break;
180:
181: case 'w':
182: wide = 0;
183: break;
184:
185: default:
186: fprintf( stderr, "finger: Usage -- 'finger [-bfhilmpqsw] [login1 [login2 ...] ]'\n" );
187: exit( 1 );
188: }
189: }
190: }
191: }
192: else {
193: fngrlogin = 1;
194: }
195: if( unquick ) {
196: time( &tloc );
197: }
198: else {
199: if( idle ) {
200: time( &tloc );
201: }
202: }
203:
204: /* i > argc means no login names given so get them by reading USERLOG */
205:
206: if( (i > argc) || fngrlogin ) {
207: unshort = large;
208: if( ( uf = open(USERLOG, 0) ) >= 0 ) {
209: user.ut_name[0] = NULL;
210: while( user.ut_name[0] == NULL ) {
211: if( read( uf, (char *) &user, usize ) != usize ) {
212: printf( "\nNo one logged on\n" );
213: exit( 0 );
214: }
215: }
216: person1 = (struct person *) malloc( persize );
217: for( j = 0; j < 8; j++ ) {
218: person1->tty[j] = user.ut_line[j];
219: person1->name[j] = user.ut_name[j];
220: }
221: person1->name[8] = NULL;
222: person1->tty[8] = NULL;
223: person1->loginat = user.ut_time;
224: person1->pwd = NILPWD;
225: person1->loggedin = 1;
226: numnames++;
227: p = person1;
228: while( read( uf, (char *) &user, usize ) == usize ) {
229: if( user.ut_name[0] == NULL ) continue;
230: p->link = (struct person *) malloc( persize );
231: p = p->link;
232: for( j = 0; j < 8; j++ ) {
233: p->tty[j] = user.ut_line[j];
234: p->name[j] = user.ut_name[j];
235: }
236: p->name[8] = NULL;
237: p->tty[8] = NULL;
238: p->loginat = user.ut_time;
239: p->pwd = NILPWD;
240: p->loggedin = 1;
241: numnames++;
242: }
243: p->link = NILPERS;
244: close( uf );
245: }
246: else {
247: fprintf( stderr, "finger: error opening %s\n", USERLOG );
248: exit( 2 );
249: }
250:
251: /* if we are doing it, read /etc/passwd for the useful info */
252:
253: if( unquick ) {
254: setpwent();
255: fwopen();
256: i = numnames;
257: while( ( (pw = getpwent()) != NILPWD ) && ( i > 0 ) ) {
258: p = person1;
259: do {
260: if( p->pwd == NILPWD ) {
261: if( strcmp( p->name, pw->pw_name ) == 0 ) {
262: p->pwd = (struct passwd *) malloc( pwdsize );
263: pwdcopy( p->pwd, pw );
264: decode( p );
265: i--;
266: }
267: }
268: p = p->link;
269: } while( p != NILPERS );
270: }
271: fwclose();
272: endpwent();
273: }
274: }
275:
276: /* get names from command line and check to see if they're logged in */
277:
278: else {
279: unshort = ( small == 1 ? 0 : 1 );
280: i++;
281: person1 = (struct person *) malloc( persize );
282: strcpy( person1->name, (argv++)[ 0 ] );
283: person1->loggedin = 0;
284: person1->pwd = NILPWD;
285: numnames++;
286: p = person1;
287: while( i++ <= argc ) {
288: p->link = (struct person *) malloc( persize );
289: p = p->link;
290: strcpy( p->name, (argv++)[ 0 ] );
291: p->loggedin = 0;
292: p->pwd = NILPWD;
293: numnames++;
294: }
295: p->link = NILPERS;
296: pend = p;
297:
298: /* if we are doing it, read /etc/passwd for the useful info */
299:
300: orgnumnames = numnames;
301: if( unquick ) {
302: setpwent();
303: while( ( pw = getpwent() ) != NILPWD ) {
304: p = person1;
305: i = 0;
306: do {
307: if( strcmp( p->name, pw->pw_name ) == 0 ||
308: matchcmp( pw->pw_gecos, pw->pw_name, p->name ) ) {
309: if( p->pwd == NILPWD ) {
310: p->pwd = (struct passwd *) malloc( pwdsize );
311: pwdcopy( p->pwd, pw );
312: }
313: else {
314: pend->link = (struct person *) malloc(persize);
315: pend = pend->link;
316: pend->link = NILPERS;
317: strcpy( pend->name, p->name );
318: pend->pwd = (struct passwd *) malloc(pwdsize);
319: pwdcopy( pend->pwd, pw );
320: numnames++;
321: }
322: }
323: p = p->link;
324: } while( ++i < orgnumnames );
325: }
326: endpwent();
327: }
328:
329: /* Now get login information */
330:
331: if( ( uf = open(USERLOG, 0) ) >= 0 ) {
332: while( read( uf, (char *) &user, usize ) == usize ) {
333: if( user.ut_name[0] == NULL ) continue;
334: p = person1;
335: do {
336: pw = p->pwd;
337: if( pw == NILPWD ) {
338: p = p->link;
339: continue;
340: }
341: i = 0;
342: while((i < 8) && (pw->pw_name[i] == user.ut_name[i])) {
343: if( pw->pw_name[i] == NULL ) {
344: i = 8;
345: break;
346: }
347: i++;
348: }
349: if( i == 8 ) {
350: if( p->loggedin == 1 ) {
351: pend->link = (struct person *) malloc(persize);
352: pend = pend->link;
353: pend->link = NILPERS;
354: strcpy( pend->name, p->name );
355: for( j = 0; j < 8; j++ ) {
356: pend->tty[j] = user.ut_line[j];
357: }
358: pend->tty[ 8 ] = NULL;
359: pend->loginat = user.ut_time;
360: pend->loggedin = 2;
361: pend->pwd = (struct passwd *) malloc(pwdsize);
362: pwdcopy( pend->pwd, pw );
363: numnames++;
364: }
365: else {
366: if( p->loggedin != 2 ) {
367: for( j = 0; j < 8; j++ ) {
368: p->tty[j] = user.ut_line[j];
369: }
370: p->tty[ 8 ] = NULL;
371: p->loginat = user.ut_time;
372: p->loggedin = 1;
373: }
374: }
375: }
376: p = p->link;
377: } while( p != NILPERS );
378: }
379: fwopen();
380: p = person1;
381: while( p != NILPERS ) {
382: if( p->loggedin == 2 ) {
383: p->loggedin = 1;
384: }
385: decode( p );
386: p = p->link;
387: }
388: fwclose();
389: close( uf );
390: }
391: else {
392: fprintf( stderr, "finger: error opening %s\n", USERLOG );
393: exit( 2 );
394: }
395: }
396:
397: /* print out what we got */
398:
399: if( header ) {
400: if( unquick ) {
401: if( !unshort ) {
402: if( wide ) {
403: printf(
404: "Login Name TTY Idle When Office\n" );
405: }
406: else {
407: printf(
408: "Login TTY Idle When Office\n" );
409: }
410: }
411: }
412: else {
413: printf( "Login TTY When" );
414: if( idle ) {
415: printf( " Idle" );
416: }
417: printf( "\n" );
418: }
419: }
420: p = person1;
421: do {
422: if( unquick ) {
423: if( unshort ) {
424: personprint( p );
425: if( p->pwd != NILPWD ) {
426: if( hack ) {
427: s = malloc(strlen((p->pwd)->pw_dir) + PROJLEN + 1 );
428: strcpy( s, (p->pwd)->pw_dir );
429: strcat( s, PROJ );
430: if( ( fp = fopen( s, "r") ) != NULL ) {
431: printf( "Project: " );
432: while( ( c = getc(fp) ) != EOF ) {
433: if( c == LINEBREAK ) {
434: break;
435: }
436: putc( c, stdout );
437: }
438: fclose( fp );
439: printf( "\n" );
440: }
441: }
442: if( plan ) {
443: s = malloc( strlen( (p->pwd)->pw_dir ) + PLANLEN + 1 );
444: strcpy( s, (p->pwd)->pw_dir );
445: strcat( s, PLAN );
446: if( ( fp = fopen( s, "r") ) == NULL ) {
447: printf( "No Plan.\n" );
448: }
449: else {
450: printf( "Plan:\n" );
451: while( ( c = getc(fp) ) != EOF ) {
452: putc( c, stdout );
453: }
454: fclose( fp );
455: }
456: }
457: }
458: if( p->link != NILPERS ) {
459: printf( "\n" );
460: }
461: }
462: else {
463: shortprint( p );
464: }
465: }
466: else {
467: quickprint( p );
468: }
469: p = p->link;
470: } while( p != NILPERS );
471: exit(1);
472: }
473:
474:
475: /* given a pointer to a pwd (pfrom) copy it to another one, allocating
476: * space for all the stuff in it. Note: Only the useful (what the
477: * program currently uses) things are copied.
478: */
479:
480: pwdcopy( pto, pfrom ) /* copy relevant fields only */
481:
482: struct passwd *pto, *pfrom;
483: {
484: pto->pw_name = malloc( strlen( pfrom->pw_name ) + 1 );
485: strcpy( pto->pw_name, pfrom->pw_name );
486: pto->pw_uid = pfrom->pw_uid;
487: pto->pw_gecos = malloc( strlen( pfrom->pw_gecos ) + 1 );
488: strcpy( pto->pw_gecos, pfrom->pw_gecos );
489: pto->pw_dir = malloc( strlen( pfrom->pw_dir ) + 1 );
490: strcpy( pto->pw_dir, pfrom->pw_dir );
491: pto->pw_shell = malloc( strlen( pfrom->pw_shell ) + 1 );
492: strcpy( pto->pw_shell, pfrom->pw_shell );
493: }
494:
495:
496: /* print out information on quick format giving just name, tty, login time
497: * and idle time if idle is set.
498: */
499:
500: quickprint( pers )
501:
502: struct person *pers;
503: {
504: int idleprinted;
505:
506: printf( "%-8.8s", pers->name );
507: printf( " " );
508: if( pers->loggedin ) {
509: if( idle ) {
510: findidle( pers );
511: if( pers->writeable ) {
512: printf( " %-8.8s %-16.16s",
513: pers->tty, ctime( &pers->loginat ) );
514: }
515: else {
516: printf( "*%-8.8s %-16.16s",
517: pers->tty, ctime( &pers->loginat ) );
518: }
519: printf( " " );
520: idleprinted = ltimeprint( &pers->idletime );
521: }
522: else {
523: printf( " %-8.8s %-16.16s",
524: pers->tty, ctime( &pers->loginat ) );
525: }
526: }
527: else {
528: printf( " Not Logged In" );
529: }
530: printf( "\n" );
531: }
532:
533:
534: /* print out information in short format, giving login name, full name,
535: * tty, idle time, login time, office location and phone.
536: */
537:
538: shortprint( pers )
539:
540: struct person *pers;
541:
542: {
543: struct passwd *pwdt = pers->pwd;
544: char buf[ 26 ];
545: int i, len, offset, dialup;
546:
547: if( pwdt == NILPWD ) {
548: printf( "%-8.8s", pers->name );
549: printf( " ???\n" );
550: return;
551: }
552: printf( "%-8.8s", pwdt->pw_name );
553: dialup = 0;
554: if( wide ) {
555: if( strlen( pers->realname ) > 0 ) {
556: printf( " %-20.20s", pers->realname );
557: }
558: else {
559: printf( " ??? " );
560: }
561: }
562: if( pers->loggedin ) {
563: if( pers->writeable ) {
564: printf( " " );
565: }
566: else {
567: printf( " *" );
568: }
569: }
570: else {
571: printf( " " );
572: }
573: if( strlen( pers->tty ) > 0 ) {
574: strcpy( buf, pers->tty );
575: if( (buf[0] == 't') && (buf[1] == 't') && (buf[2] == 'y') ) {
576: offset = 3;
577: for( i = 0; i < 2; i++ ) {
578: buf[i] = buf[i + offset];
579: }
580: }
581: if( (buf[0] == 'd') && pers->loggedin ) {
582: dialup = 1;
583: }
584: printf( "%-2.2s ", buf );
585: }
586: else {
587: printf( " " );
588: }
589: strcpy( buf, ctime( &pers->loginat ) );
590: if( pers->loggedin ) {
591: stimeprint( &pers->idletime );
592: offset = 7;
593: for( i = 4; i < 19; i++ ) {
594: buf[i] = buf[i + offset];
595: }
596: printf( " %-9.9s ", buf );
597: }
598: else {
599: printf( " " );
600: offset = 4;
601: for( i = 0; i <22; i++ ) {
602: buf[i] = buf[i + offset];
603: }
604: printf( "<%-12.12s>", buf );
605: }
606: len = strlen( pers->homephone );
607: if( dialup && (len > 0) ) {
608: if( len == 8 ) {
609: printf( " " );
610: }
611: else {
612: if( len == 12 ) {
613: printf( " " );
614: }
615: else {
616: for( i = 1; i <= 21 - len; i++ ) {
617: printf( " " );
618: }
619: }
620: }
621: printf( "%s", pers->homephone );
622: }
623: else {
624: if( strlen( pers->office ) > 0 ) {
625: printf( " %-11.11s", pers->office );
626: if( strlen( pers->officephone ) > 0 ) {
627: printf( " %8.8s", pers->officephone );
628: }
629: else {
630: if( len == 8 ) {
631: printf( " %8.8s", pers->homephone );
632: }
633: }
634: }
635: else {
636: if( strlen( pers->officephone ) > 0 ) {
637: printf( " %8.8s", pers->officephone );
638: }
639: else {
640: if( len == 8 ) {
641: printf( " %8.8s", pers->homephone );
642: }
643: else {
644: if( len == 12 ) {
645: printf( " %12.12s", pers->homephone );
646: }
647: }
648: }
649: }
650: }
651: printf( "\n" );
652: }
653:
654:
655: /* print out a person in long format giving all possible information.
656: * directory and shell are inhibited if unbrief is clear.
657: */
658:
659: personprint( pers )
660:
661: struct person *pers;
662:
663: {
664: struct passwd *pwdt = pers->pwd;
665: int idleprinted;
666:
667: if( pwdt == NILPWD ) {
668: printf( "Login name: %-10s", pers->name );
669: printf( " " );
670: printf( "In real life: ???\n");
671: return;
672: }
673: printf( "Login name: %-10s", pwdt->pw_name );
674: if( pers->loggedin ) {
675: if( pers->writeable ) {
676: printf( " " );
677: }
678: else {
679: printf( " (messages off) " );
680: }
681: }
682: else {
683: printf( " " );
684: }
685: if( strlen( pers->realname ) > 0 ) {
686: printf( "In real life: %-s", pers->realname );
687: }
688: if( strlen( pers->office ) > 0 ) {
689: printf( "\nOffice: %-.11s", pers->office );
690: if( strlen( pers->officephone ) > 0 ) {
691: printf( ", %s", pers->officephone );
692: if( strlen( pers->homephone ) > 0 ) {
693: printf( " Home phone: %s", pers->homephone );
694: }
695: else {
696: if( strlen( pers->random ) > 0 ) {
697: printf( " %s", pers->random );
698: }
699: }
700: }
701: else {
702: if( strlen( pers->homephone ) > 0 ) {
703: printf(" Home phone: %s",pers->homephone);
704: }
705: if( strlen( pers->random ) > 0 ) {
706: printf( " %s", pers->random );
707: }
708: }
709: }
710: else {
711: if( strlen( pers->officephone ) > 0 ) {
712: printf( "\nPhone: %s", pers->officephone );
713: if( strlen( pers->homephone ) > 0 ) {
714: printf( "\n, %s", pers->homephone );
715: if( strlen( pers->random ) > 0 ) {
716: printf( ", %s", pers->random );
717: }
718: }
719: else {
720: if( strlen( pers->random ) > 0 ) {
721: printf( "\n, %s", pers->random );
722: }
723: }
724: }
725: else {
726: if( strlen( pers->homephone ) > 0 ) {
727: printf( "\nPhone: %s", pers->homephone );
728: if( strlen( pers->random ) > 0 ) {
729: printf( "%s", pers->random );
730: }
731: }
732: else {
733: if( strlen( pers->random ) > 0 ) {
734: printf( "\n%s", pers->random );
735: }
736: }
737: }
738: }
739: if( unbrief ) {
740: printf( "\n" );
741: printf( "Directory: %-25s", pwdt->pw_dir );
742: if( strlen( pwdt->pw_shell ) > 0 ) {
743: printf( " Shell: %-s", pwdt->pw_shell );
744: }
745: }
746: if( pers->loggedin ) {
747: register char *ep = ctime( &pers->loginat );
748: printf("\nOn since %15.15s on %-8.8s ", &ep[4], pers->tty );
749: idleprinted = ltimeprint( &pers->idletime );
750: if( idleprinted ) {
751: printf( " Idle Time" );
752: }
753: }
754: else {
755: register char *ep = ctime( &pers->loginat );
756: printf("\nLast login %16.16s on %.8s", ep, pers->tty );
757: }
758: printf( "\n" );
759: }
760:
761:
762: /*
763: * very hacky section of code to print phone numbers. filled with
764: * magic constants like 4, 7 and 10.
765: */
766:
767: char *phone( s, len )
768:
769: char *s;
770: int len;
771: {
772: char *strsave();
773: char fonebuf[ 15 ];
774: int i;
775:
776: switch (len) {
777:
778: case 4:
779: fonebuf[ 0 ] = ' ';
780: fonebuf[ 1 ] = 'x';
781: fonebuf[ 2 ] = '2';
782: fonebuf[ 3 ] = '-';
783: for( i = 0; i <= 3; i++ ) {
784: fonebuf[ 4 + i ] = *s++;
785: }
786: fonebuf[ 8 ] = NULL;
787: return( strsave( &fonebuf[0] ) );
788: break;
789:
790: case 7:
791: for( i = 0; i <= 2; i++ ) {
792: fonebuf[ i ] = *s++;
793: }
794: fonebuf[ 3 ] = '-';
795: for( i = 0; i <= 3; i++ ) {
796: fonebuf[ 4 + i ] = *s++;
797: }
798: fonebuf[ 8 ] = NULL;
799: return( strsave( &fonebuf[0] ) );
800: break;
801:
802: case 10:
803: for( i = 0; i <= 2; i++ ) {
804: fonebuf[ i ] = *s++;
805: }
806: fonebuf[ 3 ] = '-';
807: for( i = 0; i <= 2; i++ ) {
808: fonebuf[ 4 + i ] = *s++;
809: }
810: fonebuf[ 7 ] = '-';
811: for( i = 0; i <= 3; i++ ) {
812: fonebuf[ 8 + i ] = *s++;
813: }
814: fonebuf[ 12 ] = NULL;
815: return( strsave( &fonebuf[0] ) );
816: break;
817:
818: default:
819: fprintf( stderr, "finger: error in phone numbering\n" );
820: return( strsave(s) );
821: break;
822: }
823: }
824:
825:
826: /* decode the information in the gecos field of /etc/passwd
827: * another hacky section of code, but given the format the stuff is in...
828: */
829:
830: decode( pers )
831:
832: struct person *pers;
833:
834: {
835: struct passwd *pwdt = pers->pwd;
836: char buffer[ 40 ], *bp, *gp, *lp;
837: char *phone();
838: int alldigits;
839: int len;
840: int i;
841:
842: pers->realname = NULLSTR;
843: pers->office = NULLSTR;
844: pers->officephone = NULLSTR;
845: pers->homephone = NULLSTR;
846: pers->random = NULLSTR;
847: if( pwdt != NILPWD ) {
848: gp = pwdt->pw_gecos;
849: bp = &buffer[ 0 ];
850: if( *gp == ASTERISK ) {
851: gp++;
852: }
853: while( (*gp != NULL) && (*gp != COMMA) ) {
854: if( *gp == SAMENAME ) {
855: lp = pwdt->pw_name;
856: *bp++ = CAPITALIZE(*lp++);
857: while( *lp != NULL ) {
858: *bp++ = *lp++;
859: }
860: }
861: else {
862: *bp++ = *gp;
863: }
864: gp++;
865: }
866: *bp = NULL;
867: pers->realname = malloc( strlen( &buffer[0] ) + 1 );
868: strcpy( pers->realname, &buffer[0] );
869: if( *gp++ == COMMA ) {
870: alldigits = 1;
871: bp = &buffer[ 0 ];
872: while( (*gp != NULL) && (*gp != COMMA) ) {
873: *bp = *gp++;
874: alldigits = alldigits && ('0' <= *bp) && (*bp <= '9');
875: bp++;
876: }
877: *bp = NULL;
878: len = strlen( &buffer[0] );
879: if( buffer[ len - 1 ] == CORY ) {
880: strcpy( &buffer[ len - 1 ], " Cory" );
881: pers->office = malloc( len + 5 );
882: strcpy( pers->office, &buffer[0] );
883: }
884: else {
885: if( buffer[ len - 1 ] == EVANS ) {
886: strcpy( &buffer[ len - 1 ], " Evans" );
887: pers->office = malloc( len + 6 );
888: strcpy( pers->office, &buffer[0] );
889: }
890: else {
891: if( buffer[ len - 1 ] == 'L' ) {
892: strcpy( &buffer[ len - 3 ], " LBL" );
893: pers->office = malloc( len + 2 );
894: strcpy( pers->office, &buffer[0] );
895: }
896: else {
897: if( alldigits ) {
898: if( len == 4 ) {
899: pers->officephone = phone(&buffer[0], len);
900: }
901: else {
902: if( (len == 7) || (len == 10) ) {
903: pers->homephone = phone(&buffer[0],len);
904: }
905: }
906: }
907: else {
908: pers->random = malloc( len + 1 );
909: strcpy( pers->random, &buffer[0] );
910: }
911: }
912: }
913: }
914: if( *gp++ == COMMA ) {
915: bp = &buffer[ 0 ];
916: alldigits = 1;
917: while( (*gp != NULL) && (*gp != COMMA) ) {
918: *bp = *gp++;
919: alldigits = alldigits && ('0' <= *bp) && (*bp <= '9');
920: bp++;
921: }
922: *bp = NULL;
923: len = strlen( &buffer[0] );
924: if( alldigits ) {
925: if( len != 4 ) {
926: if( (len == 7) || (len == 10) ) {
927: pers->homephone = phone( &buffer[0], len );
928: }
929: else {
930: pers->random = malloc( len + 1 );
931: strcpy( pers->random, &buffer[0] );
932: }
933: }
934: else {
935: pers->officephone = phone( &buffer[0], len );
936: }
937: }
938: else {
939: pers->random = malloc( len + 1 );
940: strcpy( pers->random, &buffer[0] );
941: }
942: if( *gp++ == COMMA ) {
943: bp = &buffer[ 0 ];
944: alldigits = 1;
945: while( (*gp != NULL) && (*gp != COMMA) ) {
946: *bp = *gp++;
947: alldigits = alldigits && ('0' <= *bp) &&
948: (*bp <= '9');
949: bp++;
950: }
951: *bp = NULL;
952: len = strlen( &buffer[0] );
953: if( alldigits && ( (len == 7) || (len == 10) ) ) {
954: if( pers->homephone != NULL ) {
955: pers->officephone = pers->homephone;
956: }
957: pers->homephone = phone( &buffer[0], len );
958: }
959: else {
960: pers->random = malloc( strlen( &buffer[0] ) + 1 );
961: strcpy( pers->random, &buffer[0] );
962: }
963: }
964: }
965: }
966: if( pers->loggedin == 0 ) {
967: findwhen( pers );
968: }
969: else {
970: findidle( pers );
971: }
972: }
973: }
974:
975:
976: /* find the last log in of a user by checking the LASTLOG file.
977: * the entry is indexed by the uid, so this can only be done if
978: * the uid is known (which it isn't in quick mode)
979: */
980:
981: fwopen()
982: {
983: if( ( lf = open(LASTLOG, 0) ) >= 0 ) {
984: llopenerr = 0;
985: }
986: else {
987: fprintf( stderr, "finger: lastlog open error\n" );
988: llopenerr = 1;
989: }
990: }
991:
992:
993: findwhen( pers )
994:
995: struct person *pers;
996: {
997: struct passwd *pwdt = pers->pwd;
998: struct lastlog ll;
999: int llsize = sizeof ll;
1000: int i;
1001:
1002: if( !llopenerr ) {
1003: lseek( lf, pwdt->pw_uid*llsize, 0 );
1004: if( read( lf, (char *) &ll, llsize ) == llsize ) {
1005: for( i = 0; i < 8; i++ ) {
1006: pers->tty[ i ] = ll.ll_line[ i ];
1007: }
1008: pers->tty[ 8 ] = NULL;
1009: pers->loginat = ll.ll_time;
1010: }
1011: else {
1012: fprintf( stderr, "finger: lastlog read error\n" );
1013: pers->tty[ 0 ] = NULL;
1014: pers->loginat = 0L;
1015: }
1016: }
1017: else {
1018: pers->tty[ 0 ] = NULL;
1019: pers->loginat = 0L;
1020: }
1021: }
1022:
1023:
1024: fwclose()
1025: {
1026: if( !llopenerr ) {
1027: close( lf );
1028: }
1029: }
1030:
1031:
1032: /* find the idle time of a user by doing a stat on /dev/histty,
1033: * where histty has been gotten from USERLOG, supposedly.
1034: */
1035:
1036: findidle( pers )
1037:
1038: struct person *pers;
1039: {
1040: struct stat ttystatus;
1041: struct passwd *pwdt = pers->pwd;
1042: char buffer[ 20 ];
1043: char *TTY = "/dev/";
1044: int TTYLEN = strlen( TTY );
1045: int i;
1046:
1047: strcpy( &buffer[0], TTY );
1048: i = 0;
1049: do {
1050: buffer[ TTYLEN + i ] = pers->tty[ i ];
1051: } while( ++i <= 8 );
1052: if( stat( &buffer[0], &ttystatus ) >= 0 ) {
1053: time( &tloc );
1054: if( tloc < ttystatus.st_atime ) {
1055: pers->idletime = 0L;
1056: }
1057: else {
1058: pers->idletime = tloc - ttystatus.st_atime;
1059: }
1060: if( (ttystatus.st_mode & TALKABLE) == TALKABLE ) {
1061: pers->writeable = 1;
1062: }
1063: else {
1064: pers->writeable = 0;
1065: }
1066: }
1067: else {
1068: fprintf( stderr, "finger: error STATing %s\n", &buffer[0] );
1069: exit( 4 );
1070: }
1071: }
1072:
1073:
1074: /* print idle time in short format; this program always prints 4 characters;
1075: * if the idle time is zero, it prints 4 blanks.
1076: */
1077:
1078: stimeprint( dt )
1079:
1080: long *dt;
1081: {
1082: struct tm *gmtime();
1083: struct tm *delta;
1084:
1085: delta = gmtime( dt );
1086: if( delta->tm_yday == 0 ) {
1087: if( delta->tm_hour == 0 ) {
1088: if( delta->tm_min >= 10 ) {
1089: printf( " %2.2d ", delta->tm_min );
1090: }
1091: else {
1092: if( delta->tm_min == 0 ) {
1093: printf( " " );
1094: }
1095: else {
1096: printf( " %1.1d ", delta->tm_min );
1097: }
1098: }
1099: }
1100: else {
1101: if( delta->tm_hour >= 10 ) {
1102: printf( "%3.3d:", delta->tm_hour );
1103: }
1104: else {
1105: printf( "%1.1d:%02.2d", delta->tm_hour, delta->tm_min );
1106: }
1107: }
1108: }
1109: else {
1110: printf( "%3dd", delta->tm_yday );
1111: }
1112: }
1113:
1114:
1115: /* print idle time in long format with care being taken not to pluralize
1116: * 1 minutes or 1 hours or 1 days.
1117: */
1118:
1119: ltimeprint( dt )
1120:
1121: long *dt;
1122: {
1123: struct tm *gmtime();
1124: struct tm *delta;
1125: int printed = 1;
1126:
1127: delta = gmtime( dt );
1128: if( delta->tm_yday == 0 ) {
1129: if( delta->tm_hour == 0 ) {
1130: if( delta->tm_min >= 10 ) {
1131: printf( "%2d minutes", delta->tm_min );
1132: }
1133: else {
1134: if( delta->tm_min == 0 ) {
1135: if( delta->tm_sec > 10 ) {
1136: printf( "%2d seconds", delta->tm_sec );
1137: }
1138: else {
1139: printed = 0;
1140: }
1141: }
1142: else {
1143: if( delta->tm_min == 1 ) {
1144: if( delta->tm_sec == 1 ) {
1145: printf( "%1d minute %1d second",
1146: delta->tm_min, delta->tm_sec );
1147: }
1148: else {
1149: printf( "%1d minute %d seconds",
1150: delta->tm_min, delta->tm_sec );
1151: }
1152: }
1153: else {
1154: if( delta->tm_sec == 1 ) {
1155: printf( "%1d minutes %1d second",
1156: delta->tm_min, delta->tm_sec );
1157: }
1158: else {
1159: printf( "%1d minutes %d seconds",
1160: delta->tm_min, delta->tm_sec );
1161: }
1162: }
1163: }
1164: }
1165: }
1166: else {
1167: if( delta->tm_hour >= 10 ) {
1168: printf( "%2d hours", delta->tm_hour );
1169: }
1170: else {
1171: if( delta->tm_hour == 1 ) {
1172: if( delta->tm_min == 1 ) {
1173: printf( "%1d hour %1d minute",
1174: delta->tm_hour, delta->tm_min );
1175: }
1176: else {
1177: printf( "%1d hour %2d minutes",
1178: delta->tm_hour, delta->tm_min );
1179: }
1180: }
1181: else {
1182: if( delta->tm_min == 1 ) {
1183: printf( "%1d hours %1d minute",
1184: delta->tm_hour, delta->tm_min );
1185: }
1186: else {
1187: printf( "%1d hours %2d minutes",
1188: delta->tm_hour, delta->tm_min );
1189: }
1190: }
1191: }
1192: }
1193: }
1194: else {
1195: if( delta->tm_yday >= 10 ) {
1196: printf( "%2d days", delta->tm_yday );
1197: }
1198: else {
1199: if( delta->tm_yday == 1 ) {
1200: if( delta->tm_hour == 1 ) {
1201: printf( "%1d day %1d hour",
1202: delta->tm_yday, delta->tm_hour );
1203: }
1204: else {
1205: printf( "%1d day %2d hours",
1206: delta->tm_yday, delta->tm_hour );
1207: }
1208: }
1209: else {
1210: if( delta->tm_hour == 1 ) {
1211: printf( "%1d days %1d hour",
1212: delta->tm_yday, delta->tm_hour );
1213: }
1214: else {
1215: printf( "%1d days %2d hours",
1216: delta->tm_yday, delta->tm_hour );
1217: }
1218: }
1219: }
1220: }
1221: return( printed );
1222: }
1223:
1224:
1225: matchcmp( gname, login, given )
1226:
1227: char *gname;
1228: char *login;
1229: char *given;
1230: {
1231: char buffer[ 20 ];
1232: char c;
1233: int flag, i, unfound;
1234:
1235: if( !match ) {
1236: return( 0 );
1237: }
1238: else {
1239: if( namecmp( login, given ) ) {
1240: return( 1 );
1241: }
1242: else {
1243: if( *gname == ASTERISK ) {
1244: gname++;
1245: }
1246: flag = 1;
1247: i = 0;
1248: unfound = 1;
1249: while( unfound ) {
1250: if( flag ) {
1251: c = *gname++;
1252: if( c == SAMENAME ) {
1253: flag = 0;
1254: c = *login++;
1255: }
1256: else {
1257: unfound = (*gname != COMMA) && (*gname != NULL);
1258: }
1259: }
1260: else {
1261: c = *login++;
1262: if( c == NULL ) {
1263: if( (*gname == COMMA) || (*gname == NULL) ) {
1264: break;
1265: }
1266: else {
1267: flag = 1;
1268: continue;
1269: }
1270: }
1271: }
1272: if( c == BLANK ) {
1273: buffer[i++] = NULL;
1274: if( namecmp( buffer, given ) ) {
1275: return( 1 );
1276: }
1277: i = 0;
1278: flag = 1;
1279: }
1280: else {
1281: buffer[ i++ ] = c;
1282: }
1283: }
1284: buffer[i++] = NULL;
1285: if( namecmp( buffer, given ) ) {
1286: return( 1 );
1287: }
1288: else {
1289: return( 0 );
1290: }
1291: }
1292: }
1293: }
1294:
1295:
1296: namecmp( name1, name2 )
1297:
1298: char *name1;
1299: char *name2;
1300: {
1301: char c1, c2;
1302:
1303: c1 = *name1;
1304: if( (('A' <= c1) && (c1 <= 'Z')) || (('a' <= c1) && (c1 <= 'z')) ) {
1305: c1 = CAPITALIZE( c1 );
1306: }
1307: c2 = *name2;
1308: if( (('A' <= c2) && (c2 <= 'Z')) || (('a' <= c2) && (c2 <= 'z')) ) {
1309: c2 = CAPITALIZE( c2 );
1310: }
1311: while( c1 == c2 ) {
1312: if( c1 == NULL ) {
1313: return( 1 );
1314: }
1315: c1 = *++name1;
1316: if( (('A'<=c1) && (c1<='Z')) || (('a'<=c1) && (c1<='z')) ) {
1317: c1 = CAPITALIZE( c1 );
1318: }
1319: c2 = *++name2;
1320: if( (('A'<=c2) && (c2<='Z')) || (('a'<=c2) && (c2<='z')) ) {
1321: c2 = CAPITALIZE( c2 );
1322: }
1323: }
1324: if( *name1 == NULL ) {
1325: while( ('0' <= *name2) && (*name2 <= '9') ) {
1326: name2++;
1327: }
1328: if( *name2 == NULL ) {
1329: return( 1 );
1330: }
1331: }
1332: else {
1333: if( *name2 == NULL ) {
1334: while( ('0' <= *name1) && (*name1 <= '9') ) {
1335: name1++;
1336: }
1337: if( *name1 == NULL ) {
1338: return( 1 );
1339: }
1340: }
1341: }
1342: return( 0 );
1343: }
1344:
1345:
1346: char *strsave( s )
1347:
1348: char *s;
1349: {
1350: char *malloc();
1351: char *p;
1352:
1353: p = malloc( strlen( s ) + 1 );
1354: strcpy( p, s );
1355: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.