![[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 [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb|
Return to finger.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / 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: if (s[len - 1] == 'Z') {
794: fonebuf[0] = ' ';
795: fonebuf[1] = 'x';
796: for (i = 2; ; i++) {
797: if (*s == 'Z')
798: break;
799: fonebuf[i] = *s++;
800: }
801: for (i = i; i <= 7; i++)
802: fonebuf[i] = ' ';
803: fonebuf[8] = NULL;
804: return( strsave( &fonebuf[0] ) );
805: }
806: switch( len ) {
807:
808: case 4:
809: fonebuf[ 0 ] = ' ';
810: fonebuf[ 1 ] = 'x';
811: fonebuf[ 2 ] = '2';
812: fonebuf[ 3 ] = '-';
813: for( i = 0; i <= 3; i++ ) {
814: fonebuf[ 4 + i ] = *s++;
815: }
816: fonebuf[ 8 ] = NULL;
817: return( strsave( &fonebuf[0] ) );
818: break;
819:
820: case 7:
821: for( i = 0; i <= 2; i++ ) {
822: fonebuf[ i ] = *s++;
823: }
824: fonebuf[ 3 ] = '-';
825: for( i = 0; i <= 3; i++ ) {
826: fonebuf[ 4 + i ] = *s++;
827: }
828: fonebuf[ 8 ] = NULL;
829: return( strsave( &fonebuf[0] ) );
830: break;
831:
832: case 10:
833: for( i = 0; i <= 2; i++ ) {
834: fonebuf[ i ] = *s++;
835: }
836: fonebuf[ 3 ] = '-';
837: for( i = 0; i <= 2; i++ ) {
838: fonebuf[ 4 + i ] = *s++;
839: }
840: fonebuf[ 7 ] = '-';
841: for( i = 0; i <= 3; i++ ) {
842: fonebuf[ 8 + i ] = *s++;
843: }
844: fonebuf[ 12 ] = NULL;
845: return( strsave( &fonebuf[0] ) );
846: break;
847:
848: default:
849: fprintf( stderr, "finger: error in phone numbering\n" );
850: return( strsave(s) );
851: break;
852: }
853: }
854:
855:
856: /* decode the information in the gecos field of /etc/passwd
857: * another hacky section of code, but given the format the stuff is in...
858: */
859:
860: decode( pers )
861:
862: struct person *pers;
863:
864: {
865: struct passwd *pwdt = pers->pwd;
866: char buffer[ 256 ], *bp, *gp, *lp;
867: char *phone();
868: int len;
869: int i;
870:
871: pers->realname = NULLSTR;
872: pers->office = NULLSTR;
873: pers->officephone = NULLSTR;
874: pers->homephone = NULLSTR;
875: pers->random = NULLSTR;
876: if( pwdt != NILPWD ) {
877: gp = pwdt->pw_gecos;
878: bp = &buffer[ 0 ];
879: if( *gp == ASTERISK ) {
880: gp++;
881: }
882: while( (*gp != NULL) && (*gp != COMMA) ) { /* name */
883: if( *gp == SAMENAME ) {
884: lp = pwdt->pw_name;
885: *bp++ = CAPITALIZE(*lp++);
886: while( *lp != NULL ) {
887: *bp++ = *lp++;
888: }
889: }
890: else {
891: *bp++ = *gp;
892: }
893: gp++;
894: }
895: *bp = NULL;
896: pers->realname = malloc( strlen( &buffer[0] ) + 1 );
897: strcpy( pers->realname, &buffer[0] );
898: if( *gp++ == COMMA ) { /* office, supposedly */
899: bp = &buffer[ 0 ];
900: while( (*gp != NULL) && (*gp != COMMA) )
901: *bp++ = *gp++;
902: *bp = NULL;
903: len = strlen( &buffer[0] );
904: if( buffer[ len - 1 ] == CORY ) {
905: strcpy( &buffer[ len - 1 ], " Cory" );
906: pers->office = malloc( len + 5 );
907: strcpy( pers->office, &buffer[0] );
908: }
909: else {
910: if( buffer[ len - 1 ] == EVANS ) {
911: strcpy( &buffer[ len - 1 ], " Evans" );
912: pers->office = malloc( len + 6 );
913: strcpy( pers->office, &buffer[0] );
914: }
915: else {
916: if( buffer[ len - 1 ] == 'L' ) {
917: strcpy( &buffer[ len - 1 ], " LBL" );
918: pers->office = malloc( len + 4 );
919: strcpy( pers->office, &buffer[0] );
920: }
921: else {
922: if( buffer[ len - 1 ] == 'Q' ) {
923: pers->office = malloc( 10 );
924: for (i = 0; i < len - 1; i++)
925: pers->office[8 - i] = buffer[ len-i-2 ];
926: for (i = 0; i <= 9 - len; i++)
927: pers->office[i] = ' ';
928: pers->office[9] = NULL;
929: }
930: else {
931: if( len == 4 || buffer[ len - 1 ] == 'Z' ) {
932: pers->officephone = phone(&buffer[0], len);
933: }
934: else {
935: if( (len == 7) || (len == 10) ) {
936: pers->homephone = phone(&buffer[0],len);
937: }
938: else {
939: pers->random = malloc( len + 1 );
940: strcpy( pers->random, &buffer[0] );
941: }
942: }
943: }
944: }
945: }
946: }
947: if( *gp++ == COMMA ) { /* office phone, theoretically */
948: bp = &buffer[ 0 ];
949: while( (*gp != NULL) && (*gp != COMMA) )
950: *bp++ = *gp++;
951: *bp = NULL;
952: len = strlen( &buffer[0] );
953: if( (len != 4) && (buffer[ len - 1] != 'Z') ) {
954: if( (len == 7) || (len == 10) ) {
955: pers->homephone = phone( &buffer[0], len );
956: }
957: else {
958: pers->random = malloc( len + 1 );
959: strcpy( pers->random, &buffer[0] );
960: }
961: }
962: else {
963: pers->officephone = phone( &buffer[0], len );
964: }
965: if( *gp++ == COMMA ) { /* home phone?? */
966: bp = &buffer[ 0 ];
967: while( (*gp != NULL) && (*gp != COMMA) )
968: *bp++ = *gp++;
969: *bp = NULL;
970: len = strlen( &buffer[0] );
971: if( (len == 7) || (len == 10) ) {
972: if( *pers->homephone != NULL ) {
973: pers->officephone = pers->homephone;
974: }
975: pers->homephone = phone( &buffer[0], len );
976: }
977: else {
978: pers->random = malloc( strlen( &buffer[0] ) + 1 );
979: strcpy( pers->random, &buffer[0] );
980: }
981: }
982: }
983: }
984: if( pers->loggedin == 0 ) {
985: findwhen( pers );
986: }
987: else {
988: findidle( pers );
989: }
990: }
991: }
992:
993:
994: /* find the last log in of a user by checking the LASTLOG file.
995: * the entry is indexed by the uid, so this can only be done if
996: * the uid is known (which it isn't in quick mode)
997: */
998:
999: fwopen()
1000: {
1001: if( ( lf = open(LASTLOG, 0) ) >= 0 ) {
1002: llopenerr = 0;
1003: }
1004: else {
1005: fprintf( stderr, "finger: lastlog open error\n" );
1006: llopenerr = 1;
1007: }
1008: }
1009:
1010:
1011: findwhen( pers )
1012:
1013: struct person *pers;
1014: {
1015: struct passwd *pwdt = pers->pwd;
1016: struct lastlog ll;
1017: int llsize = sizeof ll;
1018: int i;
1019:
1020: if( !llopenerr ) {
1021: lseek( lf, pwdt->pw_uid*llsize, 0 );
1022: if ((i = read( lf, (char *) &ll, llsize )) == llsize) {
1023: for( i = 0; i < LMAX; i++ ) {
1024: pers->tty[ i ] = ll.ll_line[ i ];
1025: }
1026: pers->tty[ LMAX ] = NULL;
1027: pers->loginat = ll.ll_time;
1028: }
1029: else {
1030: if (i != 0)
1031: fprintf(stderr, "finger: lastlog read error\n");
1032: pers->tty[ 0 ] = NULL;
1033: pers->loginat = 0L;
1034: }
1035: }
1036: else {
1037: pers->tty[ 0 ] = NULL;
1038: pers->loginat = 0L;
1039: }
1040: }
1041:
1042:
1043: fwclose()
1044: {
1045: if( !llopenerr ) {
1046: close( lf );
1047: }
1048: }
1049:
1050:
1051: /* find the idle time of a user by doing a stat on /dev/histty,
1052: * where histty has been gotten from USERLOG, supposedly.
1053: */
1054:
1055: findidle( pers )
1056:
1057: struct person *pers;
1058: {
1059: struct stat ttystatus;
1060: struct passwd *pwdt = pers->pwd;
1061: char buffer[ 20 ];
1062: char *TTY = "/dev/";
1063: int TTYLEN = strlen( TTY );
1064: int i;
1065:
1066: strcpy( &buffer[0], TTY );
1067: i = 0;
1068: do {
1069: buffer[ TTYLEN + i ] = pers->tty[ i ];
1070: } while( ++i <= LMAX );
1071: if( stat( &buffer[0], &ttystatus ) >= 0 ) {
1072: time( &tloc );
1073: if( tloc < ttystatus.st_atime ) {
1074: pers->idletime = 0L;
1075: }
1076: else {
1077: pers->idletime = tloc - ttystatus.st_atime;
1078: }
1079: if( (ttystatus.st_mode & TALKABLE) == TALKABLE ) {
1080: pers->writeable = 1;
1081: }
1082: else {
1083: pers->writeable = 0;
1084: }
1085: }
1086: else {
1087: fprintf( stderr, "finger: error STATing %s\n", &buffer[0] );
1088: exit( 4 );
1089: }
1090: }
1091:
1092:
1093: /* print idle time in short format; this program always prints 4 characters;
1094: * if the idle time is zero, it prints 4 blanks.
1095: */
1096:
1097: stimeprint( dt )
1098:
1099: long *dt;
1100: {
1101: struct tm *gmtime();
1102: struct tm *delta;
1103:
1104: delta = gmtime( dt );
1105: if( delta->tm_yday == 0 ) {
1106: if( delta->tm_hour == 0 ) {
1107: if( delta->tm_min >= 10 ) {
1108: printf( " %2.2d ", delta->tm_min );
1109: }
1110: else {
1111: if( delta->tm_min == 0 ) {
1112: printf( " " );
1113: }
1114: else {
1115: printf( " %1.1d ", delta->tm_min );
1116: }
1117: }
1118: }
1119: else {
1120: if( delta->tm_hour >= 10 ) {
1121: printf( "%3.3d:", delta->tm_hour );
1122: }
1123: else {
1124: printf( "%1.1d:%02.2d", delta->tm_hour, delta->tm_min );
1125: }
1126: }
1127: }
1128: else {
1129: printf( "%3dd", delta->tm_yday );
1130: }
1131: }
1132:
1133:
1134: /* print idle time in long format with care being taken not to pluralize
1135: * 1 minutes or 1 hours or 1 days.
1136: */
1137:
1138: ltimeprint( dt )
1139:
1140: long *dt;
1141: {
1142: struct tm *gmtime();
1143: struct tm *delta;
1144: int printed = 1;
1145:
1146: delta = gmtime( dt );
1147: if( delta->tm_yday == 0 ) {
1148: if( delta->tm_hour == 0 ) {
1149: if( delta->tm_min >= 10 ) {
1150: printf( "%2d minutes", delta->tm_min );
1151: }
1152: else {
1153: if( delta->tm_min == 0 ) {
1154: if( delta->tm_sec > 10 ) {
1155: printf( "%2d seconds", delta->tm_sec );
1156: }
1157: else {
1158: printed = 0;
1159: }
1160: }
1161: else {
1162: if( delta->tm_min == 1 ) {
1163: if( delta->tm_sec == 1 ) {
1164: printf( "%1d minute %1d second",
1165: delta->tm_min, delta->tm_sec );
1166: }
1167: else {
1168: printf( "%1d minute %d seconds",
1169: delta->tm_min, delta->tm_sec );
1170: }
1171: }
1172: else {
1173: if( delta->tm_sec == 1 ) {
1174: printf( "%1d minutes %1d second",
1175: delta->tm_min, delta->tm_sec );
1176: }
1177: else {
1178: printf( "%1d minutes %d seconds",
1179: delta->tm_min, delta->tm_sec );
1180: }
1181: }
1182: }
1183: }
1184: }
1185: else {
1186: if( delta->tm_hour >= 10 ) {
1187: printf( "%2d hours", delta->tm_hour );
1188: }
1189: else {
1190: if( delta->tm_hour == 1 ) {
1191: if( delta->tm_min == 1 ) {
1192: printf( "%1d hour %1d minute",
1193: delta->tm_hour, delta->tm_min );
1194: }
1195: else {
1196: printf( "%1d hour %2d minutes",
1197: delta->tm_hour, delta->tm_min );
1198: }
1199: }
1200: else {
1201: if( delta->tm_min == 1 ) {
1202: printf( "%1d hours %1d minute",
1203: delta->tm_hour, delta->tm_min );
1204: }
1205: else {
1206: printf( "%1d hours %2d minutes",
1207: delta->tm_hour, delta->tm_min );
1208: }
1209: }
1210: }
1211: }
1212: }
1213: else {
1214: if( delta->tm_yday >= 10 ) {
1215: printf( "%2d days", delta->tm_yday );
1216: }
1217: else {
1218: if( delta->tm_yday == 1 ) {
1219: if( delta->tm_hour == 1 ) {
1220: printf( "%1d day %1d hour",
1221: delta->tm_yday, delta->tm_hour );
1222: }
1223: else {
1224: printf( "%1d day %2d hours",
1225: delta->tm_yday, delta->tm_hour );
1226: }
1227: }
1228: else {
1229: if( delta->tm_hour == 1 ) {
1230: printf( "%1d days %1d hour",
1231: delta->tm_yday, delta->tm_hour );
1232: }
1233: else {
1234: printf( "%1d days %2d hours",
1235: delta->tm_yday, delta->tm_hour );
1236: }
1237: }
1238: }
1239: }
1240: return( printed );
1241: }
1242:
1243:
1244: matchcmp( gname, login, given )
1245:
1246: char *gname;
1247: char *login;
1248: char *given;
1249: {
1250: char buffer[ 20 ];
1251: char c;
1252: int flag, i, unfound;
1253:
1254: if( !match ) {
1255: return( 0 );
1256: }
1257: else {
1258: if( namecmp( login, given ) ) {
1259: return( 1 );
1260: }
1261: else if (*gname == '\0')
1262: return (0);
1263: else {
1264: if( *gname == ASTERISK ) {
1265: gname++;
1266: }
1267: flag = 1;
1268: i = 0;
1269: unfound = 1;
1270: while( unfound ) {
1271: if( flag ) {
1272: c = *gname++;
1273: if( c == SAMENAME ) {
1274: flag = 0;
1275: c = *login++;
1276: }
1277: else {
1278: unfound = (*gname != COMMA) && (*gname != NULL);
1279: }
1280: }
1281: else {
1282: c = *login++;
1283: if( c == NULL ) {
1284: if( (*gname == COMMA) || (*gname == NULL) ) {
1285: break;
1286: }
1287: else {
1288: flag = 1;
1289: continue;
1290: }
1291: }
1292: }
1293: if( c == BLANK ) {
1294: buffer[i++] = NULL;
1295: if( namecmp( buffer, given ) ) {
1296: return( 1 );
1297: }
1298: i = 0;
1299: flag = 1;
1300: }
1301: else {
1302: buffer[ i++ ] = c;
1303: }
1304: }
1305: buffer[i++] = NULL;
1306: if( namecmp( buffer, given ) ) {
1307: return( 1 );
1308: }
1309: else {
1310: return( 0 );
1311: }
1312: }
1313: }
1314: }
1315:
1316:
1317: namecmp( name1, name2 )
1318:
1319: char *name1;
1320: char *name2;
1321: {
1322: char c1, c2;
1323:
1324: c1 = *name1;
1325: if( (('A' <= c1) && (c1 <= 'Z')) || (('a' <= c1) && (c1 <= 'z')) ) {
1326: c1 = CAPITALIZE( c1 );
1327: }
1328: c2 = *name2;
1329: if( (('A' <= c2) && (c2 <= 'Z')) || (('a' <= c2) && (c2 <= 'z')) ) {
1330: c2 = CAPITALIZE( c2 );
1331: }
1332: while( c1 == c2 ) {
1333: if( c1 == NULL ) {
1334: return( 1 );
1335: }
1336: c1 = *++name1;
1337: if( (('A'<=c1) && (c1<='Z')) || (('a'<=c1) && (c1<='z')) ) {
1338: c1 = CAPITALIZE( c1 );
1339: }
1340: c2 = *++name2;
1341: if( (('A'<=c2) && (c2<='Z')) || (('a'<=c2) && (c2<='z')) ) {
1342: c2 = CAPITALIZE( c2 );
1343: }
1344: }
1345: if( *name1 == NULL ) {
1346: while( ('0' <= *name2) && (*name2 <= '9') ) {
1347: name2++;
1348: }
1349: if( *name2 == NULL ) {
1350: return( 1 );
1351: }
1352: }
1353: else {
1354: if( *name2 == NULL ) {
1355: while( ('0' <= *name1) && (*name1 <= '9') ) {
1356: name1++;
1357: }
1358: if( *name1 == NULL ) {
1359: return( 1 );
1360: }
1361: }
1362: }
1363: return( 0 );
1364: }
1365:
1366:
1367: char *strsave( s )
1368:
1369: char *s;
1370: {
1371: char *malloc();
1372: char *p;
1373:
1374: p = malloc( strlen( s ) + 1 );
1375: strcpy( p, s );
1376: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.