8706 libc lint library missing endian.h functions

[unleashed.git] / usr / src / cmd / ttymon / tmttydefs.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        <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();
static  void    zero();
int     check_flags();
void    mkargv();

extern  struct  Gdef Gdef[];
extern  int     Ndefs;
char    *strsave();

/*
 *      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(id,check)
char    *id;
int     check;
{
        FILE     *fp;
        static   struct Gdef def;
        register struct Gdef *gptr;
        static   char   line[BUFSIZ];
        static   char   dbuf[BUFSIZ];
        register 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"
        };
        extern   char   *getword();

        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;
        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);
        return;
}

/*
 *      zero    - zero out the buffer
 */
static void
zero(adr,size)
register char *adr;
register 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(ttylabel)
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(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];
        extern   char   *sttyparse();
        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] = (char *)0;

        /*
         * 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(gptr)
struct  Gdef    *gptr;
{
        struct  Gdef    *tp;
        extern  struct  Gdef    *find_def();

        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++;
        return;
}

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

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

        for (i=0; i < maxargs; i++) args[i] = (char *)NULL;
        for (ptrin = ptrout = string,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()
{
        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 **********");
        return;
}
#endif


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

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