1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * Portions of such source code were derived from Berkeley 4.3 BSD
31 * under license from the Regents of the University of California.
32 */
33
34 /*
35 * utmpd - utmp daemon
36 *
37 * This program receives requests from pututxline(3)
38 * via a named pipe to watch the process to make sure it cleans up
39 * its utmpx entry on termination.
40 * The program keeps a list of procs
41 * and uses poll() on their /proc files to detect termination.
42 * Also the program periodically scans the /etc/utmpx file for
43 * processes that aren't in the table so they can be watched.
44 *
45 * If utmpd doesn't hear back over the pipe from pututline(3) that
46 * the process has removed its entry it cleans the entry when the
47 * the process terminates.
48 * The AT&T Copyright above is there since we borrowed the pipe
49 * mechanism from init(1m).
50 */
51
52
53 #include <sys/types.h>
54 #include <signal.h>
55 #include <stdio.h>
56 #include <stdio_ext.h>
57 #include <unistd.h>
58 #include <utmpx.h>
59 #include <errno.h>
60 #include <termio.h>
61 #include <sys/termios.h>
62 #include <sys/tty.h>
63 #include <ctype.h>
64 #include <sys/stat.h>
65 #include <sys/statvfs.h>
66 #include <fcntl.h>
67 #include <time.h>
68 #include <sys/stropts.h>
69 #include <wait.h>
70 #include <syslog.h>
71 #include <stdlib.h>
72 #include <string.h>
73 #include <poll.h>
74 #include <deflt.h>
75 #include <procfs.h>
76 #include <sys/resource.h>
77
78 #define dprintf(x) if (Debug) (void) printf x
79
80 /*
81 * Memory allocation keyed off MAX_FDS
82 */
83 #define MAX_FDS 4064 /* Maximum # file descriptors */
84 #define EXTRA_MARGIN 32 /* Allocate this many more FDS over Max_Fds */
85 /*
86 * MAX_POLLNV & RESETS - paranoia to cover an error case that might not exist
87 */
88 #define MAX_POLL_ERRS 1024 /* Count of bad errors */
89 #define MAX_RESETS 1024 /* Maximum times to reload tables */
90 #define POLL_TIMEOUT 300 /* Default Timeout for poll() in seconds */
91 #define CLEANIT 1 /* Used by rem_pid() */
92 #define DONT_CLEAN 0 /* Used by rem_pid() */
93 #define UTMP_DEFAULT "/etc/default/utmpd"
94 #define WARN_TIME 3600 /* seconds between utmp checks */
95 #define WTMPX_UFREQ 60 /* seconds between updating WTMPX's atime */
96
97
98 /*
99 * The pidrec structure describes the data shipped down the pipe to
100 * us from the pututxline() library in
101 * lib/libc/port/gen/getutx.c
102 */
103
104 /*
105 * pd_type's
106 */
107 #define ADDPID 1
108 #define REMPID 2
109
110 struct pidrec {
111 int pd_type; /* Command type */
112 pid_t pd_pid; /* pid to add or remove */
113 };
114
115
116 /*
117 * Since this program uses poll(2) and poll takes an array of file descriptors
118 * as an argument we maintain our data in tables.
119 * One table is the file descriptor array for poll, another parallel
120 * array is a table which contains the process ID of the corresponding
121 * open fd. These tables are kept sorted by process ID for quick lookups.
122 */
123
124 struct pidentry {
125 pid_t pl_pid; /* pid to watch for */
126 int pl_status; /* Exit status of proc */
127 };
128
129 static struct pidentry *pidtable = NULL;
130
131 static pollfd_t *fdtable = NULL;
132
133 static int pidcnt = 0; /* Number of procs being watched */
134 static char *prog_name; /* To save the invocation name away */
135 static char *UTMPPIPE_DIR = "/var/run";
136 static char *UTMPPIPE = "/var/run/utmppipe";
137 static int Pfd = -1; /* File descriptor of named pipe */
138 static int Poll_timeout = POLL_TIMEOUT;
139 static int WTMPXfd = -1; /* File descriptor of WTMPX_FILE */
140 static int WTMPX_ufreq = WTMPX_UFREQ;
141 static int Debug = 0; /* Set by command line argument */
142 static int Max_fds = MAX_FDS;
143
144 /*
145 * This program has three main components plus utilities and debug routines
146 * Receiver - receives the process ID or process for us to watch.
147 * (Uses a named pipe to get messages)
148 * Watcher - Use poll(2) to watch for processes to die so they
149 * can be cleaned up (get marked as DEAD_PROCESS)
150 * Scanner - periodically scans the utmpx file for stale entries
151 * or live entries that we don't know about.
152 */
153
154 static int wait_for_pids(); /* Watcher - uses poll */
155 static void scan_utmps(); /* Scanner, reads utmpx file */
156 static void drain_pipe(); /* Receiver - reads mesgs over UTMPPIPE */
157 static void setup_pipe(); /* For setting up receiver */
158
159 static void add_pid(); /* Adds a process to the table */
160 static void rem_pid(); /* Removes a process from the table */
161 static int find_pid(); /* Finds a process in the table */
162 static int proc_to_fd(); /* Takes a pid and returns an fd for its proc */
163 static void load_tables(); /* Loads up the tables the first time around */
164 static int pidcmp(); /* For sorting pids */
165
166 static void clean_entry(); /* Removes entry from our table and calls ... */
167 static void clean_utmpx_ent(); /* Cleans a utmpx entry */
168
169 static void fatal() __NORETURN; /* Prints error message and calls exit */
170 static void nonfatal(); /* Prints error message */
171 static void print_tables(); /* Prints out internal tables for Debug */
172 static int proc_is_alive(pid_t pid); /* Check if a process is alive */
173 static void warn_utmp(void);
174
175 /*
176 * main() - Main does basic setup and calls wait_for_pids() to do the work
177 */
178
179 int
180 main(argc, argv)
181 char **argv;
182 {
183 char *defp;
184 struct rlimit rlim;
185 int i;
186 time_t curtime, now;
187
188 prog_name = argv[0]; /* Save invocation name */
189
190 if (getuid() != 0) {
191 (void) fprintf(stderr,
192 "You must be root to run this program\n");
193 fatal("You must be root to run this program");
194 }
195
196 if (argc > 1) {
197 if ((argc == 2 && (int)strlen(argv[1]) >= 2) &&
198 (argv[1][0] == '-' && argv[1][1] == 'd')) {
199 Debug = 1;
200 } else {
201 (void) fprintf(stderr,
202 "%s: Wrong number of arguments\n", prog_name);
203 (void) fprintf(stderr,
204 "Usage: %s [-debug]\n", prog_name);
205 exit(2);
206 }
207 }
208
209 /*
210 * Read defaults file for poll timeout
211 */
212 if (defopen(UTMP_DEFAULT) == 0) {
213 if ((defp = defread("SCAN_PERIOD=")) != NULL) {
214 Poll_timeout = atol(defp);
215 dprintf(("Poll timeout set to %d\n", Poll_timeout));
216 }
217
218 if ((defp = defread("WTMPX_UPDATE_FREQ=")) != NULL) {
219 WTMPX_ufreq = atol(defp);
220 dprintf(("WTMPX update frequency set to %d\n",
221 WTMPX_ufreq));
222 }
223
224 /*
225 * Paranoia - if polling on large number of FDs is expensive /
226 * buggy the number can be set lower in the field.
227 */
228 if ((defp = defread("MAX_FDS=")) != NULL) {
229 Max_fds = atol(defp);
230 dprintf(("Max_fds set to %d\n", Max_fds));
231 }
232 (void) defopen((char *)NULL);
233 }
234
235 if (Debug == 0) {
236 /*
237 * Daemonize ourselves
238 */
239 if (fork()) {
240 exit(0);
241 }
242 (void) close(0);
243 (void) close(1);
244 (void) close(2);
245 /*
246 * We open these to avoid accidentally writing to a proc file
247 */
248 (void) open("/dev/null", O_RDONLY);
249 (void) open("/dev/null", O_WRONLY);
250 (void) open("/dev/null", O_WRONLY);
251 (void) setsid(); /* release process from tty */
252 }
253
254 openlog(prog_name, LOG_PID, LOG_DAEMON); /* For error messages */
255 warn_utmp(); /* check to see if utmp came back by accident */
256
257 /*
258 * Allocate the pidtable and fdtable. An earlier version did
259 * this as we go, but this is simpler.
260 */
261 if ((pidtable = malloc(Max_fds * sizeof (struct pidentry))) == NULL)
262 fatal("Malloc failed");
263 if ((fdtable = malloc(Max_fds * sizeof (pollfd_t))) == NULL)
264 fatal("Malloc failed");
265
266 /*
267 * Up the limit on FDs
268 */
269 if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
270 rlim.rlim_cur = Max_fds + EXTRA_MARGIN + 1;
271 rlim.rlim_max = Max_fds + EXTRA_MARGIN + 1;
272 if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) {
273 fatal("Out of File Descriptors");
274 }
275 } else
276 fatal("getrlimit returned failure");
277
278 (void) enable_extended_FILE_stdio(-1, -1);
279
280 if ((WTMPXfd = open(WTMPX_FILE, O_RDONLY)) < 0)
281 nonfatal("WARNING: unable to open " WTMPX_FILE "for update.");
282
283 /*
284 * Loop here scanning the utmpx file and waiting for processes
285 * to terminate. Most of the activity is directed out of wait_for_pids.
286 * If wait_for_pids fails we reload the table and try again.
287 */
288
289 curtime = time(NULL);
290 dprintf(("utmp warning timer set to %d seconds\n", WARN_TIME));
291
292 for (i = 0; i < MAX_RESETS; i++) {
293 load_tables();
294 while (wait_for_pids() == 1) {
295 now = time(NULL);
296 if ((now - curtime) >= WARN_TIME) {
297 dprintf(("utmp warning timer expired\n"));
298 warn_utmp();
299 curtime = now;
300 }
301 }
302 }
303
304 (void) close(WTMPXfd);
305
306 /*
307 * We only get here if we had a bunch of resets - so give up
308 */
309 fatal("Too many resets, giving up");
310 return (1);
311 }
312
313 /*
314 * load_tables() - Designed to be called repeatedly if we need to
315 * restart things. Zeros the pidcount, and loads
316 * the tables by scanning utmpx
317 */
318
319 static void
320 load_tables()
321 {
322 int i;
323
324 dprintf(("Load tables\n"));
325
326 /*
327 * Close any open files.
328 */
329 for (i = 0; i < pidcnt; i++)
330 (void) close(fdtable[i].fd);
331
332 pidcnt = 0;
333 Pfd = -1;
334 setup_pipe(); /* Setup the pipe to receive messages */
335 scan_utmps(); /* Read in USER procs entries to watch */
336 }
337
338
339 /*
340 * *** The Watcher ***
341 *
342 * Wait_for_pids - wait for the termination of a process in the table.
343 * Returns 1 on normal exist, 0 on failure.
344 */
345
346 static int
347 wait_for_pids()
348 {
349 register struct pollfd *pfd;
350 register int i;
351 pid_t pid;
352 int ret_val;
353 int timeout;
354 static time_t last_timeout = 0;
355 static int bad_error = 0; /* Count of POLL errors */
356
357 /*
358 * First time through we initialize last_timeout to now.
359 */
360 if (last_timeout == 0)
361 last_timeout = time(NULL);
362
363 /*
364 * Recalculate timeout - checking to see if time expired.
365 */
366
367 if ((timeout = Poll_timeout - (time(NULL) - last_timeout)) <= 0) {
368 timeout = Poll_timeout;
369 last_timeout = time(NULL);
370 scan_utmps();
371 }
372
373 fdtable[0].events = POLLRDNORM;
374
375 for (i = 0; i < (timeout / WTMPX_ufreq); i++) {
376
377 /*
378 * Loop here while getting EAGAIN
379 */
380
381 while ((ret_val = poll(fdtable, pidcnt, WTMPX_ufreq*1000)) < 0)
382 if (errno == EAGAIN)
383 (void) sleep(2);
384 else
385 fatal("poll");
386 /*
387 * The results of pread(2) are discarded; we only want
388 * to update the access time of WTMPX_FILE.
389 * Periodically touching WTMPX helps determine when the
390 * OS became unavailable when the OS boots again .
391 * See PSARC 2004/462 for more information.
392 */
393
394 (void) pread(WTMPXfd, (void *)&pid, sizeof (pid), 0);
395
396 if (ret_val) /* file descriptor(s) need attention */
397 break;
398 }
399
400 /*
401 * If ret_val == 0 the poll timed out - reset last_time and
402 * call scan_utmps
403 */
404 if (ret_val == 0) {
405 last_timeout = time(NULL);
406 scan_utmps();
407 return (1);
408 }
409
410 /*
411 * Check the pipe file descriptor
412 */
413 if (fdtable[0].revents & POLLRDNORM) {
414 drain_pipe();
415 fdtable[0].revents = 0;
416 ret_val--;
417 }
418
419 (void) sleep(5); /* Give parents time to cleanup children */
420
421 /*
422 * We got here because the status of one of the pids that
423 * we are polling on has changed, so search the table looking
424 * for the entry.
425 *
426 * The table is scanned backwards so that entries can be removed
427 * while we go since the table is compacted from high down to low
428 */
429 for (i = pidcnt - 1; i > 0; i--) {
430 /*
431 * Break out of the loop if we've processed all the entries.
432 */
433 if (ret_val == 0)
434 break;
435
436 pfd = &fdtable[i];
437
438 if (pfd->fd < 0) {
439 rem_pid((pid_t)0, i, DONT_CLEAN);
440 continue;
441 }
442 /*
443 * POLLHUP - Process terminated
444 */
445 if (pfd->revents & POLLHUP) {
446 psinfo_t psinfo;
447
448 if (pread(pfd->fd, &psinfo, sizeof (psinfo), (off_t)0)
449 != sizeof (psinfo)) {
450 dprintf(("! %d: terminated, status 0x%.4x\n", \
451 (int)pidtable[i].pl_pid, psinfo.pr_wstat));
452 pidtable[i].pl_status = psinfo.pr_wstat;
453
454 } else {
455 dprintf(("! %d: terminated\n", \
456 (int)pidtable[i].pl_pid));
457 pidtable[i].pl_status = 0;
458 }
459 /*
460 * PID gets removed when terminated only
461 */
462 rem_pid((pid_t)0, i, CLEANIT);
463 ret_val--;
464 continue;
465 }
466 /*
467 * POLLNVAL and POLLERR
468 * These error's shouldn't occurr but until their fixed
469 * we perform some simple error recovery.
470 */
471 if (pfd->revents & (POLLNVAL|POLLERR)) {
472 dprintf(("Poll Err = %d pid = %d i = %d\n", \
473 pfd->revents, (int)pidtable[i].pl_pid, i));
474
475 pid = pidtable[i].pl_pid; /* Save pid for below */
476 /*
477 * If its POLLNVAL we just remove the process for
478 * now, it will get picked up in the next scan.
479 * POLLERR pids get re-added after being deleted.
480 */
481 if (pfd->revents & POLLNVAL) {
482 rem_pid((pid_t)0, i, DONT_CLEAN);
483 } else { /* Else... POLLERR */
484 rem_pid((pid_t)0, i, DONT_CLEAN);
485 add_pid(pid);
486 }
487
488 if (bad_error++ > MAX_POLL_ERRS) {
489 bad_error = 0;
490 return (0); /* 0 Indicates severe error */
491 }
492 ret_val--;
493 continue;
494 }
495
496 /*
497 * No more bits should be set in revents but check anyway
498 */
499 if (pfd->revents != 0) {
500 dprintf(("%d: unknown err %d\n", \
501 (int)pidtable[i].pl_pid, pfd->revents));
502
503 rem_pid((pid_t)0, i, DONT_CLEAN);
504 ret_val--;
505
506 if (bad_error++ > MAX_POLL_ERRS) {
507 bad_error = 0;
508 return (0); /* 0 Indicates severe error */
509 }
510 return (1);
511 }
512 }
513 return (1); /* 1 Indicates Everything okay */
514 }
515
516 /*
517 * *** The Scanner ***
518 *
519 * scan_utmps() - Scan the utmpx file.
520 * For each USER_PROCESS check
521 * if its alive or dead. If alive and its not in
522 * our table to be watched, put it there. If its
523 * dead, remove it from our table and clean it up.
524 */
525
526 static void
527 scan_utmps()
528 {
529 struct utmpx *utmpx;
530 int i;
531
532 dprintf(("Scan utmps\n"));
533 /*
534 * Scan utmpx.
535 */
536 setutxent();
537 while ((utmpx = getutxent()) != NULL) {
538 if (utmpx->ut_type == USER_PROCESS) {
539 /*
540 * Is the process alive?
541 */
542 if (proc_is_alive(utmpx->ut_pid)) {
543 /*
544 * Yes, the process is alive, so add it if we
545 * don't have it in our table.
546 */
547 if (find_pid(utmpx->ut_pid, &i) == 0)
548 add_pid(utmpx->ut_pid); /* No, add it */
549 } else {
550 /*
551 * No, the process is dead, so remove it if its
552 * in our table, otherwise just clean it.
553 */
554 if (find_pid(utmpx->ut_pid, &i) == 1)
555 rem_pid(utmpx->ut_pid, i, CLEANIT);
556 else
557 clean_utmpx_ent(utmpx);
558 }
559 }
560 }
561 /*
562 * Close it to flush the buffer.
563 */
564 endutxent();
565 }
566
567
568 /*
569 * *** Receiver Routines ***
570 */
571
572 /*
573 * setup_pipe - Set up the pipe to read pids over
574 */
575
576 static void
577 setup_pipe()
578 {
579
580 struct statvfs statvfs_buf;
581 /*
582 * This code & comments swiped from init and left stock since it works
583 */
584
585 if (Pfd < 0) {
586 if ((statvfs(UTMPPIPE_DIR, &statvfs_buf) == 0) &&
587 ((statvfs_buf.f_flag & ST_RDONLY) == 0)) {
588 (void) unlink(UTMPPIPE);
589 (void) mknod(UTMPPIPE, S_IFIFO | 0600, 0);
590 }
591 Pfd = open(UTMPPIPE, O_RDWR | O_NDELAY);
592 }
593 if (Pfd < 0)
594 nonfatal(UTMPPIPE);
595 /*
596 * This code from init modified to be poll based instead of SIGPOLL,
597 * signal based.
598 */
599
600 if (Pfd >= 0) {
601 /*
602 * Read pipe in message discard mode. When read reads a
603 * pidrec size record, the remainder of the message will
604 * be discarded. Though there shouldn't be any it will
605 * help resynch if someone else wrote some garbage.
606 */
607 (void) ioctl(Pfd, I_SRDOPT, RMSGD);
608 }
609
610 /*
611 * My code. We use slot 0 in the table to hold the fd of the pipe
612 */
613 add_pid(0); /* Proc 0 guaranteed to get slot 0 */
614 fdtable[0].fd = Pfd; /* Pfd could be -1, should be okay */
615 fdtable[0].events = POLLRDNORM;
616 }
617
618 /*
619 * drain_pipe() - The receiver routine that reads the pipe
620 */
621
622 static void
623 drain_pipe()
624 {
625 struct pidrec prec;
626 register struct pidrec *p = ≺
627 int bytes_read;
628 int i;
629
630 for (;;) {
631 /*
632 * Important Note: Either read will really fail (in which case
633 * return is all we can do) or will get EAGAIN (Pfd was opened
634 * O_NDELAY), in which case we also want to return.
635 */
636
637 if ((bytes_read = read(Pfd, p, sizeof (struct pidrec))) !=
638 sizeof (struct pidrec)) {
639 /*
640 * Something went wrong reading, so read until pipe
641 * is empty
642 */
643 if (bytes_read > 0)
644 while (read(Pfd, p, sizeof (struct pidrec)) > 0)
645 ;
646 return;
647 }
648
649 dprintf(("drain_pipe: Recd command %d, pid %d\n",
650 p->pd_type, (int)p->pd_pid));
651 switch (p->pd_type) {
652 case ADDPID:
653 /*
654 * Check if we already have the process, adding it
655 * if we don't.
656 */
657 if (find_pid(p->pd_pid, &i) == 0)
658 add_pid(p->pd_pid);
659 break;
660
661 case REMPID:
662 rem_pid(p->pd_pid, -1, DONT_CLEAN);
663 break;
664 default:
665 nonfatal("Bad message on utmppipe\n");
666 break;
667 }
668 }
669 }
670
671
672 /*
673 * *** Utilities for add and removing entries in the tables ***
674 */
675
676 /*
677 * add_pid - add a pid to the fd table and the pidtable.
678 * these tables are sorted tables for quick lookups.
679 *
680 */
681 static void
682 add_pid(pid)
683 pid_t pid;
684 {
685 int fd = 0;
686 int i = 0, move_amt;
687 int j;
688 static int first_time = 1;
689
690 /*
691 * Check to see if the pid is already in our table, or being passed
692 * pid zero.
693 */
694 if (pidcnt != 0 && (find_pid(pid, &j) == 1 || pid == 0))
695 return;
696
697 if (pidcnt >= Max_fds) {
698 if (first_time == 1) {
699 /*
700 * Print this error only once
701 */
702 nonfatal("File Descriptor limit exceeded");
703 first_time = 0;
704 }
705 return;
706 }
707 /*
708 * Open the /proc file checking if there's still a valid proc file.
709 */
710 if (pid != 0 && (fd = proc_to_fd(pid)) == -1) {
711 /*
712 * No so the process died before we got to watch for him
713 */
714 return;
715 }
716
717 /*
718 * We only do this code if we're not putting in the first element
719 * Which we know will be for proc zero which is used by setup_pipe
720 * for its pipe fd.
721 */
722 if (pidcnt != 0) {
723 for (i = 0; i < pidcnt; i++) {
724 if (pid <= pidtable[i].pl_pid)
725 break;
726 }
727
728 /*
729 * Handle the case where we're not sticking our entry on the
730 * the end, or overwriting an existing entry.
731 */
732 if (i != pidcnt && pid != pidtable[i].pl_pid) {
733
734 move_amt = pidcnt - i;
735 /*
736 * Move table down
737 */
738 if (move_amt != 0) {
739 (void) memmove(&pidtable[i+1], &pidtable[i],
740 move_amt * sizeof (struct pidentry));
741 (void) memmove(&fdtable[i+1], &fdtable[i],
742 move_amt * sizeof (pollfd_t));
743 }
744 }
745 }
746
747 /*
748 * Fill in the events field for poll and copy the entry into the array
749 */
750 fdtable[i].events = 0;
751 fdtable[i].revents = 0;
752 fdtable[i].fd = fd;
753
754 /*
755 * Likewise, setup pid field and pointer (index) to the fdtable entry
756 */
757 pidtable[i].pl_pid = pid;
758
759 pidcnt++; /* Bump the pid count */
760 dprintf((" add_pid: pid = %d fd = %d index = %d pidcnt = %d\n",
761 (int)pid, fd, i, pidcnt));
762 }
763
764
765 /*
766 * rem_pid - Remove an entry from the table and check to see if its
767 * not in the utmpx file.
768 * If i != -1 don't look up the pid, use i as index
769 */
770
771 static void
772 rem_pid(pid, i, clean_it)
773 pid_t pid; /* Pid of process to clean or 0 if we don't know it */
774 int i; /* Index into table or -1 if we need to look it up */
775 int clean_it; /* Clean the entry, or just remove from table? */
776 {
777 int move_amt;
778
779 dprintf((" rem_pid: pid = %d i = %d", (int)pid, i));
780
781 /*
782 * Don't allow slot 0 in the table to be removed - utmppipe fd
783 */
784 if ((i == -1 && pid == 0) || (i == 0)) {
785 dprintf((" - attempted to remove proc 0\n"));
786 return;
787 }
788
789 if (i != -1 || find_pid(pid, &i) == 1) { /* Found the entry */
790 (void) close(fdtable[i].fd); /* We're done with the fd */
791
792 dprintf((" fd = %d\n", fdtable[i].fd));
793
794 if (clean_it == CLEANIT)
795 clean_entry(i);
796
797 move_amt = (pidcnt - i) - 1;
798 /*
799 * Remove entries from the tables.
800 */
801 (void) memmove(&pidtable[i], &pidtable[i+1],
802 move_amt * sizeof (struct pidentry));
803
804 (void) memmove(&fdtable[i], &fdtable[i+1],
805 move_amt * sizeof (pollfd_t));
806
807 /*
808 * decrement the pid count - one less pid to worry about
809 */
810 pidcnt--;
811 }
812 if (i == -1)
813 dprintf((" - entry not found \n"));
814 }
815
816
817 /*
818 * find_pid - Returns an index into the pidtable of the specifed pid,
819 * else -1 if not found
820 */
821
822 static int
823 find_pid(pid, i)
824 pid_t pid;
825 int *i;
826 {
827 struct pidentry pe;
828 struct pidentry *p;
829
830 pe.pl_pid = pid;
831 p = bsearch(&pe, pidtable, pidcnt, sizeof (struct pidentry), pidcmp);
832
833 if (p == NULL)
834 return (0);
835 else {
836 *i = p - (struct pidentry *)pidtable;
837 return (1);
838 }
839 }
840
841
842 /*
843 * Pidcmp - Used by besearch for sorting and finding process IDs.
844 */
845
846 static int
847 pidcmp(a, b)
848 struct pidentry *a, *b;
849 {
850 if (b == NULL || a == NULL)
851 return (0);
852 return (a->pl_pid - b->pl_pid);
853 }
854
855
856 /*
857 * proc_to_fd - Take a process ID and return an open file descriptor to the
858 * /proc file for the specified process.
859 */
860 static int
861 proc_to_fd(pid)
862 pid_t pid;
863 {
864 char procname[64];
865 int fd, dfd;
866
867 (void) sprintf(procname, "/proc/%d/psinfo", (int)pid);
868
869 if ((fd = open(procname, O_RDONLY)) >= 0) {
870 /*
871 * dup the fd above the low order values to assure
872 * stdio works for other fds - paranoia.
873 */
874 if (fd < EXTRA_MARGIN) {
875 dfd = fcntl(fd, F_DUPFD, EXTRA_MARGIN);
876 if (dfd > 0) {
877 (void) close(fd);
878 fd = dfd;
879 }
880 }
881 /*
882 * More paranoia - set the close on exec flag
883 */
884 (void) fcntl(fd, F_SETFD, 1);
885 return (fd);
886 }
887 if (errno == ENOENT)
888 return (-1);
889
890 if (errno == EMFILE) {
891 /*
892 * This is fatal, since libc won't be able to allocate
893 * any fds for the pututxline() routines
894 */
895 fatal("Out of file descriptors");
896 }
897 fatal(procname); /* Only get here on error */
898 return (-1);
899 }
900
901
902 /*
903 * *** Utmpx Cleaning Utilities ***
904 */
905
906 /*
907 * Clean_entry - Cleans the specified entry - where i is an index
908 * into the pid_table.
909 */
910 static void
911 clean_entry(i)
912 int i;
913 {
914 struct utmpx *u;
915
916 if (pidcnt == 0)
917 return;
918
919 dprintf((" Cleaning %d\n", (int)pidtable[i].pl_pid));
920
921 /*
922 * Double check if the process is dead.
923 */
924 if (proc_is_alive(pidtable[i].pl_pid)) {
925 dprintf((" Bad attempt to clean %d\n", \
926 (int)pidtable[i].pl_pid));
927 return;
928 }
929
930 /*
931 * Find the entry that corresponds to this pid.
932 * Do nothing if entry not found in utmpx file.
933 */
934 setutxent();
935 while ((u = getutxent()) != NULL) {
936 if (u->ut_pid == pidtable[i].pl_pid) {
937 if (u->ut_type == USER_PROCESS) {
938 clean_utmpx_ent(u);
939 }
940 }
941 }
942 endutxent();
943 }
944
945
946 /*
947 * clean_utmpx_ent - Clean a utmpx entry
948 */
949
950 static void
951 clean_utmpx_ent(u)
952 struct utmpx *u;
953 {
954 dprintf((" clean_utmpx_ent: %d\n", (int)u->ut_pid));
955 u->ut_type = DEAD_PROCESS;
956 (void) time(&u->ut_xtime);
957 (void) pututxline(u);
958 updwtmpx(WTMPX_FILE, u);
959 /*
960 * XXX update wtmp for ! nonuserx entries?
961 */
962 }
963
964 /*
965 * *** Error Handling and Debugging Routines ***
966 */
967
968 /*
969 * fatal - Catastrophic failure
970 */
971
972 static void
973 fatal(char *str)
974 {
975 int oerrno = errno;
976
977 syslog(LOG_ALERT, "%s", str);
978 if (Debug == 1) {
979 if ((errno = oerrno) != 0)
980 perror(prog_name);
981 dprintf(("%s\n", str));
982 }
983 exit(1);
984 }
985
986 /*
987 * nonfatal - Non-Catastrophic failure - print message and errno
988 */
989
990 static void
991 nonfatal(char *str)
992 {
993 syslog(LOG_WARNING, "%s", str);
994
995 if (Debug == 1) {
996 if (errno != 0)
997 perror(prog_name);
998 dprintf(("%c%s\n", 7, str));
999 print_tables();
1000 (void) sleep(5); /* Time to read debug messages */
1001 }
1002 }
1003
1004 /*
1005 * print_tables - Print internal tables - for debugging
1006 */
1007
1008 static void
1009 print_tables()
1010 {
1011 int i;
1012
1013 if (Debug == 0)
1014 return;
1015
1016 dprintf(("pidtable: "));
1017 for (i = 0; i < pidcnt; i++)
1018 dprintf(("%d: %d ", i, (int)pidtable[i].pl_pid));
1019 dprintf(("\n"));
1020 dprintf(("fdtable: "));
1021 for (i = 0; i < pidcnt; i++)
1022 dprintf(("%d: %d ", i, fdtable[i].fd));
1023 dprintf(("\n"));
1024 }
1025
1026 /*
1027 * proc_is_alive - Check to see if a process is alive AND its
1028 * not a zombie. Returns 1 if process is alive
1029 * and zero if it is dead or a zombie.
1030 */
1031
1032 static int
1033 proc_is_alive(pid)
1034 pid_t pid;
1035 {
1036 char psinfoname[64];
1037 int fd;
1038 psinfo_t psinfo;
1039
1040 if (kill(pid, 0) != 0)
1041 return (0); /* Kill failed - no process */
1042
1043 /*
1044 * The process exists, so check if it's a zombie.
1045 */
1046 (void) sprintf(psinfoname, "/proc/%d/psinfo", (int)pid);
1047
1048 if ((fd = open(psinfoname, O_RDONLY)) < 0 ||
1049 read(fd, &psinfo, sizeof (psinfo)) != sizeof (psinfo)) {
1050 /*
1051 * We either couldn't open the proc, or we did but the
1052 * read of the psinfo file failed, so pid is nonexistent.
1053 */
1054 psinfo.pr_nlwp = 0;
1055 }
1056 if (fd >= 0)
1057 (void) close(fd);
1058
1059 /* if pr_nlwp == 0, process is a zombie */
1060 return (psinfo.pr_nlwp != 0);
1061 }
1062
1063 /*
1064 * warn_utmp - /var/adm/utmp has been deprecated. It should no longer
1065 * be used. Applications that try to directly manipulate
1066 * it may cause problems. Since the file is no longer
1067 * shipped, if it appears on a system it's because an
1068 * old application created it. We'll have utmpd
1069 * complain about it periodically.
1070 */
1071
1072 static void
1073 warn_utmp()
1074 {
1075 struct stat s;
1076
1077 if (lstat(UTMP_FILE, &s) == 0 &&
1078 s.st_size % sizeof (struct utmp) == 0) {
1079 nonfatal("WARNING: /var/adm/utmp exists!\nSee "
1080 "utmp(4) for more information");
1081 }
1082 }