1093 lines
25 KiB
C
Executable file
1093 lines
25 KiB
C
Executable file
/*
|
|
* Copyright (c) 1980 Regents of the University of California.
|
|
* All rights reserved. The Berkeley software License Agreement
|
|
* specifies the terms and conditions for redistribution.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)finger.c 1.1 87/12/21 SMI"; /* from 5.8 3/13/86 */
|
|
#endif /* not lint */
|
|
|
|
/*
|
|
* This is a finger program. It prints out useful information about users
|
|
* by digging it up from various system files.
|
|
*
|
|
* There are three output formats, all of which give login name, teletype
|
|
* line number, and login time. The short output format is reminiscent
|
|
* of finger on ITS, and gives one line of information per user containing
|
|
* in addition to the minimum basic requirements (MBR), the full name of
|
|
* the user, his idle time and location. The
|
|
* quick style output is UNIX who-like, giving only name, teletype and
|
|
* login time. Finally, the long style output give the same information
|
|
* as the short (in more legible format), the home directory and shell
|
|
* of the user, and, if it exits, a copy of the file .plan in the users
|
|
* home directory. Finger may be called with or without a list of people
|
|
* to finger -- if no list is given, all the people currently logged in
|
|
* are fingered.
|
|
*
|
|
* The program is validly called by one of the following:
|
|
*
|
|
* finger {short form list of users}
|
|
* finger -l {long form list of users}
|
|
* finger -b {briefer long form list of users}
|
|
* finger -q {quick list of users}
|
|
* finger -i {quick list of users with idle times}
|
|
* finger namelist {long format list of specified users}
|
|
* finger -s namelist {short format list of specified users}
|
|
* finger -w namelist {narrow short format list of specified users}
|
|
*
|
|
* where 'namelist' is a list of users login names.
|
|
* The other options can all be given after one '-', or each can have its
|
|
* own '-'. The -f option disables the printing of headers for short and
|
|
* quick outputs. The -b option briefens long format outputs. The -p
|
|
* option turns off plans for long format outputs.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <pwd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <utmp.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <net/gen/in.h>
|
|
#include <net/gen/inet.h>
|
|
#include <net/gen/netdb.h>
|
|
#include <net/gen/socket.h>
|
|
#include <net/gen/tcp.h>
|
|
#include <net/gen/tcp_hdr.h>
|
|
#include <net/gen/tcp_io.h>
|
|
#include <net/hton.h>
|
|
#include <net/netlib.h>
|
|
|
|
#define NONOTHING 1 /* don't say "No plan", or "No mail" */
|
|
|
|
#define NONET 0
|
|
|
|
#define ASTERISK '*' /* ignore this in real name */
|
|
#define COMMA ',' /* separator in pw_gecos field */
|
|
#define COMMAND '-' /* command line flag char */
|
|
#define SAMENAME '&' /* repeat login name in real name */
|
|
#define TALKABLE 0220 /* tty is writable if this mode */
|
|
|
|
struct utmp user;
|
|
#define NMAX sizeof(user.ut_name)
|
|
#define LMAX sizeof(user.ut_line)
|
|
#define HMAX sizeof(user.ut_host)
|
|
|
|
struct person { /* one for each person fingered */
|
|
char *name; /* name */
|
|
char tty[LMAX+1]; /* null terminated tty line */
|
|
char host[HMAX+1]; /* null terminated remote host name */
|
|
long loginat; /* time of (last) login */
|
|
long idletime; /* how long idle (if logged in) */
|
|
char *realname; /* pointer to full name */
|
|
struct passwd *pwd; /* structure of /etc/passwd stuff */
|
|
char loggedin; /* person is logged in */
|
|
char writable; /* tty is writable */
|
|
char original; /* this is not a duplicate entry */
|
|
struct person *link; /* link to next person */
|
|
char *where; /* terminal location */
|
|
char hostt[HMAX+1]; /* login host */
|
|
};
|
|
|
|
#include <minix/paths.h>
|
|
|
|
char LASTLOG[] = _PATH_LASTLOG; /* last login info */
|
|
char USERLOG[] = _PATH_UTMP; /* who is logged in */
|
|
char PLAN[] = "/.plan"; /* what plan file is */
|
|
char PROJ[] = "/.project"; /* what project file */
|
|
|
|
int unbrief = 1; /* -b option default */
|
|
int header = 1; /* -f option default */
|
|
int hack = 1; /* -h option default */
|
|
int idle = 0; /* -i option default */
|
|
int large = 0; /* -l option default */
|
|
int match = 1; /* -m option default */
|
|
int plan = 1; /* -p option default */
|
|
int unquick = 1; /* -q option default */
|
|
int small = 0; /* -s option default */
|
|
int wide = 1; /* -w option default */
|
|
|
|
int unshort;
|
|
int lf; /* LASTLOG file descriptor */
|
|
struct person *person1; /* list of people */
|
|
long tloc; /* current time */
|
|
|
|
#if !_MINIX
|
|
char *strcpy();
|
|
char *ctime();
|
|
#endif
|
|
|
|
char *prog_name;
|
|
|
|
int main (int argc, char *argv[]);
|
|
static void doall(void);
|
|
static void donames(char **args);
|
|
static void print(void);
|
|
static void fwopen(void);
|
|
static void decode(struct person *pers);
|
|
static void fwclose(void);
|
|
static int netfinger (char *name);
|
|
static int matchcmp (char *gname, char *login, char *given);
|
|
static void quickprint (struct person *pers);
|
|
static void shortprint (struct person *pers);
|
|
static void personprint (struct person *pers);
|
|
static int AlreadyPrinted(int uid);
|
|
static int AnyMail (char *name);
|
|
static struct passwd *pwdcopy(struct passwd *pfrom);
|
|
static void findidle (struct person *pers);
|
|
static int ltimeprint (char *dt, long *before, char *after);
|
|
static void stimeprint (long *dt);
|
|
static void findwhen (struct person *pers);
|
|
static int namecmp (char *name1, char *name2);
|
|
|
|
main(argc, argv)
|
|
int argc;
|
|
register char **argv;
|
|
{
|
|
FILE *fp;
|
|
register char *s;
|
|
|
|
prog_name= argv[0];
|
|
|
|
/* parse command line for (optional) arguments */
|
|
while (*++argv && **argv == COMMAND)
|
|
for (s = *argv + 1; *s; s++)
|
|
switch (*s) {
|
|
case 'b':
|
|
unbrief = 0;
|
|
break;
|
|
case 'f':
|
|
header = 0;
|
|
break;
|
|
case 'h':
|
|
hack = 0;
|
|
break;
|
|
case 'i':
|
|
idle = 1;
|
|
unquick = 0;
|
|
break;
|
|
case 'l':
|
|
large = 1;
|
|
break;
|
|
case 'm':
|
|
match = 0;
|
|
break;
|
|
case 'p':
|
|
plan = 0;
|
|
break;
|
|
case 'q':
|
|
unquick = 0;
|
|
break;
|
|
case 's':
|
|
small = 1;
|
|
break;
|
|
case 'w':
|
|
wide = 0;
|
|
break;
|
|
default:
|
|
fprintf(stderr, "Usage: finger [-bfhilmpqsw] [login1 [login2 ...] ]\n");
|
|
exit(1);
|
|
}
|
|
if (unquick || idle)
|
|
time(&tloc);
|
|
/*
|
|
* *argv == 0 means no names given
|
|
*/
|
|
if (*argv == 0)
|
|
doall();
|
|
else
|
|
donames(argv);
|
|
if (person1)
|
|
print();
|
|
exit(0);
|
|
}
|
|
|
|
static void doall()
|
|
{
|
|
register struct person *p;
|
|
register struct passwd *pw;
|
|
int uf;
|
|
char name[NMAX + 1];
|
|
|
|
unshort = large;
|
|
if ((uf = open(USERLOG, 0)) < 0) {
|
|
fprintf(stderr, "finger: error opening %s\n", USERLOG);
|
|
exit(2);
|
|
}
|
|
if (unquick) {
|
|
setpwent();
|
|
fwopen();
|
|
}
|
|
while (read(uf, (char *)&user, sizeof user) == sizeof user) {
|
|
if (user.ut_name[0] == 0)
|
|
continue;
|
|
if (person1 == 0)
|
|
p = person1 = (struct person *) malloc(sizeof *p);
|
|
else {
|
|
p->link = (struct person *) malloc(sizeof *p);
|
|
p = p->link;
|
|
}
|
|
bcopy(user.ut_name, name, NMAX);
|
|
name[NMAX] = 0;
|
|
bcopy(user.ut_line, p->tty, LMAX);
|
|
p->tty[LMAX] = 0;
|
|
bcopy(user.ut_host, p->host, HMAX);
|
|
p->host[HMAX] = 0;
|
|
p->loginat = user.ut_time;
|
|
p->pwd = 0;
|
|
p->loggedin = 1;
|
|
p->where = NULL;
|
|
if (unquick && (pw = getpwnam(name))) {
|
|
p->pwd = pwdcopy(pw);
|
|
decode(p);
|
|
p->name = p->pwd->pw_name;
|
|
} else
|
|
p->name = strcpy(malloc(strlen(name) + 1), name);
|
|
}
|
|
if (unquick) {
|
|
fwclose();
|
|
endpwent();
|
|
}
|
|
close(uf);
|
|
if (person1 == 0) {
|
|
printf("No one logged on\n");
|
|
return;
|
|
}
|
|
p->link = 0;
|
|
}
|
|
|
|
static void donames(argv)
|
|
char **argv;
|
|
{
|
|
register struct person *p;
|
|
register struct passwd *pw;
|
|
int uf;
|
|
|
|
/*
|
|
* get names from command line and check to see if they're
|
|
* logged in
|
|
*/
|
|
unshort = !small;
|
|
for (; *argv != 0; argv++) {
|
|
if (netfinger(*argv))
|
|
continue;
|
|
if (person1 == 0)
|
|
p = person1 = (struct person *) malloc(sizeof *p);
|
|
else {
|
|
p->link = (struct person *) malloc(sizeof *p);
|
|
p = p->link;
|
|
}
|
|
p->name = *argv;
|
|
p->loggedin = 0;
|
|
p->original = 1;
|
|
p->pwd = 0;
|
|
}
|
|
if (person1 == 0)
|
|
return;
|
|
p->link = 0;
|
|
/*
|
|
* if we are doing it, read /etc/passwd for the useful info
|
|
*/
|
|
if (unquick) {
|
|
setpwent();
|
|
if (!match) {
|
|
for (p = person1; p != 0; p = p->link)
|
|
if (pw = getpwnam(p->name))
|
|
p->pwd = pwdcopy(pw);
|
|
} else while ((pw = getpwent()) != 0) {
|
|
for (p = person1; p != 0; p = p->link) {
|
|
if (!p->original)
|
|
continue;
|
|
if (strcmp(p->name, pw->pw_name) != 0 &&
|
|
!matchcmp(pw->pw_gecos, pw->pw_name, p->name))
|
|
continue;
|
|
if (p->pwd == 0)
|
|
p->pwd = pwdcopy(pw);
|
|
else {
|
|
struct person *new;
|
|
/*
|
|
* handle multiple login names, insert
|
|
* new "duplicate" entry behind
|
|
*/
|
|
new = (struct person *)
|
|
malloc(sizeof *new);
|
|
new->pwd = pwdcopy(pw);
|
|
new->name = p->name;
|
|
new->original = 1;
|
|
new->loggedin = 0;
|
|
new->link = p->link;
|
|
p->original = 0;
|
|
p->link = new;
|
|
p = new;
|
|
}
|
|
}
|
|
}
|
|
endpwent();
|
|
}
|
|
/* Now get login information */
|
|
if ((uf = open(USERLOG, 0)) < 0) {
|
|
fprintf(stderr, "finger: error opening %s\n", USERLOG);
|
|
exit(2);
|
|
}
|
|
while (read(uf, (char *)&user, sizeof user) == sizeof user) {
|
|
if (*user.ut_name == 0)
|
|
continue;
|
|
for (p = person1; p != 0; p = p->link) {
|
|
if (p->loggedin == 2)
|
|
continue;
|
|
if (strncmp(p->pwd ? p->pwd->pw_name : p->name,
|
|
user.ut_name, NMAX) != 0)
|
|
continue;
|
|
if (p->loggedin == 0) {
|
|
bcopy(user.ut_line, p->tty, LMAX);
|
|
p->tty[LMAX] = 0;
|
|
bcopy(user.ut_host, p->host, HMAX);
|
|
p->host[HMAX] = 0;
|
|
p->loginat = user.ut_time;
|
|
p->loggedin = 1;
|
|
} else { /* p->loggedin == 1 */
|
|
struct person *new;
|
|
new = (struct person *) malloc(sizeof *new);
|
|
new->name = p->name;
|
|
bcopy(user.ut_line, new->tty, LMAX);
|
|
new->tty[LMAX] = 0;
|
|
bcopy(user.ut_host, new->host, HMAX);
|
|
new->host[HMAX] = 0;
|
|
new->loginat = user.ut_time;
|
|
new->pwd = p->pwd;
|
|
new->loggedin = 1;
|
|
new->original = 0;
|
|
new->link = p->link;
|
|
p->loggedin = 2;
|
|
p->link = new;
|
|
p = new;
|
|
}
|
|
}
|
|
}
|
|
close(uf);
|
|
if (unquick) {
|
|
fwopen();
|
|
for (p = person1; p != 0; p = p->link)
|
|
decode(p);
|
|
fwclose();
|
|
}
|
|
}
|
|
|
|
static void print()
|
|
{
|
|
register FILE *fp;
|
|
register struct person *p;
|
|
register char *s;
|
|
register c;
|
|
|
|
/*
|
|
* print out what we got
|
|
*/
|
|
if (header) {
|
|
if (unquick) {
|
|
if (!unshort)
|
|
if (wide)
|
|
printf("Login Name TTY Idle When Where\n");
|
|
else
|
|
printf("Login TTY Idle When Where\n");
|
|
} else {
|
|
printf("Login TTY When");
|
|
if (idle)
|
|
printf(" Idle");
|
|
putchar('\n');
|
|
}
|
|
}
|
|
for (p = person1; p != 0; p = p->link) {
|
|
if (!unquick) {
|
|
quickprint(p);
|
|
continue;
|
|
}
|
|
if (!unshort) {
|
|
shortprint(p);
|
|
continue;
|
|
}
|
|
personprint(p);
|
|
if (p->pwd != 0 && !AlreadyPrinted(p->pwd->pw_uid)) {
|
|
AnyMail(p->pwd->pw_name);
|
|
if (hack) {
|
|
s = malloc(strlen(p->pwd->pw_dir) +
|
|
sizeof PROJ);
|
|
strcpy(s, p->pwd->pw_dir);
|
|
strcat(s, PROJ);
|
|
if ((fp = fopen(s, "r")) != 0) {
|
|
printf("Project: ");
|
|
while ((c = getc(fp)) != EOF) {
|
|
if (c == '\n')
|
|
break;
|
|
if (isprint(c) || isspace(c))
|
|
putchar(c);
|
|
else
|
|
putchar(c ^ 100);
|
|
}
|
|
fclose(fp);
|
|
putchar('\n');
|
|
}
|
|
free(s);
|
|
}
|
|
if (plan) {
|
|
s = malloc(strlen(p->pwd->pw_dir) +
|
|
sizeof PLAN);
|
|
strcpy(s, p->pwd->pw_dir);
|
|
strcat(s, PLAN);
|
|
if ((fp = fopen(s, "r")) == 0) {
|
|
if (!NONOTHING) printf("No Plan.\n");
|
|
} else {
|
|
printf("Plan:\n");
|
|
while ((c = getc(fp)) != EOF)
|
|
if (isprint(c) || isspace(c))
|
|
putchar(c);
|
|
else
|
|
putchar(c ^ 100);
|
|
fclose(fp);
|
|
}
|
|
free(s);
|
|
}
|
|
}
|
|
if (p->link != 0)
|
|
putchar('\n');
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Duplicate a pwd entry.
|
|
* Note: Only the useful things (what the program currently uses) are copied.
|
|
*/
|
|
static struct passwd *
|
|
pwdcopy(pfrom)
|
|
register struct passwd *pfrom;
|
|
{
|
|
register struct passwd *pto;
|
|
|
|
pto = (struct passwd *) malloc(sizeof *pto);
|
|
#define savestr(s) strcpy(malloc(strlen(s) + 1), s)
|
|
pto->pw_name = savestr(pfrom->pw_name);
|
|
pto->pw_uid = pfrom->pw_uid;
|
|
pto->pw_gecos = savestr(pfrom->pw_gecos);
|
|
pto->pw_dir = savestr(pfrom->pw_dir);
|
|
pto->pw_shell = savestr(pfrom->pw_shell);
|
|
#undef savestr
|
|
return pto;
|
|
}
|
|
|
|
/*
|
|
* print out information on quick format giving just name, tty, login time
|
|
* and idle time if idle is set.
|
|
*/
|
|
static void quickprint(pers)
|
|
register struct person *pers;
|
|
{
|
|
printf("%-*.*s ", NMAX, NMAX, pers->name);
|
|
if (pers->loggedin) {
|
|
if (idle) {
|
|
findidle(pers);
|
|
printf("%c%-*s %-16.16s", pers->writable ? ' ' : '*',
|
|
LMAX, pers->tty, ctime(&pers->loginat));
|
|
ltimeprint(" ", &pers->idletime, "");
|
|
} else
|
|
printf(" %-*s %-16.16s", LMAX,
|
|
pers->tty, ctime(&pers->loginat));
|
|
putchar('\n');
|
|
} else
|
|
printf(" Not Logged In\n");
|
|
}
|
|
|
|
/*
|
|
* print out information in short format, giving login name, full name,
|
|
* tty, idle time, login time, and host.
|
|
*/
|
|
static void shortprint(pers)
|
|
register struct person *pers;
|
|
{
|
|
char *p;
|
|
char dialup;
|
|
|
|
if (pers->pwd == 0) {
|
|
printf("%-15s ???\n", pers->name);
|
|
return;
|
|
}
|
|
printf("%-*s", NMAX, pers->pwd->pw_name);
|
|
dialup = 0;
|
|
if (wide) {
|
|
if (pers->realname)
|
|
printf(" %-20.20s", pers->realname);
|
|
else
|
|
printf(" ??? ");
|
|
}
|
|
putchar(' ');
|
|
if (pers->loggedin && !pers->writable)
|
|
putchar('*');
|
|
else
|
|
putchar(' ');
|
|
if (*pers->tty) {
|
|
if (pers->tty[0] == 't' && pers->tty[1] == 't' &&
|
|
pers->tty[2] == 'y') {
|
|
if (pers->tty[3] == 'd' && pers->loggedin)
|
|
dialup = 1;
|
|
printf("%-2.2s ", pers->tty + 3);
|
|
} else
|
|
printf("%-2.2s ", pers->tty);
|
|
} else
|
|
printf(" ");
|
|
p = ctime(&pers->loginat);
|
|
if (pers->loggedin) {
|
|
stimeprint(&pers->idletime);
|
|
printf(" %3.3s %-5.5s ", p, p + 11);
|
|
} else if (pers->loginat == 0)
|
|
printf(" < . . . . >");
|
|
else if (tloc - pers->loginat >= 180L * 24 * 60 * 60)
|
|
printf(" <%-6.6s, %-4.4s>", p + 4, p + 20);
|
|
else
|
|
printf(" <%-12.12s>", p + 4);
|
|
if (pers->host[0])
|
|
printf(" %-20.20s", pers->host);
|
|
putchar('\n');
|
|
}
|
|
|
|
|
|
/*
|
|
* print out a person in long format giving all possible information.
|
|
* directory and shell are inhibited if unbrief is clear.
|
|
*/
|
|
static void
|
|
personprint(pers)
|
|
register struct person *pers;
|
|
{
|
|
if (pers->pwd == 0) {
|
|
printf("Login name: %-10s\t\t\tIn real life: ???\n",
|
|
pers->name);
|
|
return;
|
|
}
|
|
printf("Login name: %-10s", pers->pwd->pw_name);
|
|
if (pers->loggedin && !pers->writable)
|
|
printf(" (messages off) ");
|
|
else
|
|
printf(" ");
|
|
if (pers->realname)
|
|
printf("In real life: %s", pers->realname);
|
|
if (unbrief) {
|
|
printf("\nDirectory: %-25s", pers->pwd->pw_dir);
|
|
if (*pers->pwd->pw_shell)
|
|
printf("\tShell: %-s", pers->pwd->pw_shell);
|
|
}
|
|
if (pers->loggedin) {
|
|
register char *ep = ctime(&pers->loginat);
|
|
if (*pers->host) {
|
|
printf("\nOn since %15.15s on %s from %s",
|
|
&ep[4], pers->tty, pers->host);
|
|
ltimeprint("\n", &pers->idletime, " Idle Time");
|
|
} else {
|
|
printf("\nOn since %15.15s on %-*s",
|
|
&ep[4], LMAX, pers->tty);
|
|
ltimeprint("\t", &pers->idletime, " Idle Time");
|
|
}
|
|
} else if (pers->loginat == 0) {
|
|
if (lf >= 0) printf("\nNever logged in.");
|
|
} else if (tloc - pers->loginat > 180L * 24 * 60 * 60) {
|
|
register char *ep = ctime(&pers->loginat);
|
|
printf("\nLast login %10.10s, %4.4s on %s",
|
|
ep, ep+20, pers->tty);
|
|
if (*pers->host)
|
|
printf(" from %s", pers->host);
|
|
} else {
|
|
register char *ep = ctime(&pers->loginat);
|
|
printf("\nLast login %16.16s on %s", ep, pers->tty);
|
|
if (*pers->host)
|
|
printf(" from %s", pers->host);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
|
|
|
|
/*
|
|
* decode the information in the gecos field of /etc/passwd
|
|
*/
|
|
static void
|
|
decode(pers)
|
|
register struct person *pers;
|
|
{
|
|
char buffer[256];
|
|
register char *bp, *gp, *lp;
|
|
int alldigits;
|
|
int hasspace;
|
|
int len;
|
|
|
|
pers->realname = 0;
|
|
if (pers->pwd == 0)
|
|
return;
|
|
gp = pers->pwd->pw_gecos;
|
|
bp = buffer;
|
|
if (*gp == ASTERISK)
|
|
gp++;
|
|
while (*gp && *gp != COMMA) /* name */
|
|
if (*gp == SAMENAME) {
|
|
lp = pers->pwd->pw_name;
|
|
if (islower(*lp))
|
|
*bp++ = toupper(*lp++);
|
|
while (*bp++ = *lp++)
|
|
;
|
|
bp--;
|
|
gp++;
|
|
} else
|
|
*bp++ = *gp++;
|
|
*bp++ = 0;
|
|
if ((len = bp - buffer) > 1)
|
|
pers->realname = strcpy(malloc(len), buffer);
|
|
if (pers->loggedin)
|
|
findidle(pers);
|
|
else
|
|
findwhen(pers);
|
|
}
|
|
|
|
/*
|
|
* find the last log in of a user by checking the LASTLOG file.
|
|
* the entry is indexed by the uid, so this can only be done if
|
|
* the uid is known (which it isn't in quick mode)
|
|
*/
|
|
|
|
static void
|
|
fwopen()
|
|
{
|
|
if ((lf = open(LASTLOG, 0)) < 0) {
|
|
if (errno == ENOENT) return;
|
|
fprintf(stderr, "finger: %s open error\n", LASTLOG);
|
|
}
|
|
}
|
|
|
|
static void
|
|
findwhen(pers)
|
|
register struct person *pers;
|
|
{
|
|
struct utmp ll;
|
|
#define ll_line ut_line
|
|
#define ll_host ut_host
|
|
#define ll_time ut_time
|
|
|
|
int i;
|
|
|
|
if (lf >= 0) {
|
|
lseek(lf, (long)pers->pwd->pw_uid * sizeof ll, 0);
|
|
if ((i = read(lf, (char *)&ll, sizeof ll)) == sizeof ll) {
|
|
bcopy(ll.ll_line, pers->tty, LMAX);
|
|
pers->tty[LMAX] = 0;
|
|
bcopy(ll.ll_host, pers->host, HMAX);
|
|
pers->host[HMAX] = 0;
|
|
pers->loginat = ll.ll_time;
|
|
} else {
|
|
if (i != 0)
|
|
fprintf(stderr, "finger: %s read error\n",
|
|
LASTLOG);
|
|
pers->tty[0] = 0;
|
|
pers->host[0] = 0;
|
|
pers->loginat = 0L;
|
|
}
|
|
} else {
|
|
pers->tty[0] = 0;
|
|
pers->host[0] = 0;
|
|
pers->loginat = 0L;
|
|
}
|
|
}
|
|
|
|
static void fwclose()
|
|
{
|
|
if (lf >= 0)
|
|
close(lf);
|
|
}
|
|
|
|
/*
|
|
* find the idle time of a user by doing a stat on /dev/tty??,
|
|
* where tty?? has been gotten from USERLOG, supposedly.
|
|
*/
|
|
static void
|
|
findidle(pers)
|
|
register struct person *pers;
|
|
{
|
|
struct stat ttystatus;
|
|
static char buffer[20] = "/dev/";
|
|
long t;
|
|
#define TTYLEN 5
|
|
|
|
strcpy(buffer + TTYLEN, pers->tty);
|
|
buffer[TTYLEN+LMAX] = 0;
|
|
if (stat(buffer, &ttystatus) < 0) {
|
|
fprintf(stderr, "finger: Can't stat %s\n", buffer);
|
|
exit(4);
|
|
}
|
|
time(&t);
|
|
if (t < ttystatus.st_atime)
|
|
pers->idletime = 0L;
|
|
else
|
|
pers->idletime = t - ttystatus.st_atime;
|
|
pers->writable = (ttystatus.st_mode & TALKABLE) == TALKABLE;
|
|
}
|
|
|
|
/*
|
|
* print idle time in short format; this program always prints 4 characters;
|
|
* if the idle time is zero, it prints 4 blanks.
|
|
*/
|
|
static void
|
|
stimeprint(dt)
|
|
long *dt;
|
|
{
|
|
register struct tm *delta;
|
|
|
|
delta = gmtime(dt);
|
|
if (delta->tm_yday == 0)
|
|
if (delta->tm_hour == 0)
|
|
if (delta->tm_min == 0)
|
|
printf(" ");
|
|
else
|
|
printf(" %2d", delta->tm_min);
|
|
else
|
|
if (delta->tm_hour >= 10)
|
|
printf("%3d:", delta->tm_hour);
|
|
else
|
|
printf("%1d:%02d",
|
|
delta->tm_hour, delta->tm_min);
|
|
else
|
|
printf("%3dd", delta->tm_yday);
|
|
}
|
|
|
|
/*
|
|
* print idle time in long format with care being taken not to pluralize
|
|
* 1 minutes or 1 hours or 1 days.
|
|
* print "prefix" first.
|
|
*/
|
|
static int
|
|
ltimeprint(before, dt, after)
|
|
long *dt;
|
|
char *before, *after;
|
|
{
|
|
register struct tm *delta;
|
|
|
|
delta = gmtime(dt);
|
|
if (delta->tm_yday == 0 && delta->tm_hour == 0 && delta->tm_min == 0 &&
|
|
delta->tm_sec <= 10)
|
|
return (0);
|
|
printf("%s", before);
|
|
if (delta->tm_yday >= 10)
|
|
printf("%d days", delta->tm_yday);
|
|
else if (delta->tm_yday > 0)
|
|
printf("%d day%s %d hour%s",
|
|
delta->tm_yday, delta->tm_yday == 1 ? "" : "s",
|
|
delta->tm_hour, delta->tm_hour == 1 ? "" : "s");
|
|
else
|
|
if (delta->tm_hour >= 10)
|
|
printf("%d hours", delta->tm_hour);
|
|
else if (delta->tm_hour > 0)
|
|
printf("%d hour%s %d minute%s",
|
|
delta->tm_hour, delta->tm_hour == 1 ? "" : "s",
|
|
delta->tm_min, delta->tm_min == 1 ? "" : "s");
|
|
else
|
|
if (delta->tm_min >= 10)
|
|
printf("%2d minutes", delta->tm_min);
|
|
else if (delta->tm_min == 0)
|
|
printf("%2d seconds", delta->tm_sec);
|
|
else
|
|
printf("%d minute%s %d second%s",
|
|
delta->tm_min,
|
|
delta->tm_min == 1 ? "" : "s",
|
|
delta->tm_sec,
|
|
delta->tm_sec == 1 ? "" : "s");
|
|
printf("%s", after);
|
|
}
|
|
|
|
static int
|
|
matchcmp(gname, login, given)
|
|
register char *gname;
|
|
char *login;
|
|
char *given;
|
|
{
|
|
char buffer[100];
|
|
register char *bp, *lp;
|
|
register c;
|
|
|
|
if (*gname == ASTERISK)
|
|
gname++;
|
|
lp = 0;
|
|
bp = buffer;
|
|
for (;;)
|
|
switch (c = *gname++) {
|
|
case SAMENAME:
|
|
for (lp = login; bp < buffer + sizeof buffer
|
|
&& (*bp++ = *lp++);)
|
|
;
|
|
bp--;
|
|
break;
|
|
case ' ':
|
|
case COMMA:
|
|
case '\0':
|
|
*bp = 0;
|
|
if (namecmp(buffer, given))
|
|
return (1);
|
|
if (c == COMMA || c == 0)
|
|
return (0);
|
|
bp = buffer;
|
|
break;
|
|
default:
|
|
if (bp < buffer + sizeof buffer)
|
|
*bp++ = c;
|
|
}
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
static int
|
|
namecmp(name1, name2)
|
|
register char *name1, *name2;
|
|
{
|
|
register c1, c2;
|
|
|
|
for (;;) {
|
|
c1 = *name1++;
|
|
if (islower(c1))
|
|
c1 = toupper(c1);
|
|
c2 = *name2++;
|
|
if (islower(c2))
|
|
c2 = toupper(c2);
|
|
if (c1 != c2)
|
|
break;
|
|
if (c1 == 0)
|
|
return (1);
|
|
}
|
|
if (!c1) {
|
|
for (name2--; isdigit(*name2); name2++)
|
|
;
|
|
if (*name2 == 0)
|
|
return (1);
|
|
} else if (!c2) {
|
|
for (name1--; isdigit(*name1); name1++)
|
|
;
|
|
if (*name2 == 0)
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
#if NONET
|
|
static int
|
|
netfinger(name)
|
|
char *name;
|
|
{
|
|
return 0;
|
|
}
|
|
#else
|
|
static int
|
|
netfinger(name)
|
|
char *name;
|
|
{
|
|
char *host;
|
|
char fname[100];
|
|
struct hostent *hp;
|
|
struct servent *sp;
|
|
int s, result;
|
|
#if !_MINIX
|
|
char *rindex();
|
|
#endif
|
|
register FILE *f;
|
|
register int c;
|
|
register int lastc;
|
|
nwio_tcpconf_t tcpconf;
|
|
nwio_tcpcl_t tcpconnopt;
|
|
char *tcp_device;
|
|
|
|
if (name == NULL)
|
|
return (0);
|
|
host = rindex(name, '@');
|
|
if (host == NULL)
|
|
return (0);
|
|
*host++ = 0;
|
|
hp = gethostbyname(host);
|
|
if (hp == NULL) {
|
|
static struct hostent def;
|
|
static ipaddr_t defaddr;
|
|
static char namebuf[128];
|
|
|
|
defaddr = inet_addr(host);
|
|
if (defaddr == -1) {
|
|
printf("unknown host: %s\n", host);
|
|
return (1);
|
|
}
|
|
strcpy(namebuf, host);
|
|
def.h_name = namebuf;
|
|
def.h_addr = (char *)&defaddr;
|
|
def.h_length = sizeof (ipaddr_t);
|
|
def.h_addrtype = AF_INET;
|
|
def.h_aliases = 0;
|
|
hp = &def;
|
|
}
|
|
printf("[%s] ", hp->h_name);
|
|
fflush(stdout);
|
|
|
|
tcp_device= getenv("TCP_DEVICE");
|
|
if (tcp_device == NULL)
|
|
tcp_device= TCP_DEVICE;
|
|
s= open (tcp_device, O_RDWR);
|
|
if (s == -1)
|
|
{
|
|
fprintf(stderr, "%s: unable to open %s (%s)\n",
|
|
prog_name, tcp_device, strerror(errno));
|
|
exit(1);
|
|
}
|
|
tcpconf.nwtc_flags= NWTC_LP_SEL | NWTC_SET_RA | NWTC_SET_RP;
|
|
tcpconf.nwtc_remaddr= *(ipaddr_t *)hp->h_addr;
|
|
tcpconf.nwtc_remport= htons(TCPPORT_FINGER);
|
|
|
|
result= ioctl (s, NWIOSTCPCONF, &tcpconf);
|
|
if (result<0)
|
|
{
|
|
fprintf(stderr, "%s\n", strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
tcpconnopt.nwtcl_flags= 0;
|
|
|
|
do
|
|
{
|
|
result= ioctl (s, NWIOTCPCONN, &tcpconnopt);
|
|
if (result<0 && errno== EAGAIN)
|
|
{
|
|
fprintf(stderr, "got EAGAIN error, sleeping 2s\n");
|
|
sleep(2);
|
|
}
|
|
} while (result<0 && errno == EAGAIN);
|
|
if (result<0)
|
|
{
|
|
fprintf(stderr, "%s\n", strerror(errno));
|
|
exit(1);
|
|
}
|
|
printf("\r\n");
|
|
if (large) write(s, "/W ", 3);
|
|
write(s, name, strlen(name));
|
|
write(s, "\r\n", 2);
|
|
f = fdopen(s, "r");
|
|
while ((c = getc(f)) != EOF) {
|
|
/*
|
|
switch(c) {
|
|
case 0210:
|
|
case 0211:
|
|
case 0212:
|
|
case 0214:
|
|
c -= 0200;
|
|
break;
|
|
case 0215:
|
|
c = '\n';
|
|
break;
|
|
}
|
|
*/
|
|
c &= ~0200;
|
|
if (c == '\r')
|
|
{
|
|
c= getc(f) & ~0200;
|
|
if (c == '\012')
|
|
{
|
|
lastc= c;
|
|
putchar('\n');
|
|
continue;
|
|
}
|
|
else
|
|
putchar('\r');
|
|
}
|
|
lastc = c;
|
|
if (isprint(c) || isspace(c))
|
|
putchar(c);
|
|
else
|
|
putchar(c ^ 100);
|
|
}
|
|
if (lastc != '\n')
|
|
putchar('\n');
|
|
(void)fclose(f);
|
|
return (1);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* AnyMail - takes a username (string pointer thereto), and
|
|
* prints on standard output whether there is any unread mail,
|
|
* and if so, how old it is. (JCM@Shasta 15 March 80)
|
|
*/
|
|
#define preamble "/usr/spool/mail/" /* mailboxes are there */
|
|
static int
|
|
AnyMail(name)
|
|
char *name;
|
|
{
|
|
struct stat buf; /* space for file status buffer */
|
|
char *mbxdir = preamble; /* string with path preamble */
|
|
char *mbxpath; /* space for entire pathname */
|
|
|
|
#if !_MINIX
|
|
char *ctime(); /* convert longword time to ascii */
|
|
#endif
|
|
char *timestr;
|
|
|
|
mbxpath = malloc(strlen(name) + strlen(preamble) + 1);
|
|
|
|
strcpy(mbxpath, mbxdir); /* copy preamble into path name */
|
|
strcat(mbxpath, name); /* concatenate user name to path */
|
|
|
|
if (stat(mbxpath, &buf) == -1 || buf.st_size == 0) {
|
|
/* Mailbox is empty or nonexistent */
|
|
if (!NONOTHING) printf("No unread mail\n");
|
|
} else {
|
|
if (buf.st_mtime == buf.st_atime) {
|
|
/* There is something in the mailbox, but we can't really
|
|
* be sure whether it is mail held there by the user
|
|
* or a (single) new message that was placed in a newly
|
|
* recreated mailbox, so we punt and call it "unread mail."
|
|
*/
|
|
printf("Unread mail since ");
|
|
printf(ctime(&buf.st_mtime));
|
|
} else {
|
|
/* New mail has definitely arrived since the last time
|
|
* mail was read. mtime is the time the most recent
|
|
* message arrived; atime is either the time the oldest
|
|
* unread message arrived, or the last time the mail
|
|
* was read.
|
|
*/
|
|
printf("New mail received ");
|
|
timestr = ctime(&buf.st_mtime); /* time last modified */
|
|
timestr[24] = '\0'; /* suppress newline (ugh) */
|
|
printf(timestr);
|
|
printf(";\n unread since ");
|
|
printf(ctime(&buf.st_atime)); /* time last accessed */
|
|
}
|
|
}
|
|
|
|
free(mbxpath);
|
|
}
|
|
|
|
/*
|
|
* return true iff we've already printed project/plan for this uid;
|
|
* if not, enter this uid into table (so this function has a side-effect.)
|
|
*/
|
|
#define PPMAX 200 /* assume no more than 200 logged-in users */
|
|
int PlanPrinted[PPMAX+1];
|
|
int PPIndex = 0; /* index of next unused table entry */
|
|
|
|
static int
|
|
AlreadyPrinted(uid)
|
|
int uid;
|
|
{
|
|
int i = 0;
|
|
|
|
while (i++ < PPIndex) {
|
|
if (PlanPrinted[i] == uid)
|
|
return(1);
|
|
}
|
|
if (i < PPMAX) {
|
|
PlanPrinted[i] = uid;
|
|
PPIndex++;
|
|
}
|
|
return(0);
|
|
}
|