![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lastcomm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb|
Return to lastcomm.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)lastcomm.c 4.9 (Berkeley) 9/8/83";
3: #endif
4:
5: /*
6: * last command
7: */
8: #include <sys/param.h>
9: #include <sys/acct.h>
10: #include <sys/file.h>
11:
12: #include <stdio.h>
13: #include <pwd.h>
14: #include <sys/stat.h>
15: #include <utmp.h>
16: #include <struct.h>
17: #include <ctype.h>
18:
19: struct acct buf[DEV_BSIZE / sizeof (struct acct)];
20:
21: time_t expand();
22: char *flagbits();
23: char *getname();
24: char *getdev();
25:
26: main(argc, argv)
27: char *argv[];
28: {
29: register int bn, cc;
30: register struct acct *acp;
31: int fd;
32: struct stat sb;
33:
34: fd = open("/usr/adm/acct", O_RDONLY);
35: if (fd < 0) {
36: perror("/usr/adm/acct");
37: exit(1);
38: }
39: fstat(fd, &sb);
40: for (bn = btodb(sb.st_size) - 1; bn >= 0; bn--) {
41: lseek(fd, bn * DEV_BSIZE, L_SET);
42: cc = read(fd, buf, DEV_BSIZE);
43: if (cc < 0) {
44: perror("read");
45: break;
46: }
47: acp = buf + (cc / sizeof (buf[0])) - 1;
48: for (; acp >= buf; acp--) {
49: register char *cp;
50: time_t x =
51: expand(acp->ac_utime) + expand(acp->ac_stime);
52:
53: acp->ac_comm[10] = '\0';
54: if (*acp->ac_comm == '\0')
55: strcpy(acp->ac_comm, "?");
56: for (cp = acp->ac_comm; *cp; cp++)
57: if (iscntrl(*cp))
58: *cp = '?';
59: if (!ok(argc, argv, acp) && argc != 1)
60: continue;
61: printf("%-*s %s %-*s %-*s %4d sec%s %.16s\n",
62: fldsiz(acct, ac_comm), acp->ac_comm,
63: flagbits(acp->ac_flag),
64: fldsiz(utmp, ut_name), getname(acp->ac_uid),
65: fldsiz(utmp, ut_line), getdev(acp->ac_tty),
66: x, x > 1 || x == 0 ? "s" : " ",
67: ctime(&acp->ac_btime));
68: }
69: }
70: }
71:
72: time_t
73: expand (t)
74: unsigned t;
75: {
76: register time_t nt;
77:
78: nt = t & 017777;
79: t >>= 13;
80: while (t) {
81: t--;
82: nt <<= 3;
83: }
84: return (nt);
85: }
86:
87: char *
88: flagbits(f)
89: register int f;
90: {
91: register int i = 0;
92: static char flags[20];
93:
94: #define BIT(flag, ch) flags[i++] = (f & flag) ? ch : ' '
95: BIT(ASU, 'S');
96: BIT(AFORK, 'F');
97: BIT(ACOMPAT, 'C');
98: BIT(ACORE, 'D');
99: BIT(AXSIG, 'X');
100: flags[i] = '\0';
101: return (flags);
102: }
103:
104: ok(argc, argv, acp)
105: register int argc;
106: register char *argv[];
107: register struct acct *acp;
108: {
109: register int j;
110:
111: for (j = 1; j < argc; j++)
112: if (strcmp(getname(acp->ac_uid), argv[j]) &&
113: strcmp(getdev(acp->ac_tty), argv[j]) &&
114: strcmp(acp->ac_comm, argv[j]))
115: break;
116: return (j == argc);
117: }
118:
119: /* should be done with nameserver or database */
120:
121: struct utmp utmp;
122:
123: #define NUID 2048
124: #define NMAX (sizeof (utmp.ut_name))
125:
126: char names[NUID][NMAX+1];
127: char outrangename[NMAX+1];
128: int outrangeuid = -1;
129:
130: char *
131: getname(uid)
132: {
133: register struct passwd *pw;
134: static init;
135: struct passwd *getpwent();
136:
137: if (uid >= 0 && uid < NUID && names[uid][0])
138: return (&names[uid][0]);
139: if (uid >= 0 && uid == outrangeuid)
140: return (outrangename);
141: if (init == 2) {
142: if (uid < NUID)
143: return (0);
144: setpwent();
145: while (pw = getpwent()) {
146: if (pw->pw_uid != uid)
147: continue;
148: outrangeuid = pw->pw_uid;
149: strncpy(outrangename, pw->pw_name, NMAX);
150: endpwent();
151: return (outrangename);
152: }
153: endpwent();
154: return (0);
155: }
156: if (init == 0)
157: setpwent(), init = 1;
158: while (pw = getpwent()) {
159: if (pw->pw_uid < 0 || pw->pw_uid >= NUID) {
160: if (pw->pw_uid == uid) {
161: outrangeuid = pw->pw_uid;
162: strncpy(outrangename, pw->pw_name, NMAX);
163: return (outrangename);
164: }
165: continue;
166: }
167: if (names[pw->pw_uid][0])
168: continue;
169: strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
170: if (pw->pw_uid == uid)
171: return (&names[uid][0]);
172: }
173: init = 2;
174: endpwent();
175: return (0);
176: }
177:
178: #include <sys/dir.h>
179:
180: #define N_DEVS 43 /* hash value for device names */
181: #define NDEVS 500 /* max number of file names in /dev */
182:
183: struct devhash {
184: dev_t dev_dev;
185: char dev_name [fldsiz(utmp, ut_line) + 1];
186: struct devhash * dev_nxt;
187: };
188: struct devhash *dev_hash[N_DEVS];
189: struct devhash *dev_chain;
190: #define HASH(d) (((int) d) % N_DEVS)
191:
192: setupdevs()
193: {
194: register DIR * fd;
195: register struct devhash * hashtab;
196: register ndevs = NDEVS;
197: struct direct * dp;
198:
199: if ((fd = opendir("/dev")) == NULL) {
200: perror("/dev");
201: return;
202: }
203: hashtab = (struct devhash *)malloc(NDEVS * sizeof(struct devhash));
204: if (hashtab == (struct devhash *)0) {
205: fprintf(stderr, "No mem for dev table\n");
206: closedir(fd);
207: return;
208: }
209: while (dp = readdir(fd)) {
210: if (dp->d_ino == 0)
211: continue;
212: if (dp->d_name[0] != 't' && strcmp(dp->d_name, "console"))
213: continue;
214: strncpy(hashtab->dev_name, dp->d_name, fldsiz(utmp, ut_line));
215: hashtab->dev_name[fldsiz(utmp, ut_line)] = 0;
216: hashtab->dev_nxt = dev_chain;
217: dev_chain = hashtab;
218: hashtab++;
219: if (--ndevs <= 0)
220: break;
221: }
222: closedir(fd);
223: }
224:
225: char *
226: getdev(dev)
227: dev_t dev;
228: {
229: register struct devhash *hp, *nhp;
230: struct stat statb;
231: char name[fldsiz(devhash, dev_name) + 6];
232: static dev_t lastdev = (dev_t) -1;
233: static char *lastname;
234: static int init = 0;
235:
236: if (dev == NODEV)
237: return ("__");
238: if (dev == lastdev)
239: return (lastname);
240: if (!init) {
241: setupdevs();
242: init++;
243: }
244: for (hp = dev_hash[HASH(dev)]; hp; hp = hp->dev_nxt)
245: if (hp->dev_dev == dev) {
246: lastdev = dev;
247: return (lastname = hp->dev_name);
248: }
249: for (hp = dev_chain; hp; hp = nhp) {
250: nhp = hp->dev_nxt;
251: strcpy(name, "/dev/");
252: strcat(name, hp->dev_name);
253: if (stat(name, &statb) < 0) /* name truncated usually */
254: continue;
255: if ((statb.st_mode & S_IFMT) != S_IFCHR)
256: continue;
257: hp->dev_dev = statb.st_rdev;
258: hp->dev_nxt = dev_hash[HASH(hp->dev_dev)];
259: dev_hash[HASH(hp->dev_dev)] = hp;
260: if (hp->dev_dev == dev) {
261: dev_chain = nhp;
262: lastdev = dev;
263: return (lastname = hp->dev_name);
264: }
265: }
266: dev_chain = (struct devhash *) 0;
267: return ("??");
268: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.