OpenSolaris_b135/cmd/ttymon/tmpmtab.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 <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"
extern char *strsave();
extern void set_softcar();
extern int vml();
void purge();
static int get_flags();
static int get_ttyflags();
static int same_entry();
static int check_pmtab();
static void insert_pmtab();
static void free_pmtab();
static char *expand();
int check_identity();
int strcheck();
/*
* 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()
{
register struct pmtab *gptr;
register 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;
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) == PNULL)
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);
return;
}
/*
* get_flags - scan flags field to set U_FLAG and X_FLAG
*/
static int
get_flags(wptr, flags)
char *wptr; /* pointer to the input string */
long *flags; /* pointer to the flag to set */
{
register 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
*/
static int
get_ttyflags(wptr, ttyflags)
char *wptr; /* pointer to the input string */
long *ttyflags; /* pointer to the flag to be set*/
{
register 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
*/
char *
pflags(flags)
long flags; /* binary representation of the flags */
{
register 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
*/
char *
pttyflags(flags)
long flags; /* binary representation of ttyflags */
{
register 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()
{
struct pmtab *gptr;
debug("in dump_pmtab");
log("********** dumping pmtab **********");
log(" ");
for (gptr=PMtab; gptr; 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_pid);
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(e1,e2)
struct pmtab *e1,*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(sp)
register struct pmtab *sp; /* ptr to entry to be inserted */
{
register 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_pid = tsp->p_pid;
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()
{
register struct pmtab *sp; /* working pointer */
register 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(p)
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);
if (p->p_dir)
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(p)
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);
}
extern struct passwd *getpwnam();
extern void endpwent();
extern struct group *getgrgid();
extern void endgrent();
/*
* 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(p)
struct pmtab *p;
{
register 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(cmdp,devp)
char *cmdp; /* ptr to cmd string */
char *devp; /* ptr to device name */
{
register 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);
}