OpenSolaris_b135/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);
}