![[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] / 43BSD / ucb|
Return to finger.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: char copyright[] = ! 9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\ ! 10: All rights reserved.\n"; ! 11: #endif not lint ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)finger.c 5.8 (Berkeley) 3/13/86"; ! 15: #endif not lint ! 16: ! 17: /* ! 18: * This is a finger program. It prints out useful information about users ! 19: * by digging it up from various system files. It is not very portable ! 20: * because the most useful parts of the information (the full user name, ! 21: * office, and phone numbers) are all stored in the VAX-unused gecos field ! 22: * of /etc/passwd, which, unfortunately, other UNIXes use for other things. ! 23: * ! 24: * There are three output formats, all of which give login name, teletype ! 25: * line number, and login time. The short output format is reminiscent ! 26: * of finger on ITS, and gives one line of information per user containing ! 27: * in addition to the minimum basic requirements (MBR), the full name of ! 28: * the user, his idle time and office location and phone number. The ! 29: * quick style output is UNIX who-like, giving only name, teletype and ! 30: * login time. Finally, the long style output give the same information ! 31: * as the short (in more legible format), the home directory and shell ! 32: * of the user, and, if it exits, a copy of the file .plan in the users ! 33: * home directory. Finger may be called with or without a list of people ! 34: * to finger -- if no list is given, all the people currently logged in ! 35: * are fingered. ! 36: * ! 37: * The program is validly called by one of the following: ! 38: * ! 39: * finger {short form list of users} ! 40: * finger -l {long form list of users} ! 41: * finger -b {briefer long form list of users} ! 42: * finger -q {quick list of users} ! 43: * finger -i {quick list of users with idle times} ! 44: * finger namelist {long format list of specified users} ! 45: * finger -s namelist {short format list of specified users} ! 46: * finger -w namelist {narrow short format list of specified users} ! 47: * ! 48: * where 'namelist' is a list of users login names. ! 49: * The other options can all be given after one '-', or each can have its ! 50: * own '-'. The -f option disables the printing of headers for short and ! 51: * quick outputs. The -b option briefens long format outputs. The -p ! 52: * option turns off plans for long format outputs. ! 53: */ ! 54: ! 55: #include <sys/types.h> ! 56: #include <sys/stat.h> ! 57: #include <utmp.h> ! 58: #include <sys/signal.h> ! 59: #include <pwd.h> ! 60: #include <stdio.h> ! 61: #include <lastlog.h> ! 62: #include <ctype.h> ! 63: #include <sys/time.h> ! 64: #include <sys/socket.h> ! 65: #include <netinet/in.h> ! 66: #include <netdb.h> ! 67: ! 68: #define ASTERISK '*' /* ignore this in real name */ ! 69: #define COMMA ',' /* separator in pw_gecos field */ ! 70: #define COMMAND '-' /* command line flag char */ ! 71: #define CORY 'C' /* cory hall office */ ! 72: #define EVANS 'E' /* evans hall office */ ! 73: #define SAMENAME '&' /* repeat login name in real name */ ! 74: #define TALKABLE 0220 /* tty is writable if 220 mode */ ! 75: ! 76: struct utmp user; ! 77: #define NMAX sizeof(user.ut_name) ! 78: #define LMAX sizeof(user.ut_line) ! 79: #define HMAX sizeof(user.ut_host) ! 80: ! 81: struct person { /* one for each person fingered */ ! 82: char *name; /* name */ ! 83: char tty[LMAX+1]; /* null terminated tty line */ ! 84: char host[HMAX+1]; /* null terminated remote host name */ ! 85: long loginat; /* time of (last) login */ ! 86: long idletime; /* how long idle (if logged in) */ ! 87: char *realname; /* pointer to full name */ ! 88: char *office; /* pointer to office name */ ! 89: char *officephone; /* pointer to office phone no. */ ! 90: char *homephone; /* pointer to home phone no. */ ! 91: char *random; /* for any random stuff in pw_gecos */ ! 92: struct passwd *pwd; /* structure of /etc/passwd stuff */ ! 93: char loggedin; /* person is logged in */ ! 94: char writable; /* tty is writable */ ! 95: char original; /* this is not a duplicate entry */ ! 96: struct person *link; /* link to next person */ ! 97: }; ! 98: ! 99: char LASTLOG[] = "/usr/adm/lastlog"; /* last login info */ ! 100: char USERLOG[] = "/etc/utmp"; /* who is logged in */ ! 101: char PLAN[] = "/.plan"; /* what plan file is */ ! 102: char PROJ[] = "/.project"; /* what project file */ ! 103: ! 104: int unbrief = 1; /* -b option default */ ! 105: int header = 1; /* -f option default */ ! 106: int hack = 1; /* -h option default */ ! 107: int idle = 0; /* -i option default */ ! 108: int large = 0; /* -l option default */ ! 109: int match = 1; /* -m option default */ ! 110: int plan = 1; /* -p option default */ ! 111: int unquick = 1; /* -q option default */ ! 112: int small = 0; /* -s option default */ ! 113: int wide = 1; /* -w option default */ ! 114: ! 115: int unshort; ! 116: int lf; /* LASTLOG file descriptor */ ! 117: struct person *person1; /* list of people */ ! 118: long tloc; /* current time */ ! 119: ! 120: struct passwd *pwdcopy(); ! 121: char *strcpy(); ! 122: char *malloc(); ! 123: char *ctime(); ! 124: ! 125: main(argc, argv) ! 126: int argc; ! 127: register char **argv; ! 128: { ! 129: FILE *fp; ! 130: register char *s; ! 131: ! 132: /* parse command line for (optional) arguments */ ! 133: while (*++argv && **argv == COMMAND) ! 134: for (s = *argv + 1; *s; s++) ! 135: switch (*s) { ! 136: case 'b': ! 137: unbrief = 0; ! 138: break; ! 139: case 'f': ! 140: header = 0; ! 141: break; ! 142: case 'h': ! 143: hack = 0; ! 144: break; ! 145: case 'i': ! 146: idle = 1; ! 147: unquick = 0; ! 148: break; ! 149: case 'l': ! 150: large = 1; ! 151: break; ! 152: case 'm': ! 153: match = 0; ! 154: break; ! 155: case 'p': ! 156: plan = 0; ! 157: break; ! 158: case 'q': ! 159: unquick = 0; ! 160: break; ! 161: case 's': ! 162: small = 1; ! 163: break; ! 164: case 'w': ! 165: wide = 0; ! 166: break; ! 167: default: ! 168: fprintf(stderr, "Usage: finger [-bfhilmpqsw] [login1 [login2 ...] ]\n"); ! 169: exit(1); ! 170: } ! 171: if (unquick || idle) ! 172: time(&tloc); ! 173: /* ! 174: * *argv == 0 means no names given ! 175: */ ! 176: if (*argv == 0) ! 177: doall(); ! 178: else ! 179: donames(argv); ! 180: if (person1) ! 181: print(); ! 182: exit(0); ! 183: } ! 184: ! 185: doall() ! 186: { ! 187: register struct person *p; ! 188: register struct passwd *pw; ! 189: int uf; ! 190: char name[NMAX + 1]; ! 191: ! 192: unshort = large; ! 193: if ((uf = open(USERLOG, 0)) < 0) { ! 194: fprintf(stderr, "finger: error opening %s\n", USERLOG); ! 195: exit(2); ! 196: } ! 197: if (unquick) { ! 198: extern _pw_stayopen; ! 199: ! 200: setpwent(); ! 201: _pw_stayopen = 1; ! 202: fwopen(); ! 203: } ! 204: while (read(uf, (char *)&user, sizeof user) == sizeof user) { ! 205: if (user.ut_name[0] == 0) ! 206: continue; ! 207: if (person1 == 0) ! 208: p = person1 = (struct person *) malloc(sizeof *p); ! 209: else { ! 210: p->link = (struct person *) malloc(sizeof *p); ! 211: p = p->link; ! 212: } ! 213: bcopy(user.ut_name, name, NMAX); ! 214: name[NMAX] = 0; ! 215: bcopy(user.ut_line, p->tty, LMAX); ! 216: p->tty[LMAX] = 0; ! 217: bcopy(user.ut_host, p->host, HMAX); ! 218: p->host[HMAX] = 0; ! 219: p->loginat = user.ut_time; ! 220: p->pwd = 0; ! 221: p->loggedin = 1; ! 222: if (unquick && (pw = getpwnam(name))) { ! 223: p->pwd = pwdcopy(pw); ! 224: decode(p); ! 225: p->name = p->pwd->pw_name; ! 226: } else ! 227: p->name = strcpy(malloc(strlen(name) + 1), name); ! 228: } ! 229: if (unquick) { ! 230: fwclose(); ! 231: endpwent(); ! 232: } ! 233: close(uf); ! 234: if (person1 == 0) { ! 235: printf("No one logged on\n"); ! 236: return; ! 237: } ! 238: p->link = 0; ! 239: } ! 240: ! 241: donames(argv) ! 242: char **argv; ! 243: { ! 244: register struct person *p; ! 245: register struct passwd *pw; ! 246: int uf; ! 247: ! 248: /* ! 249: * get names from command line and check to see if they're ! 250: * logged in ! 251: */ ! 252: unshort = !small; ! 253: for (; *argv != 0; argv++) { ! 254: if (netfinger(*argv)) ! 255: continue; ! 256: if (person1 == 0) ! 257: p = person1 = (struct person *) malloc(sizeof *p); ! 258: else { ! 259: p->link = (struct person *) malloc(sizeof *p); ! 260: p = p->link; ! 261: } ! 262: p->name = *argv; ! 263: p->loggedin = 0; ! 264: p->original = 1; ! 265: p->pwd = 0; ! 266: } ! 267: if (person1 == 0) ! 268: return; ! 269: p->link = 0; ! 270: /* ! 271: * if we are doing it, read /etc/passwd for the useful info ! 272: */ ! 273: if (unquick) { ! 274: setpwent(); ! 275: if (!match) { ! 276: extern _pw_stayopen; ! 277: ! 278: _pw_stayopen = 1; ! 279: for (p = person1; p != 0; p = p->link) ! 280: if (pw = getpwnam(p->name)) ! 281: p->pwd = pwdcopy(pw); ! 282: } else while ((pw = getpwent()) != 0) { ! 283: for (p = person1; p != 0; p = p->link) { ! 284: if (!p->original) ! 285: continue; ! 286: if (strcmp(p->name, pw->pw_name) != 0 && ! 287: !matchcmp(pw->pw_gecos, pw->pw_name, p->name)) ! 288: continue; ! 289: if (p->pwd == 0) ! 290: p->pwd = pwdcopy(pw); ! 291: else { ! 292: struct person *new; ! 293: /* ! 294: * handle multiple login names, insert ! 295: * new "duplicate" entry behind ! 296: */ ! 297: new = (struct person *) ! 298: malloc(sizeof *new); ! 299: new->pwd = pwdcopy(pw); ! 300: new->name = p->name; ! 301: new->original = 1; ! 302: new->loggedin = 0; ! 303: new->link = p->link; ! 304: p->original = 0; ! 305: p->link = new; ! 306: p = new; ! 307: } ! 308: } ! 309: } ! 310: endpwent(); ! 311: } ! 312: /* Now get login information */ ! 313: if ((uf = open(USERLOG, 0)) < 0) { ! 314: fprintf(stderr, "finger: error opening %s\n", USERLOG); ! 315: exit(2); ! 316: } ! 317: while (read(uf, (char *)&user, sizeof user) == sizeof user) { ! 318: if (*user.ut_name == 0) ! 319: continue; ! 320: for (p = person1; p != 0; p = p->link) { ! 321: if (p->loggedin == 2) ! 322: continue; ! 323: if (strncmp(p->pwd ? p->pwd->pw_name : p->name, ! 324: user.ut_name, NMAX) != 0) ! 325: continue; ! 326: if (p->loggedin == 0) { ! 327: bcopy(user.ut_line, p->tty, LMAX); ! 328: p->tty[LMAX] = 0; ! 329: bcopy(user.ut_host, p->host, HMAX); ! 330: p->host[HMAX] = 0; ! 331: p->loginat = user.ut_time; ! 332: p->loggedin = 1; ! 333: } else { /* p->loggedin == 1 */ ! 334: struct person *new; ! 335: new = (struct person *) malloc(sizeof *new); ! 336: new->name = p->name; ! 337: bcopy(user.ut_line, new->tty, LMAX); ! 338: new->tty[LMAX] = 0; ! 339: bcopy(user.ut_host, new->host, HMAX); ! 340: new->host[HMAX] = 0; ! 341: new->loginat = user.ut_time; ! 342: new->pwd = p->pwd; ! 343: new->loggedin = 1; ! 344: new->original = 0; ! 345: new->link = p->link; ! 346: p->loggedin = 2; ! 347: p->link = new; ! 348: p = new; ! 349: } ! 350: } ! 351: } ! 352: close(uf); ! 353: if (unquick) { ! 354: fwopen(); ! 355: for (p = person1; p != 0; p = p->link) ! 356: decode(p); ! 357: fwclose(); ! 358: } ! 359: } ! 360: ! 361: print() ! 362: { ! 363: register FILE *fp; ! 364: register struct person *p; ! 365: register char *s; ! 366: register c; ! 367: ! 368: /* ! 369: * print out what we got ! 370: */ ! 371: if (header) { ! 372: if (unquick) { ! 373: if (!unshort) ! 374: if (wide) ! 375: printf("Login Name TTY Idle When Office\n"); ! 376: else ! 377: printf("Login TTY Idle When Office\n"); ! 378: } else { ! 379: printf("Login TTY When"); ! 380: if (idle) ! 381: printf(" Idle"); ! 382: putchar('\n'); ! 383: } ! 384: } ! 385: for (p = person1; p != 0; p = p->link) { ! 386: if (!unquick) { ! 387: quickprint(p); ! 388: continue; ! 389: } ! 390: if (!unshort) { ! 391: shortprint(p); ! 392: continue; ! 393: } ! 394: personprint(p); ! 395: if (p->pwd != 0) { ! 396: if (hack) { ! 397: s = malloc(strlen(p->pwd->pw_dir) + ! 398: sizeof PROJ); ! 399: strcpy(s, p->pwd->pw_dir); ! 400: strcat(s, PROJ); ! 401: if ((fp = fopen(s, "r")) != 0) { ! 402: printf("Project: "); ! 403: while ((c = getc(fp)) != EOF) { ! 404: if (c == '\n') ! 405: break; ! 406: if (isprint(c) || isspace(c)) ! 407: putchar(c); ! 408: else ! 409: putchar(c ^ 100); ! 410: } ! 411: fclose(fp); ! 412: putchar('\n'); ! 413: } ! 414: free(s); ! 415: } ! 416: if (plan) { ! 417: s = malloc(strlen(p->pwd->pw_dir) + ! 418: sizeof PLAN); ! 419: strcpy(s, p->pwd->pw_dir); ! 420: strcat(s, PLAN); ! 421: if ((fp = fopen(s, "r")) == 0) ! 422: printf("No Plan.\n"); ! 423: else { ! 424: printf("Plan:\n"); ! 425: while ((c = getc(fp)) != EOF) ! 426: if (isprint(c) || isspace(c)) ! 427: putchar(c); ! 428: else ! 429: putchar(c ^ 100); ! 430: fclose(fp); ! 431: } ! 432: free(s); ! 433: } ! 434: } ! 435: if (p->link != 0) ! 436: putchar('\n'); ! 437: } ! 438: } ! 439: ! 440: /* ! 441: * Duplicate a pwd entry. ! 442: * Note: Only the useful things (what the program currently uses) are copied. ! 443: */ ! 444: struct passwd * ! 445: pwdcopy(pfrom) ! 446: register struct passwd *pfrom; ! 447: { ! 448: register struct passwd *pto; ! 449: ! 450: pto = (struct passwd *) malloc(sizeof *pto); ! 451: #define savestr(s) strcpy(malloc(strlen(s) + 1), s) ! 452: pto->pw_name = savestr(pfrom->pw_name); ! 453: pto->pw_uid = pfrom->pw_uid; ! 454: pto->pw_gecos = savestr(pfrom->pw_gecos); ! 455: pto->pw_dir = savestr(pfrom->pw_dir); ! 456: pto->pw_shell = savestr(pfrom->pw_shell); ! 457: #undef savestr ! 458: return pto; ! 459: } ! 460: ! 461: /* ! 462: * print out information on quick format giving just name, tty, login time ! 463: * and idle time if idle is set. ! 464: */ ! 465: quickprint(pers) ! 466: register struct person *pers; ! 467: { ! 468: printf("%-*.*s ", NMAX, NMAX, pers->name); ! 469: if (pers->loggedin) { ! 470: if (idle) { ! 471: findidle(pers); ! 472: printf("%c%-*s %-16.16s", pers->writable ? ' ' : '*', ! 473: LMAX, pers->tty, ctime(&pers->loginat)); ! 474: ltimeprint(" ", &pers->idletime, ""); ! 475: } else ! 476: printf(" %-*s %-16.16s", LMAX, ! 477: pers->tty, ctime(&pers->loginat)); ! 478: putchar('\n'); ! 479: } else ! 480: printf(" Not Logged In\n"); ! 481: } ! 482: ! 483: /* ! 484: * print out information in short format, giving login name, full name, ! 485: * tty, idle time, login time, office location and phone. ! 486: */ ! 487: shortprint(pers) ! 488: register struct person *pers; ! 489: { ! 490: char *p; ! 491: char dialup; ! 492: ! 493: if (pers->pwd == 0) { ! 494: printf("%-15s ???\n", pers->name); ! 495: return; ! 496: } ! 497: printf("%-*s", NMAX, pers->pwd->pw_name); ! 498: dialup = 0; ! 499: if (wide) { ! 500: if (pers->realname) ! 501: printf(" %-20.20s", pers->realname); ! 502: else ! 503: printf(" ??? "); ! 504: } ! 505: putchar(' '); ! 506: if (pers->loggedin && !pers->writable) ! 507: putchar('*'); ! 508: else ! 509: putchar(' '); ! 510: if (*pers->tty) { ! 511: if (pers->tty[0] == 't' && pers->tty[1] == 't' && ! 512: pers->tty[2] == 'y') { ! 513: if (pers->tty[3] == 'd' && pers->loggedin) ! 514: dialup = 1; ! 515: printf("%-2.2s ", pers->tty + 3); ! 516: } else ! 517: printf("%-2.2s ", pers->tty); ! 518: } else ! 519: printf(" "); ! 520: p = ctime(&pers->loginat); ! 521: if (pers->loggedin) { ! 522: stimeprint(&pers->idletime); ! 523: printf(" %3.3s %-5.5s ", p, p + 11); ! 524: } else if (pers->loginat == 0) ! 525: printf(" < . . . . >"); ! 526: else if (tloc - pers->loginat >= 180 * 24 * 60 * 60) ! 527: printf(" <%-6.6s, %-4.4s>", p + 4, p + 20); ! 528: else ! 529: printf(" <%-12.12s>", p + 4); ! 530: if (dialup && pers->homephone) ! 531: printf(" %20s", pers->homephone); ! 532: else { ! 533: if (pers->office) ! 534: printf(" %-11.11s", pers->office); ! 535: else if (pers->officephone || pers->homephone) ! 536: printf(" "); ! 537: if (pers->officephone) ! 538: printf(" %s", pers->officephone); ! 539: else if (pers->homephone) ! 540: printf(" %s", pers->homephone); ! 541: } ! 542: putchar('\n'); ! 543: } ! 544: ! 545: /* ! 546: * print out a person in long format giving all possible information. ! 547: * directory and shell are inhibited if unbrief is clear. ! 548: */ ! 549: personprint(pers) ! 550: register struct person *pers; ! 551: { ! 552: if (pers->pwd == 0) { ! 553: printf("Login name: %-10s\t\t\tIn real life: ???\n", ! 554: pers->name); ! 555: return; ! 556: } ! 557: printf("Login name: %-10s", pers->pwd->pw_name); ! 558: if (pers->loggedin && !pers->writable) ! 559: printf(" (messages off) "); ! 560: else ! 561: printf(" "); ! 562: if (pers->realname) ! 563: printf("In real life: %s", pers->realname); ! 564: if (pers->office) { ! 565: printf("\nOffice: %-.11s", pers->office); ! 566: if (pers->officephone) { ! 567: printf(", %s", pers->officephone); ! 568: if (pers->homephone) ! 569: printf("\t\tHome phone: %s", pers->homephone); ! 570: else if (pers->random) ! 571: printf("\t\t%s", pers->random); ! 572: } else ! 573: if (pers->homephone) ! 574: printf("\t\t\tHome phone: %s", pers->homephone); ! 575: else if (pers->random) ! 576: printf("\t\t\t%s", pers->random); ! 577: } else if (pers->officephone) { ! 578: printf("\nPhone: %s", pers->officephone); ! 579: if (pers->homephone) ! 580: printf(", %s", pers->homephone); ! 581: if (pers->random) ! 582: printf(", %s", pers->random); ! 583: } else if (pers->homephone) { ! 584: printf("\nPhone: %s", pers->homephone); ! 585: if (pers->random) ! 586: printf(", %s", pers->random); ! 587: } else if (pers->random) ! 588: printf("\n%s", pers->random); ! 589: if (unbrief) { ! 590: printf("\nDirectory: %-25s", pers->pwd->pw_dir); ! 591: if (*pers->pwd->pw_shell) ! 592: printf("\tShell: %-s", pers->pwd->pw_shell); ! 593: } ! 594: if (pers->loggedin) { ! 595: register char *ep = ctime(&pers->loginat); ! 596: if (*pers->host) { ! 597: printf("\nOn since %15.15s on %s from %s", ! 598: &ep[4], pers->tty, pers->host); ! 599: ltimeprint("\n", &pers->idletime, " Idle Time"); ! 600: } else { ! 601: printf("\nOn since %15.15s on %-*s", ! 602: &ep[4], LMAX, pers->tty); ! 603: ltimeprint("\t", &pers->idletime, " Idle Time"); ! 604: } ! 605: } else if (pers->loginat == 0) ! 606: printf("\nNever logged in."); ! 607: else if (tloc - pers->loginat > 180 * 24 * 60 * 60) { ! 608: register char *ep = ctime(&pers->loginat); ! 609: printf("\nLast login %10.10s, %4.4s on %s", ! 610: ep, ep+20, pers->tty); ! 611: if (*pers->host) ! 612: printf(" from %s", pers->host); ! 613: } else { ! 614: register char *ep = ctime(&pers->loginat); ! 615: printf("\nLast login %16.16s on %s", ep, pers->tty); ! 616: if (*pers->host) ! 617: printf(" from %s", pers->host); ! 618: } ! 619: putchar('\n'); ! 620: } ! 621: ! 622: /* ! 623: * very hacky section of code to format phone numbers. filled with ! 624: * magic constants like 4, 7 and 10. ! 625: */ ! 626: char * ! 627: phone(s, len, alldigits) ! 628: register char *s; ! 629: int len; ! 630: char alldigits; ! 631: { ! 632: char fonebuf[15]; ! 633: register char *p = fonebuf; ! 634: register i; ! 635: ! 636: if (!alldigits) ! 637: return (strcpy(malloc(len + 1), s)); ! 638: switch (len) { ! 639: case 4: ! 640: *p++ = ' '; ! 641: *p++ = 'x'; ! 642: *p++ = '2'; ! 643: *p++ = '-'; ! 644: for (i = 0; i < 4; i++) ! 645: *p++ = *s++; ! 646: break; ! 647: case 5: ! 648: *p++ = ' '; ! 649: *p++ = 'x'; ! 650: *p++ = *s++; ! 651: *p++ = '-'; ! 652: for (i = 0; i < 4; i++) ! 653: *p++ = *s++; ! 654: break; ! 655: case 7: ! 656: for (i = 0; i < 3; i++) ! 657: *p++ = *s++; ! 658: *p++ = '-'; ! 659: for (i = 0; i < 4; i++) ! 660: *p++ = *s++; ! 661: break; ! 662: case 10: ! 663: for (i = 0; i < 3; i++) ! 664: *p++ = *s++; ! 665: *p++ = '-'; ! 666: for (i = 0; i < 3; i++) ! 667: *p++ = *s++; ! 668: *p++ = '-'; ! 669: for (i = 0; i < 4; i++) ! 670: *p++ = *s++; ! 671: break; ! 672: case 0: ! 673: return 0; ! 674: default: ! 675: return (strcpy(malloc(len + 1), s)); ! 676: } ! 677: *p++ = 0; ! 678: return (strcpy(malloc(p - fonebuf), fonebuf)); ! 679: } ! 680: ! 681: /* ! 682: * decode the information in the gecos field of /etc/passwd ! 683: */ ! 684: decode(pers) ! 685: register struct person *pers; ! 686: { ! 687: char buffer[256]; ! 688: register char *bp, *gp, *lp; ! 689: int alldigits; ! 690: int hasspace; ! 691: int len; ! 692: ! 693: pers->realname = 0; ! 694: pers->office = 0; ! 695: pers->officephone = 0; ! 696: pers->homephone = 0; ! 697: pers->random = 0; ! 698: if (pers->pwd == 0) ! 699: return; ! 700: gp = pers->pwd->pw_gecos; ! 701: bp = buffer; ! 702: if (*gp == ASTERISK) ! 703: gp++; ! 704: while (*gp && *gp != COMMA) /* name */ ! 705: if (*gp == SAMENAME) { ! 706: lp = pers->pwd->pw_name; ! 707: if (islower(*lp)) ! 708: *bp++ = toupper(*lp++); ! 709: while (*bp++ = *lp++) ! 710: ; ! 711: bp--; ! 712: gp++; ! 713: } else ! 714: *bp++ = *gp++; ! 715: *bp++ = 0; ! 716: if ((len = bp - buffer) > 1) ! 717: pers->realname = strcpy(malloc(len), buffer); ! 718: if (*gp == COMMA) { /* office */ ! 719: gp++; ! 720: hasspace = 0; ! 721: bp = buffer; ! 722: while (*gp && *gp != COMMA) { ! 723: *bp = *gp++; ! 724: if (*bp == ' ') ! 725: hasspace = 1; ! 726: /* leave 5 for Cory and Evans expansion */ ! 727: if (bp < buffer + sizeof buffer - 6) ! 728: bp++; ! 729: } ! 730: *bp = 0; ! 731: len = bp - buffer; ! 732: bp--; /* point to last character */ ! 733: if (hasspace || len == 0) ! 734: len++; ! 735: else if (*bp == CORY) { ! 736: strcpy(bp, " Cory"); ! 737: len += 5; ! 738: } else if (*bp == EVANS) { ! 739: strcpy(bp, " Evans"); ! 740: len += 6; ! 741: } else ! 742: len++; ! 743: if (len > 1) ! 744: pers->office = strcpy(malloc(len), buffer); ! 745: } ! 746: if (*gp == COMMA) { /* office phone */ ! 747: gp++; ! 748: bp = buffer; ! 749: alldigits = 1; ! 750: while (*gp && *gp != COMMA) { ! 751: *bp = *gp++; ! 752: if (!isdigit(*bp)) ! 753: alldigits = 0; ! 754: if (bp < buffer + sizeof buffer - 1) ! 755: bp++; ! 756: } ! 757: *bp = 0; ! 758: pers->officephone = phone(buffer, bp - buffer, alldigits); ! 759: } ! 760: if (*gp == COMMA) { /* home phone */ ! 761: gp++; ! 762: bp = buffer; ! 763: alldigits = 1; ! 764: while (*gp && *gp != COMMA) { ! 765: *bp = *gp++; ! 766: if (!isdigit(*bp)) ! 767: alldigits = 0; ! 768: if (bp < buffer + sizeof buffer - 1) ! 769: bp++; ! 770: } ! 771: *bp = 0; ! 772: pers->homephone = phone(buffer, bp - buffer, alldigits); ! 773: } ! 774: if (pers->loggedin) ! 775: findidle(pers); ! 776: else ! 777: findwhen(pers); ! 778: } ! 779: ! 780: /* ! 781: * find the last log in of a user by checking the LASTLOG file. ! 782: * the entry is indexed by the uid, so this can only be done if ! 783: * the uid is known (which it isn't in quick mode) ! 784: */ ! 785: ! 786: fwopen() ! 787: { ! 788: if ((lf = open(LASTLOG, 0)) < 0) ! 789: fprintf(stderr, "finger: %s open error\n", LASTLOG); ! 790: } ! 791: ! 792: findwhen(pers) ! 793: register struct person *pers; ! 794: { ! 795: struct lastlog ll; ! 796: int i; ! 797: ! 798: if (lf >= 0) { ! 799: lseek(lf, (long)pers->pwd->pw_uid * sizeof ll, 0); ! 800: if ((i = read(lf, (char *)&ll, sizeof ll)) == sizeof ll) { ! 801: bcopy(ll.ll_line, pers->tty, LMAX); ! 802: pers->tty[LMAX] = 0; ! 803: bcopy(ll.ll_host, pers->host, HMAX); ! 804: pers->host[HMAX] = 0; ! 805: pers->loginat = ll.ll_time; ! 806: } else { ! 807: if (i != 0) ! 808: fprintf(stderr, "finger: %s read error\n", ! 809: LASTLOG); ! 810: pers->tty[0] = 0; ! 811: pers->host[0] = 0; ! 812: pers->loginat = 0L; ! 813: } ! 814: } else { ! 815: pers->tty[0] = 0; ! 816: pers->host[0] = 0; ! 817: pers->loginat = 0L; ! 818: } ! 819: } ! 820: ! 821: fwclose() ! 822: { ! 823: if (lf >= 0) ! 824: close(lf); ! 825: } ! 826: ! 827: /* ! 828: * find the idle time of a user by doing a stat on /dev/tty??, ! 829: * where tty?? has been gotten from USERLOG, supposedly. ! 830: */ ! 831: findidle(pers) ! 832: register struct person *pers; ! 833: { ! 834: struct stat ttystatus; ! 835: static char buffer[20] = "/dev/"; ! 836: long t; ! 837: #define TTYLEN 5 ! 838: ! 839: strcpy(buffer + TTYLEN, pers->tty); ! 840: buffer[TTYLEN+LMAX] = 0; ! 841: if (stat(buffer, &ttystatus) < 0) { ! 842: fprintf(stderr, "finger: Can't stat %s\n", buffer); ! 843: exit(4); ! 844: } ! 845: time(&t); ! 846: if (t < ttystatus.st_atime) ! 847: pers->idletime = 0L; ! 848: else ! 849: pers->idletime = t - ttystatus.st_atime; ! 850: pers->writable = (ttystatus.st_mode & TALKABLE) == TALKABLE; ! 851: } ! 852: ! 853: /* ! 854: * print idle time in short format; this program always prints 4 characters; ! 855: * if the idle time is zero, it prints 4 blanks. ! 856: */ ! 857: stimeprint(dt) ! 858: long *dt; ! 859: { ! 860: register struct tm *delta; ! 861: ! 862: delta = gmtime(dt); ! 863: if (delta->tm_yday == 0) ! 864: if (delta->tm_hour == 0) ! 865: if (delta->tm_min == 0) ! 866: printf(" "); ! 867: else ! 868: printf(" %2d", delta->tm_min); ! 869: else ! 870: if (delta->tm_hour >= 10) ! 871: printf("%3d:", delta->tm_hour); ! 872: else ! 873: printf("%1d:%02d", ! 874: delta->tm_hour, delta->tm_min); ! 875: else ! 876: printf("%3dd", delta->tm_yday); ! 877: } ! 878: ! 879: /* ! 880: * print idle time in long format with care being taken not to pluralize ! 881: * 1 minutes or 1 hours or 1 days. ! 882: * print "prefix" first. ! 883: */ ! 884: ltimeprint(before, dt, after) ! 885: long *dt; ! 886: char *before, *after; ! 887: { ! 888: register struct tm *delta; ! 889: ! 890: delta = gmtime(dt); ! 891: if (delta->tm_yday == 0 && delta->tm_hour == 0 && delta->tm_min == 0 && ! 892: delta->tm_sec <= 10) ! 893: return (0); ! 894: printf("%s", before); ! 895: if (delta->tm_yday >= 10) ! 896: printf("%d days", delta->tm_yday); ! 897: else if (delta->tm_yday > 0) ! 898: printf("%d day%s %d hour%s", ! 899: delta->tm_yday, delta->tm_yday == 1 ? "" : "s", ! 900: delta->tm_hour, delta->tm_hour == 1 ? "" : "s"); ! 901: else ! 902: if (delta->tm_hour >= 10) ! 903: printf("%d hours", delta->tm_hour); ! 904: else if (delta->tm_hour > 0) ! 905: printf("%d hour%s %d minute%s", ! 906: delta->tm_hour, delta->tm_hour == 1 ? "" : "s", ! 907: delta->tm_min, delta->tm_min == 1 ? "" : "s"); ! 908: else ! 909: if (delta->tm_min >= 10) ! 910: printf("%2d minutes", delta->tm_min); ! 911: else if (delta->tm_min == 0) ! 912: printf("%2d seconds", delta->tm_sec); ! 913: else ! 914: printf("%d minute%s %d second%s", ! 915: delta->tm_min, ! 916: delta->tm_min == 1 ? "" : "s", ! 917: delta->tm_sec, ! 918: delta->tm_sec == 1 ? "" : "s"); ! 919: printf("%s", after); ! 920: } ! 921: ! 922: matchcmp(gname, login, given) ! 923: register char *gname; ! 924: char *login; ! 925: char *given; ! 926: { ! 927: char buffer[100]; ! 928: register char *bp, *lp; ! 929: register c; ! 930: ! 931: if (*gname == ASTERISK) ! 932: gname++; ! 933: lp = 0; ! 934: bp = buffer; ! 935: for (;;) ! 936: switch (c = *gname++) { ! 937: case SAMENAME: ! 938: for (lp = login; bp < buffer + sizeof buffer ! 939: && (*bp++ = *lp++);) ! 940: ; ! 941: bp--; ! 942: break; ! 943: case ' ': ! 944: case COMMA: ! 945: case '\0': ! 946: *bp = 0; ! 947: if (namecmp(buffer, given)) ! 948: return (1); ! 949: if (c == COMMA || c == 0) ! 950: return (0); ! 951: bp = buffer; ! 952: break; ! 953: default: ! 954: if (bp < buffer + sizeof buffer) ! 955: *bp++ = c; ! 956: } ! 957: /*NOTREACHED*/ ! 958: } ! 959: ! 960: namecmp(name1, name2) ! 961: register char *name1, *name2; ! 962: { ! 963: register c1, c2; ! 964: ! 965: for (;;) { ! 966: c1 = *name1++; ! 967: if (islower(c1)) ! 968: c1 = toupper(c1); ! 969: c2 = *name2++; ! 970: if (islower(c2)) ! 971: c2 = toupper(c2); ! 972: if (c1 != c2) ! 973: break; ! 974: if (c1 == 0) ! 975: return (1); ! 976: } ! 977: if (!c1) { ! 978: for (name2--; isdigit(*name2); name2++) ! 979: ; ! 980: if (*name2 == 0) ! 981: return (1); ! 982: } else if (!c2) { ! 983: for (name1--; isdigit(*name1); name1++) ! 984: ; ! 985: if (*name2 == 0) ! 986: return (1); ! 987: } ! 988: return (0); ! 989: } ! 990: ! 991: netfinger(name) ! 992: char *name; ! 993: { ! 994: char *host; ! 995: char fname[100]; ! 996: struct hostent *hp; ! 997: struct servent *sp; ! 998: struct sockaddr_in sin; ! 999: int s; ! 1000: char *rindex(); ! 1001: register FILE *f; ! 1002: register int c; ! 1003: register int lastc; ! 1004: ! 1005: if (name == NULL) ! 1006: return (0); ! 1007: host = rindex(name, '@'); ! 1008: if (host == NULL) ! 1009: return (0); ! 1010: *host++ = 0; ! 1011: hp = gethostbyname(host); ! 1012: if (hp == NULL) { ! 1013: static struct hostent def; ! 1014: static struct in_addr defaddr; ! 1015: static char *alist[1]; ! 1016: static char namebuf[128]; ! 1017: int inet_addr(); ! 1018: ! 1019: defaddr.s_addr = inet_addr(host); ! 1020: if (defaddr.s_addr == -1) { ! 1021: printf("unknown host: %s\n", host); ! 1022: return (1); ! 1023: } ! 1024: strcpy(namebuf, host); ! 1025: def.h_name = namebuf; ! 1026: def.h_addr_list = alist, def.h_addr = (char *)&defaddr; ! 1027: def.h_length = sizeof (struct in_addr); ! 1028: def.h_addrtype = AF_INET; ! 1029: def.h_aliases = 0; ! 1030: hp = &def; ! 1031: } ! 1032: printf("[%s]", hp->h_name); ! 1033: sp = getservbyname("finger", "tcp"); ! 1034: if (sp == 0) { ! 1035: printf("tcp/finger: unknown service\n"); ! 1036: return (1); ! 1037: } ! 1038: sin.sin_family = hp->h_addrtype; ! 1039: bcopy(hp->h_addr, (char *)&sin.sin_addr, hp->h_length); ! 1040: sin.sin_port = sp->s_port; ! 1041: s = socket(hp->h_addrtype, SOCK_STREAM, 0); ! 1042: if (s < 0) { ! 1043: fflush(stdout); ! 1044: perror("socket"); ! 1045: return (1); ! 1046: } ! 1047: if (connect(s, (char *)&sin, sizeof (sin)) < 0) { ! 1048: fflush(stdout); ! 1049: perror("connect"); ! 1050: close(s); ! 1051: return (1); ! 1052: } ! 1053: printf("\n"); ! 1054: if (large) write(s, "/W ", 3); ! 1055: write(s, name, strlen(name)); ! 1056: write(s, "\r\n", 2); ! 1057: f = fdopen(s, "r"); ! 1058: while ((c = getc(f)) != EOF) { ! 1059: switch(c) { ! 1060: case 0210: ! 1061: case 0211: ! 1062: case 0212: ! 1063: case 0214: ! 1064: c -= 0200; ! 1065: break; ! 1066: case 0215: ! 1067: c = '\n'; ! 1068: break; ! 1069: } ! 1070: lastc = c; ! 1071: if (isprint(c) || isspace(c)) ! 1072: putchar(c); ! 1073: else ! 1074: putchar(c ^ 100); ! 1075: } ! 1076: if (lastc != '\n') ! 1077: putchar('\n'); ! 1078: (void)fclose(f); ! 1079: return (1); ! 1080: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.