cmd/boot: usr/src/cmd/boot build needs cleanup

[unleashed.git] / usr / src / cmd / ttymon / tmhandler.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 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"


#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <string.h>
#include <termio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stropts.h>
#include <unistd.h>
#include <sys/wait.h>
#include "ttymon.h"
#include "tmstruct.h"
#include "tmextern.h"
#include "sac.h"

extern  int     Retry;
static  struct  pmtab   *find_pid();
static  void    kill_children();

static  struct  pmtab   *find_fd();
static  void    pcsync_close();
extern  void    sigalarm();
extern  void    tmchild();

/*
 *      fork_tmchild    - fork child on the device
 */
static  void
fork_tmchild(pmptr)
struct  pmtab   *pmptr;
{
        pid_t   pid;
        sigset_t        cset;
        sigset_t        tset;
        int     pcpipe0[2], pcpipe1[2];
        int     p0;

#ifdef  DEBUG
        debug("in fork_tmchild");
#endif
        pmptr->p_inservice = FALSE;

        /*
         * initialize pipe. 
         * Child has pcpipe[0] pipe fd for reading and writing
         * and closes pcpipe[1]. Parent has pcpipe[1] pipe fd for
         * reading and writing and closes pcpipe[0].
         *
         * This way if the child process exits the parent's block
         * read on pipe will return immediately as the other end of
         * the pipe has closed. Similarly if the parent process exits
         * child's blocking read on the pipe will return immediately.
         */

        if (((p0 = pipe(pcpipe0)) == -1) || (pipe(pcpipe1) == -1))  {
                if (p0 == 0) {
                        close(pcpipe0[0]);
                        close(pcpipe0[1]);
                }
                log("pipe() failed: %s", strerror(errno));
                pmptr->p_status = VALID;
                pmptr->p_pid = 0;
                Retry = TRUE;
        }

        /* protect following region from SIGCLD */
        (void)sigprocmask(SIG_SETMASK, NULL, &cset);
        tset = cset;
        (void)sigaddset(&tset, SIGCLD);
        (void)sigprocmask(SIG_SETMASK, &tset, NULL);
        if( (pid=fork()) == 0 ) {
                /*
                 * Close all file descriptors except pmptr->p_fd
                 * Wait for the parent process to close its fd
                 */
                pcsync_close(pcpipe0, pcpipe1, pid, pmptr->p_fd);
                /* The CHILD */
                tmchild(pmptr); 
                /* tmchild should never return */
                fatal("tmchild for <%s> returns unexpected", pmptr->p_device);
        }
        else if (pid < 0) {
                log("fork failed: %s", strerror(errno));
                pmptr->p_status = VALID;
                pmptr->p_pid = 0;
                Retry = TRUE;
        }
        else {
                /*
                 * The PARENT - store pid of child and close the device
                 */
                pmptr->p_pid = pid;
        }
        if (pmptr->p_fd > 0) {
                (void)close(pmptr->p_fd); 
                pmptr->p_fd = 0; 
        }
        (void)sigprocmask(SIG_SETMASK, &cset, NULL);
        /*
         * Wait for child to close file descriptors
         */
        pcsync_close(pcpipe0, pcpipe1, pid, pmptr->p_fd);
}

/*
 * got_carrier - carrier is detected on the stream
 *             - depends on the flags, different action is taken
 *             - R_FLAG - wait for data
 *             - C_FLAG - if port is not disabled, fork tmchild
 *             - A_FLAG - wait for data 
 *             - otherwise - write out prompt, then wait for data
 */
void
got_carrier(pmptr)
struct  pmtab   *pmptr;
{
        flush_input(pmptr->p_fd);

        if (pmptr->p_ttyflags & R_FLAG) {
#ifdef  DEBUG
        debug("R_FLAG");
#endif
                return;
        } 
        else if ((pmptr->p_ttyflags & (C_FLAG|B_FLAG)) &&
                (State != PM_DISABLED) &&
                (!(pmptr->p_flags & X_FLAG))) {
                fork_tmchild(pmptr);
        }
        else if (pmptr->p_ttyflags & A_FLAG) {
#ifdef  DEBUG
        debug("A_FLAG");
#endif
                return;
        }
        else if (pmptr->p_timeout) {
                fork_tmchild(pmptr);
        }
        else if ( ! (pmptr->p_ttyflags & X_FLAG) ) {
                write_prompt(pmptr->p_fd,pmptr,TRUE,TRUE);
        }
}

/*
 * got_data - data is detected on the stream, fork tmchild
 */
static void
got_data(pmptr)
struct  pmtab   *pmptr;
{
        struct  sigaction sigact;

        if (tm_checklock(pmptr->p_fd) != 0) {
                pmptr->p_status = LOCKED;
                (void)close(pmptr->p_fd);
                pmptr->p_fd = 0;
                Nlocked++;
                if (Nlocked == 1) {
                        sigact.sa_flags = 0;
                        sigact.sa_handler = sigalarm;
                        (void)sigemptyset(&sigact.sa_mask);
                        (void)sigaction(SIGALRM, &sigact, NULL);
                        (void)alarm(ALARMTIME);
                }
        }
        else 
                fork_tmchild(pmptr);
}
/*
 * got_hup - stream hangup is detected, close the device
 */
static void
got_hup(pmptr)
struct  pmtab   *pmptr;
{
#ifdef  DEBUG
        debug("in got hup");
#endif
        (void)close(pmptr->p_fd);
        pmptr->p_fd = 0;
        pmptr->p_inservice = 0;
        Retry = TRUE;
}


/*
 *      do_poll - poll device
 *              - if POLLHUP received, close the device
 *              - if POLLIN received, fork tmchild.
 */
void
do_poll(fdp,nfds)
struct  pollfd *fdp; 
int     nfds;
{
        int     i,n;
        struct  pmtab   *pmptr;

        n = poll(fdp, (unsigned long)nfds, -1); /* blocked poll */
#ifdef  DEBUG
        debug("poll return");
#endif
        if (n < 0) {
                if (errno == EINTR)     /* interrupt by signal */
                        return;
                fatal("do_poll: poll failed: %s", strerror(errno));
        }
        for (i = 0; (i < nfds)&&(n); i++,fdp++) {
                if (fdp->revents != 0) {
                        n--;
                        if ((pmptr = find_fd(fdp->fd)) == NULL) {
                                log("do_poll: cannot find fd %d in pmtab",
                                    fdp->fd);
                                continue;
                        }
                        else if (fdp->revents & POLLHUP) {
                                got_hup(pmptr);
                        }
                        else if (fdp->revents & POLLIN) {
#ifdef  DEBUG
                                debug("got POLLIN");
#endif
                                got_data(pmptr);
                        } else if (fdp->revents & POLLERR) {
                                fatal("ttymon[%d]: do_poll: POLLERR on fd %d",
                                    getpid(), fdp->fd);
                        }
                }
        }
}

/*
 *      sigchild        - handler for SIGCLD
 *                      - find the pid of dead child
 *                      - clean utmp if U_FLAG is set
 */
void
/*ARGSUSED*/
sigchild(n)
int     n;      /* this is declared to make cc happy, but it is not used */
{
        struct  pmtab   *pmptr;
        struct  sigaction       sigact;
        siginfo_t       info;
        int     status;
        pid_t   pid;
        int     rcode;

#ifdef  DEBUG
        debug("in sigchild");
#endif

        /* find all processes that died */
        for (;;) {
                rcode = waitid(P_ALL, 0, &info, WNOHANG|WEXITED);
                if (rcode == -1 && errno == EINTR)
                        continue;

                /* If no more children have exited, just return */
                if (rcode == -1 || (pid = info.si_pid) == 0)
                        break;

                /* construct status as returned from waitid() */
                status = info.si_status & 0377;
                switch (info.si_code) {
                case CLD_EXITED:
                        status <<= 8;
                        break;
                case CLD_DUMPED:
                        status |= WCOREFLG;
                        break;
                case CLD_KILLED:
                        break;
                }

                if ((pmptr = find_pid(pid)) == NULL) {
#ifdef  DEBUG
                        log("cannot find dead child (%ld) in pmtab", pid);
#endif
                        /*
                         * This may happen if the entry is deleted from pmtab
                         * before the service exits.
                         * We try to cleanup utmp entry
                         */
                        cleanut(pid, status);
                } else {
                        if (pmptr->p_flags & U_FLAG)
                                cleanut(pid, status);
                        pmptr->p_status = VALID;
                        pmptr->p_fd = 0;
                        pmptr->p_pid = 0;
                        pmptr->p_inservice = 0;
                        Retry = TRUE;
                }
        }
}

/*
 *      sigterm - handler for SIGTERM
 */
void
sigterm()
{
        fatal("caught SIGTERM");
}

/*
 *      state_change    - this is called when ttymon changes
 *                        its internal state between enabled and disabled
 */
void
state_change()
{
        struct pmtab *pmptr;

#ifdef  DEBUG
        debug("in state_change");
#endif

        /* 
         * closing PCpipe will cause attached non-service children 
         * to get SIGPOLL and exit
         */
        (void)close(PCpipe[0]);
        (void)close(PCpipe[1]);

        /* reopen PCpipe */
        setup_PCpipe();

        /*
         * also close all open ports so ttymon can start over
         * with new internal state
         */
        for (pmptr = PMtab; pmptr; pmptr = pmptr->p_next) {
                if ((pmptr->p_fd > 0) && (pmptr->p_pid == 0)) {
                        (void)close(pmptr->p_fd);
                        pmptr->p_fd = 0;
                }
        }
        Retry = TRUE;

}

/*
 *      re_read - reread pmtab
 *              - kill tmchild if entry changed
 */
void
re_read()
{
        extern  struct  pollfd  *Pollp;
        sigset_t        cset;
        sigset_t        tset;

        (void)sigprocmask(SIG_SETMASK, NULL, &cset);
        tset = cset;
        (void)sigaddset(&tset, SIGCLD);
        (void)sigprocmask(SIG_SETMASK, &tset, NULL);
        if (Nlocked > 0) {
                alarm(0);
                Nlocked = 0;
        }
        read_pmtab();
        kill_children();
        (void)sigprocmask(SIG_SETMASK, &cset, NULL);
        purge();

        if (Nentries > Npollfd) {
#ifdef  DEBUG
                debug("Nentries > Npollfd, reallocating pollfds");
#endif
                /* need to malloc more pollfd structure */
                free((char *)Pollp);
                Npollfd = Nentries + 10;
                if (Npollfd > Maxfds)
                        Npollfd = Maxfds;
                if ((Pollp = (struct pollfd *)
                    malloc((unsigned)(Npollfd * sizeof(struct pollfd))))
                    == (struct pollfd *)NULL) 
                        fatal("malloc for Pollp failed");
        }
        Retry = TRUE;
}

/*
 *      find_pid(pid)   - find the corresponding pmtab entry for the pid
 */
static  struct pmtab *
find_pid(pid)
pid_t   pid;
{
        struct pmtab *pmptr;

        for (pmptr = PMtab; pmptr; pmptr = pmptr->p_next) {
                if (pmptr->p_pid == pid) {
                        return(pmptr);
                }
        }
        return((struct pmtab *)NULL);
}

/*
 *      find_fd(fd)     - find the corresponding pmtab entry for the fd
 */
static struct pmtab *
find_fd(fd)
int     fd;
{
        struct pmtab *pmptr;

        for (pmptr = PMtab; pmptr; pmptr = pmptr->p_next) {
                if (pmptr->p_fd == fd) {
                        return(pmptr);
                }
        }
        return((struct pmtab *)NULL);
}

/*
 *      kill_children() - if the pmtab entry has been changed,
 *                        kill tmchild if it is not in service.
 *                      - close the device if there is no tmchild
 */
static  void
kill_children()
{
        struct pmtab *pmptr;
        for (pmptr = PMtab; pmptr; pmptr = pmptr->p_next) {
                if (pmptr->p_status == VALID)
                        continue;
                if ((pmptr->p_fd > 0) && (pmptr->p_pid == 0)) {
                        (void)close(pmptr->p_fd);
                        pmptr->p_fd = 0;
                }
                else if ((pmptr->p_fd == 0) && (pmptr->p_pid > 0)
                        && (pmptr->p_inservice == FALSE)) {
                        (void)kill(pmptr->p_pid, SIGTERM);
                }
        }
}

static  void
mark_service(pid)
pid_t   pid;
{
        struct  pmtab   *pmptr;
#ifdef  DEBUG
        debug("in mark_service");
#endif
        if ((pmptr = find_pid(pid)) == NULL) {
                log("mark_service: cannot find child (%ld) in pmtab", pid);
                return;
        }
        pmptr->p_inservice = TRUE;
        return;
}

/*
 * read_pid(fd) - read pid info from PCpipe
 */
static  void
read_pid(fd)
int     fd;
{
        int     ret;
        pid_t   pid;

        for (;;) {
                if ((ret = read(fd,&pid,sizeof(pid))) < 0) {
                        if (errno == EINTR)
                                continue;
                        if (errno == EAGAIN) 
                                return;
                        fatal("read PCpipe failed: %s", strerror(errno));
                }
                if (ret == 0)
                        return;
                if (ret != sizeof(pid))
                        fatal("read return size incorrect, ret = %d", ret);

                mark_service(pid);
        }
}

/*
 * sipoll_catch()       - signal handle of SIGPOLL for ttymon
 *                      - it will check both PCpipe and pmpipe
 */
void
sigpoll_catch()
{
        int     ret;
        struct  pollfd  pfd[2];

#ifdef  DEBUG
        debug("in sigpoll_catch");
#endif

        pfd[0].fd = PCpipe[0];
        pfd[1].fd = Pfd;
        pfd[0].events = POLLIN;
        pfd[1].events = POLLIN;
        if ((ret = poll(pfd, 2, 0)) < 0)
                fatal("sigpoll_catch: poll failed: %s", strerror(errno));

        if (ret > 0) {
                if (pfd[0].revents & POLLIN) 
                        read_pid(pfd[0].fd);
                if (pfd[1].revents & POLLIN)
                        sacpoll();
        }
}

/*ARGSUSED*/
void
sigalarm(signo)
int     signo;
{
        struct pmtab *pmptr;
        struct sigaction sigact;
        int     fd;
        extern  int     check_session();

#ifdef  DEBUG
        debug("in sigalarm, Nlocked = %d", Nlocked);
#endif
        for (pmptr = PMtab; pmptr; pmptr = pmptr->p_next) {
                if ((pmptr->p_status == LOCKED) && (pmptr->p_fd == 0)) {
                        if ((fd=open(pmptr->p_device,O_RDWR|O_NONBLOCK)) == -1){
                                log("open (%s) failed: %s", pmptr->p_device,
                                    strerror(errno));
                                pmptr->p_status = VALID;
                                Nlocked--;
                                Retry = TRUE;
                        }
                        else {
                                if (tm_checklock(fd) == 0) {
                                        Nlocked--;
                                        pmptr->p_fd = fd;
                                        Retry = TRUE;
                                }
                                else
                                        (void)close(fd);
                        }
                }
                else if ((pmptr->p_status == SESSION) && (pmptr->p_fd == 0)) {
                        if ((fd=open(pmptr->p_device,O_RDWR|O_NONBLOCK)) == -1){
                                log("open (%s) failed: %s", pmptr->p_device,
                                    strerror(errno));
                                pmptr->p_status = VALID;
                                Nlocked--;
                                Retry = TRUE;
                        }
                        else { 
                                if (check_session(fd) == 0) {
                                        Nlocked--;
                                        pmptr->p_fd = fd;
                                        Retry = TRUE;
                                }
                                else
                                        (void)close(fd);
                        }
                }
                else if ((pmptr->p_status == UNACCESS) && (pmptr->p_fd == 0)) {
                        if ((fd=open(pmptr->p_device,O_RDWR|O_NONBLOCK)) == -1){
                                log("open (%s) failed: %s", pmptr->p_device,
                                    strerror(errno));
                                pmptr->p_status = VALID;
                                Nlocked--;
                                Retry = TRUE;
                        }
                        else { 
                                Nlocked--;
                                pmptr->p_fd = fd;
                                Retry = TRUE;
                        }
                }
        }
        if (Nlocked > 0) {
                sigact.sa_flags = 0;
                sigact.sa_handler = sigalarm;
                (void)sigemptyset(&sigact.sa_mask);
                (void)sigaction(SIGALRM, &sigact, NULL);
                (void)alarm(ALARMTIME);
        }
        else {
                sigact.sa_flags = 0;
                sigact.sa_handler = SIG_IGN;
                (void)sigemptyset(&sigact.sa_mask);
                (void)sigaction(SIGALRM, &sigact, NULL);
        }
}

/*
 * pcsync_close -  For the child process close all open fd's except
 * the one that is passed to the routine. Coordinate the reads and
 * writes to the pipes by the parent and child process to ensure
 * the parent and child processes have closed all the file descriptors
 * that are not needed any more.
 */
static void
pcsync_close(p0, p1, pid, fd)
int     *p0;
int     *p1;
int     pid;
{
        char    ch;

        if (pid == 0) {                         /* Child */
                struct  pmtab   *tp;
                for (tp = PMtab; tp; tp = tp->p_next)
                        if ((tp->p_fd > 0) && (tp->p_fd != fd))
                                close(tp->p_fd);
                close(p0[1]); close(p1[0]);
                if (read(p0[0], &ch, 1) == 1)
                        write(p1[1], "a", 1);
                close(p0[0]); close(p1[1]);
        } else {                                /* Parent */
                close(p0[0]); close(p1[1]);
                if (write(p0[1], "a", 1) == 1)
                        read(p1[0], &ch, 1);
                close(p0[1]); close(p1[0]);
        }
}