/*
 * 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        <stdio.h>
#include        <ctype.h>
#include        <string.h>
#include        <sys/types.h>
#include        <sys/stat.h>
#include        <termio.h>
#include        <sys/stermio.h>
#include        <sys/termiox.h>
#include        "ttymon.h"
#include        "tmstruct.h"
#include        "tmextern.h"
#include        "stty.h"

static  void    insert_def(struct Gdef *);
static  void    zero(char *, int);

/*
 *      read_ttydefs    - read in the /etc/ttydefs and store in Gdef array
 *                      - if id is not NULL, only get entry with that id
 *                      - if check is TRUE, print out the entries
 */
void
read_ttydefs(const char *id, int check)
{
        FILE    *fp;
        static  struct Gdef def;
        struct  Gdef *gptr;
        static  char    line[BUFSIZ];
        static  char    dbuf[BUFSIZ];
        char    *ptr;
        int     len;
        int     input, state, size, rawc, field;
        char    oldc;
        static  char    d_id[MAXID+1],
            d_nextid[MAXID+1],
            d_autobaud[MAXID+1],
            d_if[BUFSIZ],
            d_ff[BUFSIZ];
        static  char *states[] = {
            "", "tty label", "Initial flags", "Final flags", "Autobaud",
            "Next label"
        };

        if ((fp = fopen(TTYDEFS, "r")) == NULL) {
                log("can't open \"%s\".\n", TTYDEFS);
                return;
        }

        if (check) {
                for (len = 0; len < (size_t)(BUFSIZ - 1); len++)
                        dbuf[len] = '-';
                dbuf[len] = '\0';
        }

        /* Start searching for the line with the proper "id". */
        input = ACTIVE;
        field = FAILURE;
        do {
                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 (check && rawc != '#')
                                log("Entry too long.");
                        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;

                /* Now we have the complete line */

                /* Initialize "def" and "gptr". */
                gptr = &def;
                zero((char *)gptr, sizeof (struct Gdef));

                ptr = line;
                state = T_TTYLABEL;
                (void) strncpy(d_id, getword(ptr, &size, 0), MAXID);
                gptr->g_id = d_id;
                ptr += size;
                if (*ptr != ':') {
                        field = state;
                        state = FAILURE;
                } else {
                        ptr++;  /* Skip the ':' */
                        state++;
                }

                /* If "id" != NULL, and it does not match, go to next entry */
                if ((id != NULL) && (strcmp(id, gptr->g_id) != 0))
                        continue;

                if (check) {
                        len = strlen(line);
                        dbuf[len] = '\0';
                        log("\n%s", dbuf);
                        log("%s", line);
                        log("%s\n", dbuf);
                        dbuf[len] = '-';
                }


                for (; state != FAILURE && state != SUCCESS; ) {
                        switch (state) {

                        case T_IFLAGS:
                                (void) strncpy(d_if, getword(ptr, &size, 1),
                                    BUFSIZ);
                                gptr->g_iflags = d_if;
                                ptr += size;
                                if ((*ptr != ':') || (check_flags(d_if) != 0)) {
                                        field = state;
                                        state = FAILURE;
                                } else {
                                        ptr++;
                                        state++;
                                }
                                break;

                        case T_FFLAGS:
                                (void) strncpy(d_ff, getword(ptr, &size, 1),
                                    BUFSIZ);
                                gptr->g_fflags = d_ff;
                                ptr += size;
                                if ((*ptr != ':') || (check_flags(d_ff) != 0)) {
                                        field = state;
                                        state = FAILURE;
                                } else {
                                        ptr++;
                                        state++;
                                }
                                break;

                        case T_AUTOBAUD:
                                (void) strncpy(d_autobaud,
                                    getword(ptr, &size, 0), MAXID);
                                if (size > 1) {
                                        ptr += size;
                                        field = state;
                                        state = FAILURE;
                                        break;
                                }
                                if (size == 1) {
                                        if (*d_autobaud == 'A') {
                                                gptr->g_autobaud |= A_FLAG;
                                        } else {
                                                ptr += size;
                                                field = state;
                                                state = FAILURE;
                                                break;
                                        }
                                }
                                ptr += size;
                                if (*ptr != ':') {
                                        field = state;
                                        state = FAILURE;
                                } else {
                                        ptr++;  /* Skip the ':' */
                                        state++;
                                }
                                break;

                        case T_NEXTLABEL:
                                (void) strncpy(d_nextid,
                                    getword(ptr, &size, 0), MAXID);
                                gptr->g_nextid = d_nextid;
                                ptr += size;
                                if (*ptr != '\0') {
                                        field = state;
                                        state = FAILURE;
                                } else {
                                        state = SUCCESS;
                                }
                                break;

                        } /* end switch */
                } /* end for loop */

                if (state == SUCCESS) {

                        if (check) {
                                log("ttylabel:\t%s", gptr->g_id);
                                log("initial flags:\t%s", gptr->g_iflags);
                                log("final flags:\t%s", gptr->g_fflags);
                                if (gptr->g_autobaud & A_FLAG)
                                        log("autobaud:\tyes");
                                else
                                        log("autobaud:\tno");
                                log("nextlabel:\t%s", gptr->g_nextid);
                        }
                        if (Ndefs < MAXDEFS) {
                                insert_def(gptr);
                        } else {
                                log("can't add more entries to ttydefs table, "
                                    " Maximum entries = %d", MAXDEFS);
                                (void) fclose(fp);
                                return;
                        }
                        if (id != NULL) {
                                return;
                        }
                } else {
                        *++ptr = '\0';
                        log("Parsing failure in the \"%s\" field\n"
                            "%s<--error detected here\n", states[field], line);
                }
        } while (input == ACTIVE);
        (void) fclose(fp);
}

/*
 *      zero    - zero out the buffer
 */
static void
zero(char *adr, int size)
{
        if (adr != NULL) {
                while (size--)
                        *adr++ = '\0';
        }
}

/*
 * find_def(ttylabel)
 *      - scan Gdef table for an entry with requested "ttylabel".
 *      - return a Gdef ptr if entry with "ttylabel" is found
 *      - return NULL if no entry with matching "ttylabel"
 */

struct Gdef *
find_def(char *ttylabel)
{
        int     i;
        struct  Gdef    *tp;

        tp = &Gdef[0];
        for (i = 0; i < Ndefs; i++, tp++) {
                if (strcmp(ttylabel, tp->g_id) == 0) {
                        return (tp);
                }
        }
        return (NULL);
}

/*
 *      check_flags     - check to see if the flags contains options that are
 *                        recognizable by stty
 *                      - return 0 if no error. Otherwise return -1
 */
int
check_flags(char *flags)
{
        struct   termio termio;
        struct   termios termios;
        struct   termiox termiox;
        struct   winsize winsize;
        int      term;
        int      cnt = 1;
        char     *argvp[MAXARGS];       /* stty args */
        static   char    *binstty = "/usr/bin/stty";
        static   char   buf[BUFSIZ];
        char    *s_arg;         /* this will point to invalid option */

        /* put flags into buf, because strtok will break up buffer */
        (void) strcpy(buf, flags);
        argvp[0] = binstty;     /* just a place holder */
        mkargv(buf, &argvp[1], &cnt, MAXARGS - 1);
        argvp[cnt] = NULL;

        /*
         * because we don't know what type of terminal we have now,
         * just set term = everything, so all possible stty options
         * are accepted
         */
        term = ASYNC|TERMIOS|FLOW;
        if ((s_arg = sttyparse(cnt, argvp, term, &termio, &termios,
            &termiox, &winsize)) != NULL) {
                log("invalid mode: %s", s_arg);
                return (-1);
        }
        return (0);
}

/*
 *      insert_def      - insert one entry into Gdef table
 */
static void
insert_def(struct Gdef *gptr)
{
        struct  Gdef    *tp;

        if (find_def(gptr->g_id) != NULL) {
                log("Warning -- duplicate entry <%s>, ignored", gptr->g_id);
                return;
        }
        tp = &Gdef[Ndefs];
        tp->g_id = strsave(gptr->g_id);
        tp->g_iflags = strsave(gptr->g_iflags);
        tp->g_fflags = strsave(gptr->g_fflags);
        tp->g_autobaud = gptr->g_autobaud;
        tp->g_nextid = strsave(gptr->g_nextid);
        Ndefs++;
}

/*
 *      mkargv  - parse the string into args, starting from args[cnt]
 */

void
mkargv(char *string, char **args, int *cnt, int maxargs)
{
        char *ptrin, *ptrout;
        int i;
        int qsize;

        for (i = 0; i < maxargs; i++)
                args[i] = NULL;

        ptrin = ptrout = string;
        for (i = 0; *ptrin != '\0' && i < maxargs; i++) {
                /* Skip excess white spaces between arguments. */
                while (*ptrin == ' ' || *ptrin == '\t') {
                        ptrin++;
                        ptrout++;
                }
                /* Save the address of argument if there is something there. */
                if (*ptrin == '\0')
                        break;
                else
                        args[i] = ptrout;

/* Span the argument itself.  The '\' character causes quoting */
/* of the next character to take place (except for '\0'). */
                while (*ptrin != '\0') {
                        if (*ptrin == '\\') {
                                *ptrout++ = quoted(ptrin, &qsize);
                                ptrin += qsize;

/* Is this the end of the argument?  If so quit loop. */
                        } else if (*ptrin == ' ' || *ptrin == '\t') {
                                ptrin++;
                                break;

/* If this is a normal letter of the argument, save it, advancing */
/* the pointers at the same time. */
                        } else *ptrout++ = *ptrin++;
                }
                /* Null terminate the string. */
                *ptrout++ = '\0';
        }
        (*cnt) += i;
}

#ifdef  DEBUG
/*
 *      dump_ttydefs    - dump Gdef table to log file
 */
void
dump_ttydefs(void)
{
        int     i;
        struct  Gdef    *gptr;

        gptr = &Gdef[0];
        log("********** dumping ttydefs table **********");
        log("Ndefs = %d", Ndefs);
        log(" ");
        for (i = 0; i < Ndefs; i++, gptr++) {
                log("----------------------------------------");
                log("ttylabel:\t%s", gptr->g_id);
                log("initial flags:\t%s", gptr->g_iflags);
                log("final flags:\t%s", gptr->g_fflags);
                if (gptr->g_autobaud & A_FLAG)
                        log("autobaud:\tyes");
                else
                        log("Autobaud:\tno");
                log("nextlabel:\t%s", gptr->g_nextid);
                log(" ");
        }
        log("********** end dumping ttydefs table **********");
}
#endif


/*
 * this is copies from uucp/strsave.c
 * and is modified that if malloc fails, it will exit
 */
char *
strsave(char *str)
{
        char *rval;

        if (str == NULL) {
                if ((rval = malloc(1)) == NULL) {
                        log("strsave: malloc failed");
                        exit(1);
                }
                *rval = '\0';
        } else {
                if ((rval = malloc(strlen(str) + 1)) == NULL) {
                        log("strsave: malloc failed");
                        exit(1);
                }
                (void) strcpy(rval, str);
        }
        return (rval);
}