/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #pragma ident "%Z%%M% %I% %E% SMI" /* * * ct [-h] [-v] [-w n] [-x n] [-s speed] telno ... * * dials the given telephone number, waits for the * modem to answer, and initiates a login process. * * ct uses several routines from uucp: * - getto(flds) takes a vector of fields needed to make * a connection and returns a file descriptor or -1 * - rddev( ... ) takes several arguments and returns lines * from the /etc/uucp/Devices that match the type * (in ct the type will be ACU) * - fdig(string) takes a string that is zero or more * alphabetic characters follow by a number (baud rate) * and returns a pointer to the first digit in the string. * - fn_cklock(dev) takes a device name [/dev/]term/11 and * checks whether the appropriate lock file exists. It returns * FAIL if it does. * - rmlock(pointer) removes the lock file. In ct pointer is * always CNULL (a null pointer) causing rmlock to remove * all lock files associated with this execution of ct. */ #include "uucp.h" #include "sysfiles.h" #include <pwd.h> #include <utmpx.h> #ifdef DATAKIT #include <dk.h> extern int dkminor(); #endif #define ROOT 0 #define SYS 3 #define TTYGID (gid_t) 7 /* group id for terminal */ #define TTYMOD (mode_t) 0622 #define DEV "/dev/" #define TELNOSIZE 32 /* maximum phone # size is 31 */ #define LEGAL "0123456789-*#=" #define USAGE "[-h] [-v] [-w n] [-x n] [-s speed] telno ..." #define LOG "/var/adm/ctlog" #define TTYMON "/usr/lib/saf/ttymon" #define TRUE 1 #define FALSE 0 static int _Status; /* exit status of child */ static pid_t _Pid = 0; /* process id of child */ static char _Tty[sizeof DEV+12] = "", /* /dev/term/xx for connection device */ *_Dev[D_MAX + 1], /* Filled in by rddev and used globally */ _Devbuf[BUFSIZ]; /* buffer for rddev */ static char *_Num, /* pointer to a phone number */ *_Flds[7]; /* Filled in as if finds() in uucp did it */ static time_t _Log_on, _Log_elpsd; static FILE *_Fdl; extern int optind; extern char *optarg, *fdig(); extern void cleanup(); extern struct passwd *getpwuid (); extern int getto(), rddev(); static int gdev(), logproc(), exists(); static void startat(), stopat(), disconnect(), zero(); /* * These two dummy routines are needed because the uucp routines * used by ct reference them, but they will never be * called when executing from ct */ /*VARARGS*/ /*ARGSUSED*/ void assert (s1, s2, i1, s3, i2) char *s1, *s2, *s3; int i1, i2; { } /* for ASSERT in gnamef.c */ /*ARGSUSED*/ void logent (s1, s2) char *s1, *s2; { } /* so we can load ulockf() */ jmp_buf Sjbuf; /* used by uucp routines */ int main (argc, argv) int argc; char *argv[]; { int c; int found = 0, errors = 0, first = TRUE; int count, logprocflag, /* is there a login process on the line */ hangup = 1, /* hangup by default */ minutes = 0; /* number of minutes to wait for dialer */ int fdl; struct termio termio; typedef void (*save_sig)(); save_sig save_hup, save_quit, save_int; extern void setservice(), devreset(); extern int sysaccess(); save_hup = signal (SIGHUP, cleanup); save_quit = signal (SIGQUIT, cleanup); save_int = signal (SIGINT, cleanup); (void) signal (SIGTERM, cleanup); (void) strcpy (Progname, "ct"); setservice("cu"); if ( sysaccess(EACCESS_DEVICES) != 0 ) { (void) fprintf(stderr, "ct: can't access Devices file\n"); cleanup(101); } /* Set up the _Flds vector as if finds() [from uucico] built it */ _Flds[F_NAME] = "dummy"; /* never used */ _Flds[F_TIME] = "Any"; /* never used */ _Flds[F_TYPE] = "ACU"; _Flds[F_CLASS] = "1200"; /* default at 1200 */ _Flds[F_PHONE] = ""; /* filled in by arguments */ _Flds[F_LOGIN] = ""; /* never used */ _Flds[6] = NULL; while ((c = getopt (argc, argv, "hvw:s:x:")) != EOF) { switch (c) { case 'h': hangup = 0; break; case 'v': Verbose = 1; break; case 'w': minutes = atoi (optarg); if (minutes < 1) { (void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE); (void) fprintf(stderr, "(-w %s) Wait time must be > 0\n", optarg); cleanup(101); } break; case 's': _Flds[F_CLASS] = optarg; break; case 'x': Debug = atoi(optarg); if (Debug < 0 || Debug > 9) { (void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE); (void) fprintf(stderr, "(-x %s) value must be 0-9\n", optarg); cleanup(101); } break; case '?': (void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE); cleanup(101); /* NOTREACHED */ } } if (optind == argc) { (void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE); (void) fprintf(stderr, "No phone numbers specified!\n"); cleanup(101); } /* check for valid phone number(s) */ for (count = argc - 1; count >= optind; --count) { _Num = argv[count]; if (strlen(_Num) >= (size_t)(TELNOSIZE - 1)) { (void) fprintf(stderr, "ct: phone number too long -- %s\n", _Num); ++errors; } if ((int)strspn(_Num, LEGAL) < (int)strlen(_Num)) { (void) fprintf(stderr, "ct: bad phone number -- %s\n", _Num); ++errors; } } if (errors) cleanup(101); /************************************************************/ /* Begin Loop: Find an available Dialer */ /************************************************************/ for (count = 0;; count++) { /* count will be wait time after first * time through the loop. * break will be used exit loop. */ if ( (found = gdev (_Flds)) > 0) { /* found a dialer */ (void) fprintf(stdout, "Allocated dialer at %s baud\n", _Flds[F_CLASS]); break; } else if (found == 0) { /* no dialers of that on system */ (void) fprintf(stdout, "No %s dialers on this system\n", fdig(_Flds[F_CLASS]) ); cleanup(101); } if (!first) { /* not the first time in loop */ VERBOSE("%s busy", (found == -1) ? "Dialer is" : "Dialers are"); VERBOSE(" (%d minute(s))\n", count); if (count < minutes) { sleep(60); continue; } /* This is the end of the loop - no time left */ break; } /**************************************************************/ /* First time through loop - get wait minutes if no -w option */ /**************************************************************/ first = FALSE; (void) fprintf(stdout, "The (%d) %s dialer%s busy\n", -found, _Flds[F_CLASS], (found == -1 ? " is" : "s are")); if (minutes) { /* -w already set wait minutes */ (void) fprintf(stdout, "Waiting for %d minute%s\n", minutes, (minutes > 1 ? "s" : "") ); sleep(60); continue; } if (!isatty(0) ) { /* not a terminal - get out */ cleanup(101); } /* Ask user if she/he wants to wait */ (void) fputs("Do you want to wait for dialer? (y for yes): ", stdout); if ((c = getchar ()) == EOF || tolower (c) != 'y') cleanup(101); while ( (c = getchar()) != EOF && c != '\n') ; (void) fputs ("Time, in minutes? ", stdout); (void) scanf ("%d", &minutes); while ( (c = getchar()) != EOF && c != '\n') ; if (minutes <= 0) cleanup(101); (void) fputs ("Waiting for dialer\n", stdout); sleep(60); continue; } /************************************************************/ /* End Loop: Find an available Dialer */ /************************************************************/ /* check why loop terminated */ if (found < 0) { /* no dialer found - get out */ (void) fputs("*** TIMEOUT ***\n", stdout); cleanup(101); } (void) signal(SIGHUP, SIG_IGN); /* found a dialer. now try to call */ if (!isatty(0)) hangup = 0; if (hangup) { /* -h option not specified */ do { (void) fputs ("Confirm hang-up? (y/n): ", stdout); switch (c=tolower(getchar())) { case EOF: case 'n': cleanup(101); break; case 'y': break; default: while ( c != EOF && c != '\n' ) c=getchar(); break; } } while (c != 'y'); /* close stderr if it is not redirected */ if ( isatty(2) ) { Verbose = 0; Debug = 0; (void) close (2); } (void) ioctl (0, TCGETA, &termio); termio.c_cflag = 0; /* speed to zero for hangup */ (void) ioctl (0, TCSETAW, &termio); /* hang up terminal */ (void) sleep (5); } (void) close(0); (void) close(1); /* Try each phone number until a connection is made, or non work */ for (count = optind; count < argc; count++) { /* call getto routine to make connection */ _Flds[F_PHONE] = argv[count]; rmlock(CNULL); /* remove temporary lock set by gdev */ devreset(); fdl = getto(_Flds); if (fdl >= 0) { /* * If there is a login process on the line, get rid * of the lock file quickly so that when the process * reads the first character, the lock file will be gone * indicating that the process should handle the data. */ if ( (logprocflag = logproc(Dc)) ) /* really an assignment! */ rmlock(CNULL); _Fdl = fdopen(fdl, "r+"); (void) sprintf(_Tty, "%s%s", DEV, Dc); /* NOTE: Dc is set in the caller routines */ break; } } /* check why the loop ended (connected or no more numbers to try) */ if (count == argc) cleanup(101); /****** Successfully made connection ******/ VERBOSE("Connected\n%s", ""); #ifdef DATAKIT if (!strcmp(_Dev[D_CALLER], "DK")) { strcpy(_Tty, dtnamer(dkminor(fdl))); strcpy(Dc, (strrchr(_Tty, '/')+1)); if ((_Fdl = fopen(_Tty, "r+")) == NULL) { (void) fprintf(stderr, "ct: Cannot open %s, errno %d\n", _Tty, errno); cleanup(101); } } #endif /* ignore some signals if they were ignored upon invocation of ct */ /* or else, have them go to graceful disconnect */ if (save_hup == SIG_IGN) (void) signal (SIGHUP, SIG_IGN); else (void) signal (SIGHUP, disconnect); if (save_quit == SIG_IGN) (void) signal (SIGQUIT, SIG_IGN); else (void) signal (SIGQUIT, disconnect); if (save_int == SIG_IGN) (void) signal (SIGINT, SIG_IGN); else (void) signal (SIGINT, disconnect); (void) signal (SIGTERM, disconnect); (void) signal (SIGALRM, disconnect); (void) sleep (2); /* time for phone line/modem to settle */ _Log_on = time ((time_t *) 0); /* * if there is a login process on this line, * tell the user to hit a carriage return to make * the waiting process get past the inital read, * Then exit. */ if (logprocflag) { /* there is a login process on the line */ (void) fputs("Hit carriage return ", _Fdl); (void) fclose(_Fdl); CDEBUG(4, "there is a login process; exit\n%s", ""); exit(0); } CDEBUG(4, "start login process (%s ", TTYMON); CDEBUG(4, "-g -h -t 60 -l %s)\n", fdig(_Flds[F_CLASS])); for (;;) { pid_t w_ret; switch(_Pid = fork()) { case -1: /* fork failed */ if ((!hangup || Verbose)) (void) fputs ("ct: can't fork for login process\n", stderr); cleanup(101); /*NOTREACHED*/ case 0: /* child process */ startat (); (void) close(2); /* ttymon will use open fd 0 for connection */ if ( fdl != 0 ) { (void) close(0); dup(fdl); } (void) signal(SIGHUP, SIG_DFL); /* so child will exit on hangup */ (void) execl(TTYMON, "ttymon", "-g", "-h", "-t", "60", "-l", fdig(_Flds[F_CLASS]), (char *) 0); /* exec failed */ cleanup(101); /*NOTREACHED*/ default: /* parent process */ break; } /* Parent process */ while ((w_ret = wait(&_Status)) != _Pid) if (w_ret == -1 && errno != EINTR) { VERBOSE("ct: wait failed errno=%d\n", errno); cleanup(101); } if ((_Status & 0xff00) < 0) { if (!hangup) VERBOSE("ct: can't exec login process\n%s", ""); cleanup(101); } stopat(_Flds[F_PHONE]); rewind (_Fdl); /* flush line */ (void) fputs ("\nReconnect? ", _Fdl); rewind (_Fdl); (void) alarm (20); c = getc (_Fdl); if (c == EOF || tolower (c) == 'n') disconnect (0); /* normal disconnect */ while ( (c = getc(_Fdl)) != EOF && c != '\n') ; (void) alarm (0); } } static void disconnect (code) { struct termio termio; (void) alarm(0); (void) signal (SIGALRM, SIG_IGN); (void) signal (SIGINT, SIG_IGN); (void) signal (SIGTERM, SIG_IGN); _Log_elpsd = time ((time_t *) 0) - _Log_on; (void) ioctl (fileno(_Fdl), TCGETA, &termio); termio.c_cflag = 0; /* speed to zero for hangup */ (void) ioctl (fileno(_Fdl), TCSETAW, &termio); /* hang up terminal */ (void) fclose (_Fdl); DEBUG(5, "Disconnect(%d)\n", code); VERBOSE("Disconnected\n%s", ""); /* For normal disconnect or timeout on "Reconnect?" message, we already cleaned up above */ if ((code != 0) && (code != SIGALRM)) stopat(_Flds[F_PHONE]); cleanup(code); } /* * clean and exit with "code" status */ void cleanup (code) int code; { CDEBUG(5, "cleanup(%d)\n", code); rmlock (CNULL); if (*_Tty != '\0') { CDEBUG(5, "chmod/chown %s\n", _Tty); if (chown(_Tty , UUCPUID, TTYGID) < 0 ) { CDEBUG(5, "Can't chown to uid=%u, ", UUCPUID); CDEBUG(5, "gid=%u\n", TTYGID); } if (chmod(_Tty , TTYMOD) < 0) { CDEBUG(5, "Can't chmod to %lo\n", (unsigned long) TTYMOD); } } if (_Pid) { /* kill the child process */ (void) signal(SIGHUP, SIG_IGN); (void) signal(SIGQUIT, SIG_IGN); (void) kill (_Pid, SIGKILL); } exit (code); } /* gdev() * Find an available line with a dialer on it. * Set a temporary lock file for the line. * Return: * >0 - got a dialer * <0 - failed - return the number of possible dialers * 0 - not dialers of requested class on the system. */ static int gdev (flds) char *flds[]; { int count = 0; extern void devreset(); devreset(); while (rddev ("ACU", _Dev, _Devbuf, D_MAX) != FAIL) { /* check caller type */ if (!EQUALS (flds[F_TYPE] /* "ACU" */, _Dev[D_TYPE])) continue; /* check class, check (and possibly set) speed */ if (!EQUALS (flds[F_CLASS] /* speed */, _Dev[D_CLASS])) continue; count++; if (fn_cklock(_Dev[D_LINE]) == FAIL) continue; /* found available dialer and set temporary lock */ return (count); } return (- count); } /* * Check if there is a login process active on this line. * Return: * 0 - there is no login process on this line * 1 - found a login process on this line */ static int logproc(line) char *line; { struct utmpx *u; while ((u = getutxent()) != NULL) { if (u->ut_type == LOGIN_PROCESS && EQUALS(u->ut_line, line) && EQUALS(u->ut_user, "LOGIN") ) { CDEBUG(7, "ut_line %s, ", u->ut_line); CDEBUG(7, "ut_user %s, ", u->ut_user); CDEBUG(7, "ut_id %.4s, ", u->ut_id); CDEBUG(7, "ut_pid %d\n", u->ut_pid); /* see if the process is still active */ if (kill(u->ut_pid, 0) == 0 || errno == EPERM) { CDEBUG(4, "process still active\n%s", ""); return(1); } } } return(0); } /* * Create an entry in utmpx file if one does not already exist. */ static void startat () { struct utmpx utmpxbuf, *u; int fd; /* Set up the prototype for the utmpx structure we want to write. */ u = &utmpxbuf; zero (&u -> ut_user[0], sizeof (u -> ut_user)); zero (&u -> ut_line[0], sizeof (u -> ut_line)); /* Fill in the various fields of the utmpx structure. */ u -> ut_id[0] = 'c'; u -> ut_id[1] = 't'; u -> ut_id[2] = _Tty[strlen(_Tty)-2]; u -> ut_id[3] = _Tty[strlen(_Tty)-1]; u -> ut_pid = getpid (); u -> ut_exit.e_termination = 0; u -> ut_exit.e_exit = 0; u -> ut_type = INIT_PROCESS; time (&u -> ut_xtime); setutxent (); /* Start at beginning of utmpx file. */ /* For INIT_PROCESSes put in the name of the program in the */ /* "ut_user" field. */ strncpy (&u -> ut_user[0], "ttymon", sizeof (u -> ut_user)); strncpy (&u -> ut_line[0], Dc, sizeof (u -> ut_line)); /* Write out the updated entry to utmpx file. */ pututxline (u); /* Now attempt to add to the end of the wtmpx file. Do not create */ /* if it doesn't already exist. Do not overwrite any info already */ /* in file. */ if ((fd = open(WTMPX_FILE, O_WRONLY | O_APPEND)) != -1) { (void) write(fd, u, sizeof(*u)); (void) close(fd); } endutxent (); return; } /* * Change utmpx file entry to "dead". * Make entry in ct log. */ static void stopat (num) char *num; { struct utmpx utmpxbuf, *u; int fd; FILE * fp; /* Set up the prototype for the utmpx structure we want to write. */ setutxent(); u = &utmpxbuf; zero (&u -> ut_user[0], sizeof (u -> ut_user)); zero (&u -> ut_line[0], sizeof (u -> ut_line)); /* Fill in the various fields of the utmpx structure. */ u -> ut_id[0] = 'c'; u -> ut_id[1] = 't'; u -> ut_id[2] = _Tty[strlen(_Tty)-2]; u -> ut_id[3] = _Tty[strlen(_Tty)-1]; u -> ut_pid = (pid_t) _Pid; u -> ut_type = USER_PROCESS; /* Find the old entry in the utmpx file with the user name and */ /* copy it back. */ if (u = getutxid (u)) { utmpxbuf = *u; u = &utmpxbuf; } u -> ut_exit.e_termination = _Status & 0xff; u -> ut_exit.e_exit = (_Status >> 8) & 0xff; u -> ut_type = DEAD_PROCESS; time (&u -> ut_xtime); /* Write out the updated entry to utmpx file. */ pututxline (u); /* Now attempt to add to the end of the wtmpx file. Do not create */ /* if it doesn't already exist. Do not overwrite any info already */ /* in file. */ if ((fd = open(WTMPX_FILE, O_WRONLY | O_APPEND)) != -1) { (void) write(fd, u, sizeof(*u)); (void) close(fd); } endutxent (); /* Do the log accounting */ if (exists (LOG) && (fp = fopen (LOG, "a")) != NULL) { char *aptr; int hrs, mins, secs; /* ignore user set TZ for logfile purposes */ if ( (aptr = getenv ("TZ")) != NULL ) *aptr = '\0'; (aptr = ctime (&_Log_on))[16] = '\0'; hrs = _Log_elpsd / 3600; mins = (_Log_elpsd %= 3600) / 60; secs = _Log_elpsd % 60; (void) fprintf(fp, "%-8s ", getpwuid (getuid ()) -> pw_name); (void) fprintf(fp, "(%4s) %s ", fdig(_Flds[F_CLASS]), aptr); if (hrs) (void) fprintf(fp, "%2d:%.2d", hrs, mins); else (void) fprintf(fp, " %2d", mins); (void) fprintf(fp, ":%.2d %s\n", secs, num); (void) fclose (fp); } return; } static int exists (file) char *file; { struct stat statb; if (stat (file, &statb) == -1 && errno == ENOENT) return (0); return (1); } static void zero (adr, size) char *adr; int size; { while (size--) *adr++ = '\0'; return; }