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