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