xref: /illumos-gate/usr/src/cmd/bnu/ct.c (revision 3b296559ccf4430268fec1fbbb543f59c9a7113b)
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  * Copyright (c) 2016 by Delphix. All rights reserved.
30  */
31 
32 /*
33  *
34  *	ct [-h] [-v] [-w n] [-x n] [-s speed] telno ...
35  *
36  *	dials the given telephone number, waits for the
37  *	modem to answer, and initiates a login process.
38  *
39  *	ct uses several routines from uucp:
40  *	- getto(flds) takes a vector of fields needed to make
41  *	  a connection and returns a file descriptor or -1
42  *	- rddev( ... ) takes several arguments and returns lines
43  *	  from the /etc/uucp/Devices that match the type
44  *	  (in ct the type will be ACU)
45  *	- fdig(string) takes a string that is zero or more
46  *	  alphabetic characters follow by a number (baud rate)
47  *	  and returns a pointer to the first digit in the string.
48  *	- fn_cklock(dev) takes a device name [/dev/]term/11 and
49  *	  checks whether the appropriate lock file exists. It returns
50  *	  FAIL if it does.
51  *	- rmlock(pointer) removes the lock file.  In ct pointer is
52  *	  always CNULL (a null pointer) causing rmlock to remove
53  *	  all lock files associated with this execution of ct.
54  */
55 
56 #include "uucp.h"
57 #include "sysfiles.h"
58 #include <pwd.h>
59 #include <utmpx.h>
60 
61 #ifdef DATAKIT
62 #include <dk.h>
63 extern int dkminor();
64 #endif
65 
66 #define ROOT	0
67 #define SYS	3
68 #define TTYGID	(gid_t) 7		/* group id for terminal */
69 #define TTYMOD	(mode_t) 0622
70 #define DEV	"/dev/"
71 #define TELNOSIZE	32		/* maximum phone # size is 31 */
72 #define LEGAL	"0123456789-*#="
73 #define USAGE	"[-h] [-v] [-w n] [-x n] [-s speed] telno ..."
74 #define LOG	"/var/adm/ctlog"
75 #define	TTYMON	"/usr/lib/saf/ttymon"
76 #define TRUE	1
77 #define FALSE	0
78 
79 int	Dologin = 0;
80 static
81 int	_Status;		/* exit status of child */
82 
83 static
84 pid_t	_Pid = 0;		/* process id of child */
85 
86 static
87 char
88 	_Tty[sizeof DEV+12] = "",  /* /dev/term/xx for connection device */
89 	*_Dev[D_MAX + 1],	/* Filled in by rddev and used globally */
90 	_Devbuf[BUFSIZ];	/* buffer for rddev */
91 
92 static
93 char
94 	*_Num,			/* pointer to a phone number */
95 	*_Flds[7];		/* Filled in as if finds() in uucp did it */
96 
97 static
98 time_t	_Log_on,
99 	_Log_elpsd;
100 
101 static
102 FILE	*_Fdl;
103 
104 extern int  optind;
105 extern char *optarg, *fdig();
106 extern  void cleanup();
107 extern struct passwd  *getpwuid ();
108 
109 extern int getto(), rddev();
110 static int gdev(), logproc(), exists();
111 static void startat(), stopat(), disconnect(), zero();
112 
113 /*
114  * These two dummy routines are needed because the uucp routines
115  * used by ct reference them, but they will never be
116  * called when executing from ct
117  */
118 
119 /*VARARGS*/
120 /*ARGSUSED*/
121 void
assert(s1,s2,i1,s3,i2)122 assert (s1, s2, i1, s3, i2)
123 char *s1, *s2, *s3;
124 int i1, i2;
125 { }		/* for ASSERT in gnamef.c */
126 
127 /*ARGSUSED*/
128 void
logent(s1,s2)129 logent (s1, s2)
130 char *s1, *s2;
131 { }		/* so we can load ulockf() */
132 
133 jmp_buf Sjbuf;			/* used by uucp routines */
134 
135 int
main(argc,argv)136 main (argc, argv)
137 int argc;
138 char   *argv[];
139 {
140     int    	c;
141     int		found = 0,
142 		errors = 0,
143 		first = TRUE;
144     int     count,
145 	    logprocflag,	/* is there a login process on the line */
146             hangup = 1,		/* hangup by default */
147             minutes = 0;	/* number of minutes to wait for dialer */
148     int     fdl;
149     struct termio   termio;
150     typedef void (*save_sig)();
151     save_sig	save_hup,
152 		save_quit,
153 		save_int;
154     extern void	setservice(), devreset();
155     extern int sysaccess();
156 
157     save_hup = signal (SIGHUP, cleanup);
158     save_quit = signal (SIGQUIT, cleanup);
159     save_int = signal (SIGINT, cleanup);
160     (void) signal (SIGTERM, cleanup);
161     (void) strcpy (Progname, "ct");
162 
163     setservice("cu");
164     if ( sysaccess(EACCESS_DEVICES) != 0 ) {
165 	(void) fprintf(stderr, "ct: can't access Devices file\n");
166 	cleanup(101);
167     }
168 
169     /* Set up the _Flds vector as if finds() [from uucico] built it */
170     _Flds[F_NAME] = "dummy";		/* never used */
171     _Flds[F_TIME] = "Any";		/* never used */
172     _Flds[F_TYPE] = "ACU";
173     _Flds[F_CLASS] = "1200";		/* default at 1200 */
174     _Flds[F_PHONE] = "";			/* filled in by arguments */
175     _Flds[F_LOGIN] = "";			/* never used */
176     _Flds[6] = NULL;
177 
178     while ((c = getopt (argc, argv, "hvw:s:x:")) != EOF) {
179 	switch (c) {
180 	    case 'h':
181 		hangup = 0;
182 		break;
183 
184 	    case 'v':
185 		Verbose = 1;
186 		break;
187 
188 	    case 'w':
189 		minutes = atoi (optarg);
190 		if (minutes < 1) {
191 		    (void) fprintf(stderr,
192 			"\tusage: %s %s\n", Progname, USAGE);
193 		    (void) fprintf(stderr, "(-w %s) Wait time must be > 0\n",
194 			optarg);
195 		    cleanup(101);
196 		}
197 		break;
198 
199 	    case 's':
200 		_Flds[F_CLASS] = optarg;
201 		break;
202 
203 	    case 'x':
204 		Debug = atoi(optarg);
205 		if (Debug < 0 || Debug > 9) {
206 		    (void) fprintf(stderr,
207 			"\tusage: %s %s\n", Progname, USAGE);
208 		    (void) fprintf(stderr, "(-x %s) value must be 0-9\n",
209 			optarg);
210 		    cleanup(101);
211 		}
212 		break;
213 
214 	    case '?':
215 		(void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE);
216 		cleanup(101);
217 		/* NOTREACHED */
218 	}
219     }
220 
221     if (optind == argc) {
222 	(void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE);
223 	(void) fprintf(stderr, "No phone numbers specified!\n");
224 	cleanup(101);
225     }
226 
227     /* check for valid phone number(s) */
228     for (count = argc - 1; count >= optind; --count) {
229 	_Num = argv[count];
230 	if (strlen(_Num) >= (size_t)(TELNOSIZE - 1)) {
231 	    (void) fprintf(stderr, "ct: phone number too long -- %s\n", _Num);
232 	    ++errors;
233 	}
234 	if ((int)strspn(_Num, LEGAL) < (int)strlen(_Num)) {
235 	    (void) fprintf(stderr, "ct: bad phone number -- %s\n", _Num);
236 	    ++errors;
237 	}
238     }
239     if (errors)
240 	cleanup(101);
241 
242     /************************************************************/
243     /*		Begin Loop:  Find an available Dialer		*/
244     /************************************************************/
245     for (count = 0;; count++) { /* count will be wait time after first
246 				 * time through the loop.
247 				 * break will be used exit loop.
248 				 */
249 	if ( (found = gdev (_Flds)) > 0) {  /* found a dialer */
250 	    (void) fprintf(stdout, "Allocated dialer at %s baud\n",
251 		_Flds[F_CLASS]);
252 	    break;
253 	}
254 	else if (found == 0) {	/* no dialers of that on system */
255 	    (void) fprintf(stdout, "No %s dialers on this system\n",
256 		fdig(_Flds[F_CLASS]) );
257     	    cleanup(101);
258 	}
259 
260 	if (!first) { /* not the first time in loop */
261 	    VERBOSE("%s busy", (found == -1) ? "Dialer is" : "Dialers are");
262 	    VERBOSE(" (%d minute(s))\n", count);
263 	    if (count < minutes) {
264 	        sleep(60);
265 	        continue;
266 	    }
267 	    /* This is the end of the loop - no time left */
268 	    break;
269 	}
270 
271 	/**************************************************************/
272 	/* First time through loop - get wait minutes if no -w option */
273 	/**************************************************************/
274 	first = FALSE;
275 	(void) fprintf(stdout, "The (%d) %s dialer%s busy\n", -found,
276 	    _Flds[F_CLASS], (found == -1 ? " is" : "s are"));
277 	if (minutes) {	/* -w already set wait minutes */
278 	    (void) fprintf(stdout, "Waiting for %d minute%s\n", minutes,
279 		(minutes > 1 ? "s" : "") );
280 	    sleep(60);
281 	    continue;
282 	}
283 
284 	if (!isatty(0) )  {  /* not a terminal - get out */
285 	    cleanup(101);
286 	}
287 
288 	/* Ask user if they want to wait */
289 	(void) fputs("Do you want to wait for dialer? (y for yes): ", stdout);
290 	if ((c = getchar ()) == EOF || tolower (c) != 'y')
291 	    cleanup(101);
292 	while ( (c = getchar()) != EOF && c != '\n')
293 	    ;
294 
295 	(void) fputs ("Time, in minutes? ", stdout);
296 	(void) scanf ("%d", &minutes);
297 	while ( (c = getchar()) != EOF && c != '\n')
298 	    ;
299 
300 	if (minutes <= 0)
301 	    cleanup(101);
302 
303 	(void) fputs ("Waiting for dialer\n", stdout);
304 	sleep(60);
305 	continue;
306 
307     }
308     /************************************************************/
309     /*		End Loop:  Find an available Dialer		*/
310     /************************************************************/
311 
312     /* check why loop terminated */
313     if (found < 0) {	/* no dialer found - get out */
314         (void) fputs("*** TIMEOUT ***\n", stdout);
315         cleanup(101);
316     }
317 
318     (void) signal(SIGHUP, SIG_IGN);
319     /* found a dialer. now try to call */
320     if (!isatty(0))
321         hangup = 0;
322 
323     if (hangup) {  /* -h option not specified */
324 	do {
325             (void) fputs ("Confirm hang-up? (y/n): ", stdout);
326 	    switch (c=tolower(getchar())) {
327 	   case EOF:
328 	   case 'n':
329 		    cleanup(101);
330 		    break;
331 	   case 'y':
332 		    break;
333 	    default:
334 		    while ( c != EOF && c != '\n' )
335 			c=getchar();
336 		    break;
337 	    }
338 	} while (c != 'y');
339 
340 	/* close stderr if it is not redirected */
341         if ( isatty(2) ) {
342             Verbose = 0;
343 	    Debug = 0;
344             (void) close (2);
345 	}
346 
347 	(void) ioctl (0, TCGETA, &termio);
348         termio.c_cflag = 0;	/* speed to zero for hangup */
349         (void) ioctl (0, TCSETAW, &termio);  /* hang up terminal */
350         (void) sleep (5);
351     }
352     (void) close(0);
353     (void) close(1);
354 
355     /* Try each phone number until a connection is made, or non work */
356     for (count = optind; count < argc; count++) {
357 	/* call getto routine to make connection */
358 	_Flds[F_PHONE] = argv[count];
359 	rmlock(CNULL);	/* remove temporary lock set by gdev */
360 	devreset();
361 	fdl = getto(_Flds);
362 	if (fdl >= 0) {
363 	    /*
364 	     * If there is a login process on the line, get rid
365 	     * of the lock file quickly so that when the process
366 	     * reads the first character, the lock file will be gone
367 	     * indicating that the process should handle the data.
368 	     */
369 	    if ( (logprocflag = logproc(Dc)) ) /* really an assignment! */
370 		rmlock(CNULL);
371 
372 	    _Fdl = fdopen(fdl, "r+");
373 	    (void) sprintf(_Tty, "%s%s", DEV, Dc);
374 	    /* NOTE:  Dc is set in the caller routines */
375 	    break;
376 	}
377     }
378 
379     /* check why the loop ended (connected or no more numbers to try) */
380     if (count == argc)
381 	cleanup(101);
382 
383     /****** Successfully made connection ******/
384     VERBOSE("Connected\n%s", "");
385 
386 #ifdef	DATAKIT
387  	if (!strcmp(_Dev[D_CALLER], "DK")) {
388  		strcpy(_Tty, dtnamer(dkminor(fdl)));
389  		strcpy(Dc, (strrchr(_Tty, '/')+1));
390  		if ((_Fdl = fopen(_Tty, "r+")) == NULL) {
391  			(void) fprintf(stderr, "ct: Cannot open %s, errno %d\n",
392  				_Tty, errno);
393  			cleanup(101);
394  		}
395  	}
396 #endif
397 
398     /* ignore some signals if they were ignored upon invocation of ct */
399     /* or else, have them go to graceful disconnect */
400     if (save_hup == SIG_IGN)
401 	(void) signal (SIGHUP, SIG_IGN);
402     else
403 	(void) signal (SIGHUP, disconnect);
404 
405     if (save_quit == SIG_IGN)
406 	(void) signal (SIGQUIT, SIG_IGN);
407     else
408 	(void) signal (SIGQUIT, disconnect);
409 
410     if (save_int == SIG_IGN)
411 	(void) signal (SIGINT, SIG_IGN);
412     else
413 	(void) signal (SIGINT, disconnect);
414 
415     (void) signal (SIGTERM, disconnect);
416     (void) signal (SIGALRM, disconnect);
417 
418     (void) sleep (2);		/* time for phone line/modem to settle */
419 
420     _Log_on = time ((time_t *) 0);
421 
422     /*
423      * if there is a login process on this line,
424      * tell the user to hit a carriage return to make
425      * the waiting process get past the inital read,
426      * Then exit.
427      */
428     if (logprocflag) {	/* there is a login process on the line */
429 	(void) fputs("Hit carriage return ", _Fdl);
430 	(void) fclose(_Fdl);
431 	CDEBUG(4, "there is a login process; exit\n%s", "");
432 	exit(0);
433     }
434 
435     CDEBUG(4, "start login process (%s ", TTYMON);
436     CDEBUG(4, "-g -h -t 60 -l %s)\n", fdig(_Flds[F_CLASS]));
437     for (;;) {
438 	pid_t w_ret;
439 	switch(_Pid = fork()) {
440 	case -1:	/* fork failed */
441 	    if ((!hangup || Verbose))
442 		(void) fputs ("ct: can't fork for login process\n", stderr);
443 	    cleanup(101);
444 	    /*NOTREACHED*/
445 
446 	case 0:		/* child process */
447 	    startat ();
448 	    (void) close(2);
449 	    /* ttymon will use open fd 0 for connection */
450 	    if ( fdl != 0 ) {
451 		(void) close(0);
452 		dup(fdl);
453 	    }
454 	    (void) signal(SIGHUP, SIG_DFL);  /* so child will exit on hangup */
455 	    (void) execl(TTYMON, "ttymon", "-g", "-h", "-t", "60",
456 			"-l", fdig(_Flds[F_CLASS]), (char *) 0);
457 	    /* exec failed */
458 	    cleanup(101);
459 	    /*NOTREACHED*/
460 
461 	default:	/* parent process */
462 	    break;
463 	}
464 
465 	/* Parent process */
466 
467 	while ((w_ret = wait(&_Status)) != _Pid)
468 	    if (w_ret == -1 && errno != EINTR) {
469 		VERBOSE("ct: wait failed errno=%d\n", errno);
470 		cleanup(101);
471 	    }
472 	if ((_Status & 0xff00) < 0) {
473 	    if (!hangup)
474 		VERBOSE("ct: can't exec login process\n%s", "");
475 	    cleanup(101);
476 	}
477 
478 	stopat(_Flds[F_PHONE]);
479 
480         rewind (_Fdl);	/* flush line */
481         (void) fputs ("\nReconnect? ", _Fdl);
482 
483         rewind (_Fdl);
484         (void) alarm (20);
485         c = getc (_Fdl);
486 
487         if (c == EOF || tolower (c) == 'n')
488 	    disconnect (0);	/* normal disconnect */
489         while ( (c = getc(_Fdl)) != EOF && c != '\n')
490     	    ;
491         (void) alarm (0);
492     }
493 }
494 
495 static void
disconnect(int code)496 disconnect(int code)
497 {
498     struct termio   termio;
499 
500     (void) alarm(0);
501     (void) signal (SIGALRM, SIG_IGN);
502     (void) signal (SIGINT, SIG_IGN);
503     (void) signal (SIGTERM, SIG_IGN);
504 
505     _Log_elpsd = time ((time_t *) 0) - _Log_on;
506 
507     (void) ioctl (fileno(_Fdl), TCGETA, &termio);
508     termio.c_cflag = 0;				/* speed to zero for hangup */
509     (void) ioctl (fileno(_Fdl), TCSETAW, &termio);  /* hang up terminal */
510     (void) fclose (_Fdl);
511 
512     DEBUG(5, "Disconnect(%d)\n", code);
513     VERBOSE("Disconnected\n%s", "");
514 
515     /* For normal disconnect or timeout on "Reconnect?" message,
516        we already cleaned up above */
517 
518     if ((code != 0) && (code != SIGALRM))
519 	stopat(_Flds[F_PHONE]);
520 
521     cleanup(code);
522 }
523 
524 /*
525  * clean and exit with "code" status
526  */
527 void
cleanup(code)528 cleanup (code)
529 int    code;
530 {
531     CDEBUG(5, "cleanup(%d)\n", code);
532     rmlock (CNULL);
533     if (*_Tty != '\0') {
534 	CDEBUG(5, "chmod/chown %s\n", _Tty);
535 	if (chown(_Tty , UUCPUID, TTYGID) < 0 ) {
536 	    CDEBUG(5, "Can't chown to uid=%u, ", UUCPUID);
537 	    CDEBUG(5, "gid=%u\n", TTYGID);
538 	}
539 	if (chmod(_Tty , TTYMOD) < 0) {
540 	    CDEBUG(5, "Can't chmod to %lo\n", (unsigned long) TTYMOD);
541 	}
542     }
543     if (_Pid) { /* kill the child process */
544 	(void) signal(SIGHUP, SIG_IGN);
545 	(void) signal(SIGQUIT, SIG_IGN);
546 	(void) kill (_Pid, SIGKILL);
547     }
548     exit (code);
549 }
550 
551 /*	gdev()
552  * Find an available line with a dialer on it.
553  * Set a temporary lock file for the line.
554  * Return:
555  *	>0 - got a dialer
556  *	<0 - failed - return the number of possible dialers
557  *	0 - not dialers of requested class on the system.
558  */
559 
560 static int
gdev(flds)561 gdev (flds)
562 char   *flds[];
563 {
564     int	count = 0;
565     extern void	devreset();
566 
567     devreset();
568     while (rddev ("ACU", _Dev, _Devbuf, D_MAX) != FAIL) {
569 	/* check caller type */
570 	if (!EQUALS (flds[F_TYPE] /* "ACU" */, _Dev[D_TYPE]))
571 	    continue;
572 	/* check class, check (and possibly set) speed */
573 	if (!EQUALS (flds[F_CLASS] /* speed */, _Dev[D_CLASS]))
574 	    continue;
575 	count++;
576 
577 	if (fn_cklock(_Dev[D_LINE]) == FAIL)
578 	    continue;
579 
580 	/* found available dialer and set temporary lock */
581 	return (count);
582 
583     }
584     return (- count);
585 }
586 
587 /*
588  * Check if there is a login process active on this line.
589  * Return:
590  *	0 - there is no login process on this line
591  *	1 - found a login process on this line
592  */
593 
594 static int
logproc(line)595 logproc(line)
596 char *line;
597 {
598     struct utmpx   *u;
599 
600     while ((u = getutxent()) != NULL) {
601 	if (u->ut_type == LOGIN_PROCESS
602 	    && EQUALS(u->ut_line, line)
603 	    && EQUALS(u->ut_user, "LOGIN") ) {
604 		CDEBUG(7, "ut_line %s, ", u->ut_line);
605 		CDEBUG(7, "ut_user %s, ", u->ut_user);
606 		CDEBUG(7, "ut_id %.4s, ", u->ut_id);
607 		CDEBUG(7, "ut_pid %d\n", u->ut_pid);
608 
609 		/* see if the process is still active */
610 		if (kill(u->ut_pid, 0) == 0 || errno == EPERM) {
611 		    CDEBUG(4, "process still active\n%s", "");
612 		    return(1);
613 		}
614 	}
615     }
616     return(0);
617 }
618 
619 /*
620  * Create an entry in utmpx file if one does not already exist.
621  */
622 static void
startat()623 startat ()
624 {
625     struct utmpx utmpxbuf, *u;
626     int fd;
627 
628 /*	Set up the prototype for the utmpx structure we want to write.	*/
629 
630     u = &utmpxbuf;
631     zero (&u -> ut_user[0], sizeof (u -> ut_user));
632     zero (&u -> ut_line[0], sizeof (u -> ut_line));
633 
634 /*	Fill in the various fields of the utmpx structure.		*/
635 
636     u -> ut_id[0] = 'c';
637     u -> ut_id[1] = 't';
638     u -> ut_id[2] = _Tty[strlen(_Tty)-2];
639     u -> ut_id[3] = _Tty[strlen(_Tty)-1];
640     u -> ut_pid = getpid ();
641 
642     u -> ut_exit.e_termination = 0;
643     u -> ut_exit.e_exit = 0;
644     u -> ut_type = INIT_PROCESS;
645     time (&u -> ut_xtime);
646     setutxent ();		/* Start at beginning of utmpx file. */
647 
648 /*	For INIT_PROCESSes put in the name of the program in the	*/
649 /*	"ut_user" field.						*/
650 
651     strncpy (&u -> ut_user[0], "ttymon", sizeof (u -> ut_user));
652     strncpy (&u -> ut_line[0], Dc, sizeof (u -> ut_line));
653 
654 /*	Write out the updated entry to utmpx file.			*/
655     pututxline (u);
656 
657 /*	Now attempt to add to the end of the wtmpx file.  Do not create	*/
658 /*	if it doesn't already exist. Do not overwrite any info already	*/
659 /*	in file.							*/
660 
661     if ((fd = open(WTMPX_FILE, O_WRONLY | O_APPEND)) != -1) {
662 	(void) write(fd, u, sizeof(*u));
663 	(void) close(fd);
664     }
665     endutxent ();
666     return;
667 }
668 
669 /*
670  * Change utmpx file entry to "dead".
671  * Make entry in ct log.
672  */
673 
674 static void
stopat(num)675 stopat (num)
676 char   *num;
677 {
678     struct utmpx utmpxbuf, *u;
679     int fd;
680     FILE * fp;
681 
682 /*	Set up the prototype for the utmpx structure we want to write.	*/
683 
684     setutxent();
685     u = &utmpxbuf;
686     zero (&u -> ut_user[0], sizeof (u -> ut_user));
687     zero (&u -> ut_line[0], sizeof (u -> ut_line));
688 
689 /*	Fill in the various fields of the utmpx structure.		*/
690 
691     u -> ut_id[0] = 'c';
692     u -> ut_id[1] = 't';
693     u -> ut_id[2] = _Tty[strlen(_Tty)-2];
694     u -> ut_id[3] = _Tty[strlen(_Tty)-1];
695     u -> ut_pid = (pid_t) _Pid;
696     u -> ut_type = USER_PROCESS;
697 
698 /*	Find the old entry in the utmpx file with the user name and	*/
699 /*	copy it back.							*/
700 
701     if (u = getutxid (u)) {
702 	utmpxbuf = *u;
703 	u = &utmpxbuf;
704     }
705 
706     u -> ut_exit.e_termination = _Status & 0xff;
707     u -> ut_exit.e_exit = (_Status >> 8) & 0xff;
708     u -> ut_type = DEAD_PROCESS;
709     time (&u -> ut_xtime);
710 
711 /*	Write out the updated entry to utmpx file.			*/
712 
713     pututxline (u);
714 
715 /*	Now attempt to add to the end of the wtmpx file.  Do not create	*/
716 /*	if it doesn't already exist. Do not overwrite any info already	*/
717 /*	in file.							*/
718 
719     if ((fd = open(WTMPX_FILE, O_WRONLY | O_APPEND)) != -1) {
720 	(void) write(fd, u, sizeof(*u));
721 	(void) close(fd);
722     }
723     endutxent ();
724 
725 /*	Do the log accounting 					*/
726 
727     if (exists (LOG) && (fp = fopen (LOG, "a")) != NULL) {
728 	char   *aptr;
729 	int     hrs,
730 	        mins,
731 	        secs;
732 
733  	/* ignore user set TZ for logfile purposes */
734 	if ( (aptr = getenv ("TZ")) != NULL )
735 		*aptr = '\0';
736 
737 	(aptr = ctime (&_Log_on))[16] = '\0';
738 	hrs = _Log_elpsd / 3600;
739 	mins = (_Log_elpsd %= 3600) / 60;
740 	secs = _Log_elpsd % 60;
741 	(void) fprintf(fp, "%-8s ", getpwuid (getuid ()) -> pw_name);
742 	(void) fprintf(fp, "(%4s)  %s ", fdig(_Flds[F_CLASS]), aptr);
743 	if (hrs)
744 	    (void) fprintf(fp, "%2d:%.2d", hrs, mins);
745 	else
746 	    (void) fprintf(fp, "   %2d", mins);
747 	(void) fprintf(fp, ":%.2d  %s\n", secs, num);
748 	(void) fclose (fp);
749     }
750     return;
751 }
752 
753 static int
exists(file)754 exists (file)
755 char   *file;
756 {
757     struct stat statb;
758 
759     if (stat (file, &statb) == -1 && errno == ENOENT)
760 	return (0);
761     return (1);
762 }
763 
764 static void
zero(adr,size)765 zero (adr, size)
766 char  *adr;
767 int    size;
768 {
769     while (size--)
770 	*adr++ = '\0';
771     return;
772 }
773