/*
 * 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   */

#include        <unistd.h>
#include        <stdlib.h>
#include        <sys/types.h>
#include        <ctype.h>
#include        <string.h>
#include        <pwd.h>
#include        <grp.h>
#include        <signal.h>
#include        "ttymon.h"
#include        "tmstruct.h"
#include        "tmextern.h"

static  int     get_flags(char *, long *);
static  int     get_ttyflags(char *, long *);
static  int     same_entry(struct pmtab *, struct pmtab *);
static  int     check_pmtab(struct pmtab *);
static  void    insert_pmtab(struct pmtab *);
static  void    free_pmtab(struct pmtab *);
static  char    *expand(char *, char *);

int     check_identity(struct pmtab *);

/*
 * read_pmtab()
 *      - read and parse pmtab
 *      - store table in linked list pointed by global variable "PMtab"
 *      - exit if file does not exist or error detected.
 */
void
read_pmtab(void)
{
        struct pmtab *gptr;
        char *ptr, *wptr;
        FILE     *fp;
        int      input, state, size, rawc, field, linenum;
        char     oldc;
        char     line[BUFSIZ];
        char     wbuf[BUFSIZ];
        static   char *states[] = {
            "", "tag", "flags", "identity", "reserved1", "reserved2",
            "reserved3", "device", "ttyflags", "count", "service", "timeout",
            "ttylabel", "modules", "prompt", "disable msg", "terminal type",
            "soft-carrier"
        };

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

        if ((fp = fopen(PMTABFILE, "r")) == NULL) {
                fatal("open pmtab (%s) failed", PMTABFILE);
        }

        Nentries = 0;
        if (check_version(PMTAB_VERS, PMTABFILE) != 0)
                fatal("check pmtab version failed");

        for (gptr = PMtab; gptr; gptr = gptr->p_next) {
                if ((gptr->p_status == SESSION) ||
                    (gptr->p_status == LOCKED) ||
                    (gptr->p_status == UNACCESS)) {
                        if (gptr->p_fd > 0) {
                                (void) close(gptr->p_fd);
                                gptr->p_fd = 0;
                        }
                        gptr->p_inservice = gptr->p_status;
                }
                gptr->p_status = NOTVALID;
        }

        wptr = wbuf;
        input = ACTIVE;
        linenum = 0;
        field = FAILURE;
        do {
                linenum++;
                line[0] = '\0';
                for (ptr = line, oldc = '\0'; ptr < &line[sizeof (line) - 1] &&
                    (rawc = getc(fp)) != '\n' && rawc != EOF;
                    ptr++, oldc = (char)rawc) {
                        if ((rawc == '#') && (oldc != '\\'))
                                break;
                        *ptr = (char)rawc;
                }
                *ptr = '\0';

                /* skip rest of the line */
                if (rawc != EOF && rawc != '\n') {
                        if (rawc != '#')
                                log("Entry too long.\n");
                        while ((rawc = getc(fp)) != EOF && rawc != '\n')
                                ;
                }

                if (rawc == EOF) {
                        if (ptr == line)
                                break;
                        else
                                input = FINISHED;
                }

                /* if empty line, skip */
                for (ptr = line; *ptr != '\0' && isspace(*ptr); ptr++)
                        ;
                if (*ptr == '\0')
                        continue;

#ifdef DEBUG
                debug("**** Next Entry ****\n%s", line);
#endif
                log("Processing pmtab line #%d", linenum);

                /* Now we have the complete line */

                if ((gptr = ALLOC_PMTAB) == NULL)
                        fatal("memory allocation failed");

                /* set hangup flag, this is the default */
                gptr->p_ttyflags |= H_FLAG;

                /*
                 * For compatibility reasons, we cannot rely on these
                 * having values assigned from pmtab.
                 */
                gptr->p_termtype = "";
                gptr->p_softcar = "";

                for (state = P_TAG, ptr = line; state != FAILURE &&
                    state != SUCCESS;) {
                        switch (state) {
                        case P_TAG:
                                gptr->p_tag = strsave(getword(ptr, &size, 0));
                                break;
                        case P_FLAGS:
                                (void) strcpy(wptr, getword(ptr, &size, 0));
                                if ((get_flags(wptr, &gptr->p_flags)) != 0) {
                                        field = state;
                                        state = FAILURE;
                                }
                                break;
                        case P_IDENTITY:
                                gptr->p_identity = strsave(
                                    getword(ptr, &size, 0));
                                break;
                        case P_RES1:
                                gptr->p_res1 = strsave(getword(ptr, &size, 0));
                                break;
                        case P_RES2:
                                gptr->p_res2 = strsave(getword(ptr, &size, 0));
                                break;
                        case P_RES3:
                                gptr->p_res3 = strsave(getword(ptr, &size, 0));
                                break;
                        case P_DEVICE:
                                gptr->p_device = strsave(
                                    getword(ptr, &size, 0));
                                break;
                        case P_TTYFLAGS:
                                (void) strcpy(wptr, getword(ptr, &size, 0));
                                if (get_ttyflags(wptr,
                                    &gptr->p_ttyflags) != 0) {
                                        field = state;
                                        state = FAILURE;
                                }
                                break;
                        case P_COUNT:
                                (void) strcpy(wptr, getword(ptr, &size, 0));
                                if (strcheck(wptr, NUM) != 0) {
                                        log("wait_read count must be a "
                                            "positive number");
                                        field = state;
                                        state = FAILURE;
                                } else {
                                        gptr->p_count = atoi(wptr);
                                }
                                break;
                        case P_SERVER:
                                gptr->p_server =
                                    strsave(expand(getword(ptr, &size, 1),
                                    gptr->p_device));
                                break;
                        case P_TIMEOUT:
                                (void) strcpy(wptr, getword(ptr, &size, 0));
                                if (strcheck(wptr, NUM) != 0) {
                                        log("timeout value must be a positive "
                                            "number");
                                        field = state;
                                        state = FAILURE;
                                } else {
                                        gptr->p_timeout = atoi(wptr);
                                }
                                break;
                        case P_TTYLABEL:
                                gptr->p_ttylabel = strsave(getword(ptr,
                                    &size, 0));
                                break;
                        case P_MODULES:
                                gptr->p_modules = strsave(getword(ptr,
                                    &size, 0));
                                if (vml(gptr->p_modules) != 0) {
                                        field = state;
                                        state = FAILURE;
                                }
                                break;
                        case P_PROMPT:
                                gptr->p_prompt = strsave(getword(ptr, &size,
                                    TRUE));
                                break;
                        case P_DMSG:
                                gptr->p_dmsg = strsave(getword(ptr, &size,
                                    TRUE));
                                break;

                        case P_TERMTYPE:
                                gptr->p_termtype = strsave(getword(ptr,
                                    &size, TRUE));
                                break;

                        case P_SOFTCAR:
                                gptr->p_softcar = strsave(getword(ptr,
                                    &size, TRUE));
                                break;

                        } /* end switch */
                        ptr += size;
                        if (state == FAILURE)
                                break;
                        if (*ptr == ':') {
                                ptr++;  /* Skip the ':' */
                                state++;
                        } else if (*ptr != '\0') {
                                field = state;
                                state = FAILURE;
                        }
                        if (*ptr == '\0') {
                                /*
                                 * Maintain compatibility with older ttymon
                                 * pmtab files.  If Sun-added fields are
                                 * missing, this should not be an error.
                                 */
                                if (state > P_DMSG) {
                                        state = SUCCESS;
                                } else {
                                        field = state;
                                        state = FAILURE;
                                }
                        }
                } /* end for loop */

                if (state == SUCCESS) {
                        if (check_pmtab(gptr) == 0) {
                                if (Nentries < Maxfds) {
                                        insert_pmtab(gptr);
                                } else {
                                        log("can't add more entries to "
                                            "pmtab, Maxfds = %d", Maxfds);
                                        free_pmtab(gptr);
                                        (void) fclose(fp);
                                        return;
                                }
                        } else {
                                log("Parsing failure for entry: \n%s", line);
                                log("----------------------------------------"
                                    "---");
                                free_pmtab(gptr);
                        }
                } else {
                        *++ptr = '\0';
                        log("Parsing failure in the \"%s\" field,\n%s"
                            "<--error detected here", states[field], line);
                        log("-------------------------------------------");
                        free_pmtab(gptr);
                }
        } while (input == ACTIVE);

        (void) fclose(fp);
}

/*
 * get_flags    - scan flags field to set U_FLAG and X_FLAG
 */
static  int
get_flags(char *wptr, long *flags)
{
        char    *p;
        for (p = wptr; *p; p++) {
                switch (*p) {
                case 'x':
                        *flags |= X_FLAG;
                        break;
                case 'u':
                        *flags |= U_FLAG;
                        break;
                default:
                        log("Invalid flag -- %c", *p);
                        return (-1);
                }
        }
        return (0);
}

/*
 * get_ttyflags - scan ttyflags field to set corresponding flags
 * char *wptr           pointer to the input string
 * long *ttyflags       pointer to the flag to be set
 */
static  int
get_ttyflags(char *wptr, long *ttyflags)
{
        char    *p;
        for (p = wptr; *p; p++) {
                switch (*p) {
                case 'c':
                        *ttyflags |= C_FLAG;
                        break;
                case 'h': /* h means don't hangup */
                        *ttyflags &= ~H_FLAG;
                        break;
                case 'b':
                        *ttyflags |= B_FLAG;
                        break;
                case 'r':
                        *ttyflags |= R_FLAG;
                        break;
                case 'I':
                        *ttyflags |= I_FLAG;
                        break;
                default:
                        log("Invalid ttyflag -- %c", *p);
                        return (-1);
                }
        }
        return (0);
}

#ifdef DEBUG
/*
 * pflags - put service flags into intelligible form for output
 * long flags - binary representation of the flags
 */

char *
pflags(long flags)
{
        int i;                  /* scratch counter */
        static char buf[BUFSIZ];        /* formatted flags */

        if (flags == 0)
                return ("-");
        i = 0;
        if (flags & U_FLAG) {
                buf[i++] = 'u';
                flags &= ~U_FLAG;
        }
        if (flags & X_FLAG) {
                buf[i++] = 'x';
                flags &= ~X_FLAG;
        }
        if (flags)
                log("Internal error in pflags");
        buf[i] = '\0';
        return (buf);
}

/*
 * pttyflags - put ttyflags into intelligible form for output
 * long flags - binary representation of ttyflags
 */

char *
pttyflags(long flags)
{
        int i;                  /* scratch counter */
        static char buf[BUFSIZ];        /* formatted flags */

        if (flags == 0)
                return ("h");
        i = 0;
        if (flags & C_FLAG) {
                buf[i++] = 'c';
                flags &= ~C_FLAG;
        }
        if (flags & H_FLAG)
                flags &= ~H_FLAG;
        else
                buf[i++] = 'h';
        if (flags & B_FLAG) {
                buf[i++] = 'b';
                flags &= ~B_FLAG;
        }
        if (flags & R_FLAG) {
                buf[i++] = 'r';
                flags &= ~B_FLAG;
        }
        if (flags & I_FLAG) {
                buf[i++] = 'I';
                flags &= ~I_FLAG;
        }
        if (flags)
                log("Internal error in p_ttyflags");
        buf[i] = '\0';
        return (buf);
}

void
dump_pmtab(void)
{
        struct  pmtab *gptr;

        debug("in dump_pmtab");
        log("********** dumping pmtab **********");
        log(" ");
        for (gptr = PMtab; gptr != NULL; gptr = gptr->p_next) {
                log("-------------------------------------------");
                log("tag:\t\t%s", gptr->p_tag);
                log("flags:\t\t%s", pflags(gptr->p_flags));
                log("identity:\t%s", gptr->p_identity);
                log("reserved1:\t%s", gptr->p_res1);
                log("reserved2:\t%s", gptr->p_res2);
                log("reserved3:\t%s", gptr->p_res3);
                log("device:\t%s", gptr->p_device);
                log("ttyflags:\t%s", pttyflags(gptr->p_ttyflags));
                log("count:\t\t%d", gptr->p_count);
                log("server:\t%s", gptr->p_server);
                log("timeout:\t%d", gptr->p_timeout);
                log("ttylabel:\t%s", gptr->p_ttylabel);
                log("modules:\t%s", gptr->p_modules);
                log("prompt:\t%s", gptr->p_prompt);
                log("disable msg:\t%s", gptr->p_dmsg);
                log("terminal type:\t%s", gptr->p_termtype);
                log("soft-carrier:\t%s", gptr->p_softcar);
                log("status:\t\t%d", gptr->p_status);
                log("inservice:\t%d", gptr->p_inservice);
                log("fd:\t\t%d", gptr->p_fd);
                log("pid:\t\t%ld", gptr->p_childpid);
                log("uid:\t\t%ld", gptr->p_uid);
                log("gid:\t\t%ld", gptr->p_gid);
                log("dir:\t%s", gptr->p_dir);
                log(" ");
        }
        log("********** end dumping pmtab **********");
}
#endif

/*
 * same_entry(e1,e2) -    compare 2 entries of pmtab
 *                      if the fields are different, copy e2 to e1
 *                      return 1 if same, return 0 if different
 */
static  int
same_entry(struct pmtab *e1, struct pmtab *e2)
{

        if (strcmp(e1->p_identity, e2->p_identity) != 0)
                return (0);
        if (strcmp(e1->p_res1, e2->p_res1) != 0)
                return (0);
        if (strcmp(e1->p_res2, e2->p_res2) != 0)
                return (0);
        if (strcmp(e1->p_res3, e2->p_res3) != 0)
                return (0);
        if (strcmp(e1->p_device, e2->p_device) != 0)
                return (0);
        if (strcmp(e1->p_server, e2->p_server) != 0)
                return (0);
        if (strcmp(e1->p_ttylabel, e2->p_ttylabel) != 0)
                return (0);
        if (strcmp(e1->p_modules, e2->p_modules) != 0)
                return (0);
        if (strcmp(e1->p_prompt, e2->p_prompt) != 0)
                return (0);
        if (strcmp(e1->p_dmsg, e2->p_dmsg) != 0)
                return (0);
        if (strcmp(e1->p_termtype, e2->p_termtype) != 0)
                return (0);
        if (strcmp(e1->p_softcar, e2->p_softcar) != 0)
                return (0);
        if (e1->p_flags != e2->p_flags)
                return (0);
        /*
         * compare lowest 4 bits only,
         * because A_FLAG is not part of original ttyflags
         */
        if ((e1->p_ttyflags & ~A_FLAG) != (e2->p_ttyflags & ~A_FLAG))
                return (0);
        if (e1->p_count != e2->p_count)
                return (0);
        if (e1->p_timeout != e2->p_timeout)
                return (0);
        if (e1->p_uid != e2->p_uid)
                return (0);
        if (e1->p_gid != e2->p_gid)
                return (0);
        if (strcmp(e1->p_dir, e2->p_dir) != 0)
                return (0);
        return (1);
}


/*
 * insert_pmtab - insert a pmtab entry into the linked list
 */

static  void
insert_pmtab(struct pmtab *sp)
{
        struct pmtab *tsp, *savtsp;     /* scratch pointers */
        int ret;                                /* strcmp return value */

#ifdef DEBUG
        debug("in insert_pmtab");
#endif
        savtsp = tsp = PMtab;

/*
 * find the correct place to insert this element
 */

        while (tsp) {
                ret = strcmp(sp->p_tag, tsp->p_tag);
                if (ret > 0) {
                        /* keep on looking */
                        savtsp = tsp;
                        tsp = tsp->p_next;
                        continue;
                } else if (ret == 0) {
                        if (tsp->p_status) {
                                /* this is a duplicate entry, ignore it */
                                log("Ignoring duplicate entry for <%s>",
                                    tsp->p_tag);
                        } else {
                                if (same_entry(tsp, sp)) {  /* same entry */
                                        tsp->p_status = VALID;
                                } else {        /* entry changed */
                                        if ((sp->p_flags & X_FLAG) &&
                                            ((sp->p_dmsg == NULL) ||
                                            (*(sp->p_dmsg) == '\0'))) {
                                                /* disabled entry */
                                                tsp->p_status = NOTVALID;
                                        } else {
#ifdef DEBUG
                                                debug("replacing <%s>",
                                                    sp->p_tag);
#endif
                                                /* replace old entry */
                                                sp->p_next = tsp->p_next;
                                                if (tsp == PMtab) {
                                                        PMtab = sp;
                                                } else {
                                                        savtsp->p_next = sp;
                                                }
                                                sp->p_status = CHANGED;
                                                sp->p_fd = tsp->p_fd;
                                                sp->p_childpid =
                                                    tsp->p_childpid;
                                                sp->p_inservice =
                                                    tsp->p_inservice;
                                                sp = tsp;
                                        }
                                }
                                Nentries++;
                        }
                        free_pmtab(sp);
                        return;
                } else {
                        if ((sp->p_flags & X_FLAG) &&
                            ((sp->p_dmsg == NULL) ||
                            (*(sp->p_dmsg) == '\0'))) { /* disabled entry */
                                free_pmtab(sp);
                                return;
                        }
                        /*
                         * Set the state of soft-carrier.
                         * Since this is a one-time only operation,
                         * we do it when this service is added to
                         * the enabled list.
                         */
                        if (*sp->p_softcar != '\0')
                                set_softcar(sp);

                        /* insert it here */
                        if (tsp == PMtab) {
                                sp->p_next = PMtab;
                                PMtab = sp;
                        } else {
                                sp->p_next = savtsp->p_next;
                                savtsp->p_next = sp;
                        }
#ifdef DEBUG
                        debug("adding <%s>", sp->p_tag);
#endif
                        Nentries++;
                        /* this entry is "current" */
                        sp->p_status = VALID;
                        return;
                }
        }

/*
 * either an empty list or should put element at end of list
 */

        if ((sp->p_flags & X_FLAG) &&
            ((sp->p_dmsg == NULL) ||
            (*(sp->p_dmsg) == '\0'))) { /* disabled entry */
                free_pmtab(sp);          /* do not poll this entry */
                return;
        }
        /*
         * Set the state of soft-carrier.
         * Since this is a one-time only operation,
         * we do it when this service is added to
         * the enabled list.
         */
        if (*sp->p_softcar != '\0')
                set_softcar(sp);
        sp->p_next = NULL;
        if (PMtab == NULL)
                PMtab = sp;
        else
                savtsp->p_next = sp;
#ifdef DEBUG
        debug("adding <%s>", sp->p_tag);
#endif
        ++Nentries;
        /* this entry is "current" */
        sp->p_status = VALID;
}


/*
 * purge - purge linked list of "old" entries
 */
void
purge(void)
{
        struct pmtab *sp;               /* working pointer */
        struct pmtab *savesp, *tsp;     /* scratch pointers */

#ifdef DEBUG
        debug("in purge");
#endif
        sp = savesp = PMtab;
        while (sp) {
                if (sp->p_status) {
#ifdef DEBUG
                        debug("p_status not 0");
#endif
                        savesp = sp;
                        sp = sp->p_next;
                } else {
                        tsp = sp;
                        if (tsp == PMtab) {
                                PMtab = sp->p_next;
                                savesp = PMtab;
                        } else {
                                savesp->p_next = sp->p_next;
                        }
#ifdef DEBUG
                        debug("purging <%s>", sp->p_tag);
#endif
                        sp = sp->p_next;
                        free_pmtab(tsp);
                }
        }
}

/*
 *      free_pmtab      - free one pmtab entry
 */
static  void
free_pmtab(struct pmtab *p)
{
#ifdef  DEBUG
        debug("in free_pmtab");
#endif
        free(p->p_tag);
        free(p->p_identity);
        free(p->p_res1);
        free(p->p_res2);
        free(p->p_res3);
        free(p->p_device);
        free(p->p_server);
        free(p->p_ttylabel);
        free(p->p_modules);
        free(p->p_prompt);
        free(p->p_dmsg);
        free(p->p_termtype);
        free(p->p_softcar);
        free(p->p_dir);
        free(p);
}

/*
 *      check_pmtab - check the fields to make sure things are correct
 *                  - return 0 if everything is ok
 *                  - return -1 if something is wrong
 */
static  int
check_pmtab(struct pmtab *p)
{
        if (p == NULL) {
                log("pmtab ptr is NULL");
                return (-1);
        }

        /* check service tag */
        if ((p->p_tag == NULL) || (*(p->p_tag) == '\0')) {
                log("port/service tag is missing");
                return (-1);
        }
        if (strlen(p->p_tag) > (size_t)(MAXID - 1)) {
                log("port/service tag <%s> is longer than %d", p->p_tag,
                    MAXID-1);
                return (-1);
        }
        if (strcheck(p->p_tag, ALNUM) != 0) {
                log("port/service tag <%s> is not alphanumeric", p->p_tag);
                return (-1);
        }
        if (check_identity(p) != 0) {
                return (-1);
        }

        if (check_device(p->p_device) != 0)
                return (-1);

        if (check_cmd(p->p_server) != 0)
                return (-1);
        return (0);
}

/*
 *      check_identity  - check to see if the identity is a valid user
 *                      - log name in the passwd file,
 *                      - and if its group id is a valid one
 *                      - return 0 if everything is ok. Otherwise, return -1
 */

int
check_identity(struct pmtab *p)
{
        struct passwd *pwdp;

        if ((p->p_identity == NULL) || (*(p->p_identity) == '\0')) {
                log("identity field is missing");
                return (-1);
        }
        if ((pwdp = getpwnam(p->p_identity)) == NULL) {
                log("missing or bad passwd entry for <%s>", p->p_identity);
                endpwent();
                return (-1);
        }
        if (getgrgid(pwdp->pw_gid) == NULL) {
                log("no group entry for %ld", pwdp->pw_gid);
                endgrent();
                endpwent();
                return (-1);
        }
        p->p_uid = pwdp->pw_uid;
        p->p_gid = pwdp->pw_gid;
        p->p_dir = strsave(pwdp->pw_dir);
        endgrent();
        endpwent();
        return (0);
}

/*
 * expand(cmdp, devp)   - expand %d to device name and %% to %,
 *                              - any other characters are untouched.
 *                              - return the expanded string
 */
static char     *
expand(char *cmdp, char *devp)
{
        char    *cp, *dp, *np;
        static char     buf[BUFSIZ];
        cp = cmdp;
        np = buf;
        dp = devp;
        while (*cp) {
                if (*cp != '%') {
                        *np++ = *cp++;
                        continue;
                }
                switch (*++cp) {
                case 'd':
                        while (*dp) {
                                *np++ = *dp++;
                        }
                        cp++;
                        break;
                case '%':
                        *np++ = *cp++;
                        break;
                default:
                        *np++ = *cp++;
                        break;
                }
        }
        *np = '\0';
        return (buf);
}