4.3BSD/usr/ingres/source/support/ingres.y
%{
# include <stdio.h>
# include <ctype.h>
# include <ingres.h>
# include <aux.h>
# include <version.h>
# include <access.h>
# include <lock.h>
# include <opsys.h>
# include <ctlmod.h>
# include <sccs.h>
/*
** INGRES -- INGRES startup
**
** This program starts up the entire system.
**
** Parameters:
** 1 -- database name
** 2 -- optional process table name
** x -- flags of the form +x or -x may be freely inter-
** sperced in the argument list.
**
** Return:
** none if successful
** 1 -- user error (no database, etc)
** -1 -- system error
**
** Flags:
** -&xxxx -- EQUEL flag: xxxx are file descriptors for the
** status return pipe, the command write pipe, the
** data return pipe, and the data transfer pipe
** respectively.
** -@xxxx -- xxxx is same as EQUEL flag, but no flags
** are set.
** -*?? -- Masterid flag. Gives the siteid of the master
** site in a distributed ingres. (Used in dist.
** ingres' initproc() function.)
** -|xxxx -- Network flag. This flag is just passed to
** the other processes, to be processed by the
** DBU's.
** -uusername -- set effective user to be username. You
** must be INGRES or the DBA for the database to
** use this option.
** -cN -- set minimum character field output width to be
** N, default 6. This is the fewest number of
** characters which may be output in any "c" type
** field.
** -inN -- integer output width. this is the width of
** an integer field. The small "n" is the size
** of the internal field ("1", "2", or "4") and
** N is the width of the field for that flag.
** The defaults are -i16, -i26, and -i413.
** -fnxN.M -- floating point output width and precision.
** Small "n" is the internal width in bytes ("4"
** or "8"), x is the format (f, F, g, G, e, E,
** n, or N), N is the field width, and M is the
** precision (number of digits after the decimal
** point). The formats are:
** "f" or "F": FORTRAN-style F format: digits,
** decimal point, digits, no exponent.
** "e" or "E": FORTRAN-style E format: digits,
** decimal point, digits, letter "e" (or
** "E", depending on "x" in the param-
** eter), and an exponent. The scaling
** factor is always one, that is, there
** is always one digit before the decimal
** point.
** "g" or "G": F format if it will fit in the
** field, otherwise E format. Space is
** always left at the right of the field
** for the exponent, so that decimal
** points will align.
** "n" or "N": like G, except that space is not
** left for the decimal point in F style
** format (useful if you expect everything
** to fit, but you're not sure).
** The default is -fn10.3.
** -vx -- set vertical seperator for print operations
** and retrieves to the terminal to be "x". The
** default is vertical bar ("|").
** +w -- database wait state. If set ("+w"), you will
** wait until the database is not busy. If clear,
** you will be informed if the database is busy.
** If not specified, the same operations take
** place depending on whether or not you are
** running in background (determined by whether
** or not your input is a teletype). If in fore-
** ground, you are informed; if in background,
** you wait.
** -M -- monitor trace flag
** -P -- parser trace flag
** -O -- ovqp trace flag
** -Q -- qrymod trace flag
** -D -- decomp trace flag
** -Z -- dbu trace flag. These flags require the 020 bit
** in the status field of the users file to be
** set. The syntax is loose and is described
** elsewhere. Briefly, "-Z" sets all flags except
** the last 20, "-Z4" sets flag 4, and "-Z5/7"
** sets all flags from 5 through 7.
** +L -- enable/disable upper to lower case mapping in the
** parser. Used for debugging.
** -rmode -- retrieve into mode
** -nmode -- index mode. These flags give the default
** modify mode for retrieve into and index. They
** default to cheapsort and isam. "Mode" can be
** any mode to modify except "truncated".
** +a -- enable/disable autoclear function in monitor.
** Default on.
** +b -- enable/disable batch update. Default on.
** The 02 bit is needed to clear this flag.
** +d -- enable/disable printing of the dayfile. Default
** on.
** +s -- enable/disable printing of almost everything from
** the monitor.
** +U -- enable/disable direct update of system catalogs.
** Default off. The 04 bit is needed to set this
** option.
**
** Files:
** .../files/usage -- to print a "usage: ..." message.
** .../data/base/<database>/admin -- to determine
** existance and some info about <database>.
** .../files/dayfile<VERSION> -- dayfile (printed by
** monitor).
** .../files/users -- file with UNIX uid -> INGRES code
** mapping, plus a pile of other information about
** the user.
** .../files/proctab<VERSION> -- default process table
**
**
** Note:
** this is also the startup program for sysmod.
** different flags are expected and the default process table
** is different from that of ingres.
**
*/
SCCSID(@(#)ingres.y 8.4 12/18/85)
# define MAXOPTNS 10 /* maximum number of options you can specify */
# define SYSMAXOPTNS 6 /* maximum number of options to sysmod */
# define MAXPROCS 10 /* maximum number of processes in the system */
# define EQUELFLAG '&'
# define NETFLAG '|' /* network slave flag */
# define CLOSED '?'
char Fileset[10];
char *Database;
extern char *Dbpath; /* defined in initucode */
struct admin Admin; /* set in initucode */
struct lockreq Lock;
FILE *ProcFile; /* fildes for the process table */
char *DefProcTab = NULL; /* default process table name */
char *Opt[MAXOPTNS + 1];
int Nopts;
int No_exec; /* if set, don't execute */
int NumProcs; /* number of processes this system */
/*
** Internal form of process descriptions.
*/
struct proc
{
short prstat; /* status bits, see below */
char prmpipe; /* initial pipe to this process */
char prtflag; /* trace flag for CM this proc */
char prpath[50]; /* pathname of this process */
struct _cm_t prcm; /* cm info passed to this proc */
};
/* bits for prstat */
# define PR_REALUID 0001 /* run as the user, not INGRES */
# define PR_NOCHDIR 0002 /* don't chdir into database */
# define PR_CLSSIN 0004 /* close standard input */
# define PR_CLSDOUT 0010 /* close diagnostic output */
struct proc ProcTab[CM_MAXPROC];
/*
** Open pipe info.
*/
struct pipeinfo
{
char pip_rfd; /* read file descriptor */
char pip_wfd; /* write file descriptor */
short pip_rcnt; /* read reference count */
short pip_wcnt; /* write reference count */
};
struct pipeinfo Pipe[128];
/*
** Macro definitions
*/
char Macro[26][80];
/* system error messages, etc. */
extern int sys_nerr;
extern char *sys_errlist[];
extern int errno;
/* globals used by the grammar. */
struct proc *Proc;
state_t *StateP;
proc_t *ProcP;
int ProcNo;
int RemStat;
%}
%union
{
int yyint; /* integer */
char *yystr; /* string */
char yypip; /* pipe id */
char yychar; /* single character */
}
%token <yyint> INT
%token <yystr> STR
%type <yyint> procno stateno funcno
%type <yyint> flags
%type <yystr> pathname printname
%type <yypip> pipe_id
%type <yychar>macro_id tflag
%%
proctab: spec_list
;
spec_list: spec
| spec_list spec
;
spec: proc_line states
| macro_defn
;
/*
** Lines beginning with "P" introduce new processes.
**
** procno is the number of the process being defined.
** pathname is the pathname of the executable object
** of this module.
** printname is the name to be used as "Procname" in
** this module for activities unconnected with
** particular modules.
** pipe_id is the pipe to use as the normal input for
** this process. It must be listed as a pipe
** in at least one of the constituent state
** definitions.
** flags are flags associated with this process. They
** are not actually passed to the process, but
** are used internally. See the #defines after
** /^struct proc/.
*/
proc_line: 'P' procno pathname printname pipe_id flags tflag
{
NumProcs++;
Proc = &ProcTab[$2];
smove($3, Proc->prpath);
Proc->prmpipe = Proc->prcm.cm_input = Proc->prcm.cm_rinput
= Proc->prcm.cm_proc[$2].pr_ninput = $5;
smove($4, Proc->prcm.cm_myname);
Proc->prcm.cm_myproc = $2;
Proc->prstat = $6;
Proc->prtflag = $7;
Pipe[$5].pip_rcnt += 3;
Pipe[$5].pip_wcnt++;
}
;
states: state_line
| states state_line
;
state_line: local_line
| remote_line
;
local_line: 'L' stateno flags funcno stateno
{
StateP = &Proc->prcm.cm_state[$2];
StateP->st_type = ST_LOCAL;
StateP->st_stat = $3;
StateP->st_v.st_loc.st_funcno = $4;
StateP->st_v.st_loc.st_next = $5;
}
;
remote_line: remote_header stateno_list
;
remote_header: 'R' procno flags pipe_id pipe_id flags
{
ProcNo = $2;
ProcP = &Proc->prcm.cm_proc[ProcNo];
RemStat = $3;
ProcP->pr_file = $4;
ProcP->pr_ninput = $5;
ProcP->pr_stat = $6;
Pipe[$4].pip_wcnt++;
Pipe[$5].pip_rcnt++;
}
;
stateno_list: /* empty */
| stateno_list remote_stateno
;
remote_stateno: stateno
{
StateP = &Proc->prcm.cm_state[$1];
StateP->st_type = ST_REMOT;
StateP->st_stat = RemStat;
StateP->st_v.st_rem.st_proc = ProcNo;
}
;
/*
** Macro definitions.
*/
macro_defn: 'D' macro_id STR
{
smove($3, Macro[$2 - 'A']);
}
/*
** Productions for things that perhaps ought to be in the scanner.
*/
procno: INT
{
if ($1 < 0 || $1 >= CM_MAXPROC)
{
usrerr("Illegal proc number %d", $1);
YYERROR;
}
}
;
stateno: INT
{
if ($1 < 0 || $1 >= CM_MAXST)
{
usrerr("Illegal state number %d", $1);
YYERROR;
}
}
;
funcno: INT
{
if ($1 < 0)
{
usrerr("Illegal funcno %d", $1);
YYERROR;
}
}
;
pathname: STR
;
printname: STR
;
pipe_id: STR
{
if ((islower($1[0]) || $1[0] == CLOSED) && $1[1] == '\0')
$$ = $1[0];
else if ($1[0] == '|' && isdigit($1[1]) && $1[2] == '\0')
$$ = $1[1];
else
{
usrerr("Invalid pipe id \"%s\"", $1);
YYERROR;
}
}
;
tflag: STR
{
if ($1[1] != '\0')
{
usrerr("Invalid trace flag \"%s\"", $1);
YYERROR;
}
else
$$ = $1[0];
}
;
flags: INT
;
macro_id: STR
{
if ($1[0] < 'A' || $1[0] > 'Z' || $1[1] != '\0')
{
usrerr("Invalid macro name \"%s\"", $1);
YYERROR;
}
else
$$ = $1[0];
}
%%
main(argc, argv)
int argc;
char **argv;
{
register int i;
register int j;
extern char *Proc_name;
int fd;
extern int Status;
char *proctab;
register char *p;
char *ptr;
extern char *Flagvect[]; /* defined in initucode.c */
extern char *Parmvect[]; /* ditto */
char *uservect[4];
char buf[MAXLINE+1];
char str[MAXLINE+1]; /* a string to put the Alockdes value into */
char str2[MAXLINE+1];
extern int Wait_action; /* action on lock driver */
int CallSysmod = FALSE;
struct proc *pr;
int len;
char *sysptr;
/*
** sysmod is linked to ingres.
** check whether ingres or sysmod was called.
*/
len = strlen(argv[0]);
sysptr = &argv[0][len - 6];
if (sequal( sysptr, "sysmod"))
{
CallSysmod = TRUE;
Proc_name = "SYSMOD";
}
else
Proc_name = "INGRES";
itoa(getpid(), Fileset);
proctab = NULL;
Database = NULL;
/*
** Initialize everything, like Flagvect, Parmvect, Usercode,
** etc.
*/
for (i = 0; i < 128; i++)
Pipe[i].pip_rfd = Pipe[i].pip_wfd = -1;
i = initucode(argc, argv, TRUE, uservect, CallSysmod?M_EXCL:-1);
switch (i)
{
case 0: /* ok */
case INDIRECT:
break;
case NODB: /* database does not exist */
case INDNODB:
printf("Database %s does not exist\n", Parmvect[0]);
if (CallSysmod)
goto sysusage;
else
goto usage;
case NOACCESS: /* you are not authorized */
printf("You may not access database %s\n", Database);
if (CallSysmod)
goto sysusage;
else
goto usage;
case INVALIDUSR: /* not a valid user */
printf("You are not a valid INGRES user\n");
if (CallSysmod)
goto sysusage;
else
goto usage;
case NODBNAME: /* no database name specified */
printf("No database name specified\n");
if (CallSysmod)
goto sysusage;
else
goto usage;
default:
syserr("initucode %d", i);
}
/*
** Extract database name and process table name from
** parameter vector.
** Initialize the $P macro.
*/
Database = Parmvect[0];
proctab = Parmvect[1];
smove(Pathname, Macro['P' - 'A']);
if (!CallSysmod)
{
/* scan flags in users file */
for (p = uservect[0]; *p != '\0'; p++)
{
/* skip initial blanks and tabs */
if (*p == ' ' || *p == '\t')
continue;
ptr = p;
/* find end of flag and null-terminate it */
while (*p != '\0' && *p != ' ' && *p != '\t')
p++;
i = *p;
*p = '\0';
/* process the flag */
doflag(ptr, 1);
if (i == '\0')
break;
}
/* scan flags on command line */
for (i = 0; (p = Flagvect[i]) != NULL; i++)
doflag(p, 0);
/* check for query modification specified for this database */
if ((Admin.adhdr.adflags & A_QRYMOD) == 0)
doflag("-q", -1);
}
/* special routine for handling sysmod flags */
else
{
DefProcTab = "=sysmod";
if ( Flagvect[0] == NULL)
{
if (!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ))
{
printf("You are not the dba for %s\n", Database);
No_exec++;
}
}
for (i = 0; (p = Flagvect[i]) != NULL; i++)
sysflag(p);
}
/* close any extraneous files, being careful not to close anything we need */
for (i = 3; i < NOFILE; i++)
{
for (j = '0'; j <= '9'; j++)
{
if (Pipe[j].pip_wfd == i || Pipe[j].pip_rfd == i)
break;
}
if (j > '9')
close(i);
}
/* determine process table */
if (proctab == NULL)
{
/* use default proctab */
if (DefProcTab == NULL)
{
if (argv[0][length(argv[0]) - 1] == 'x')
DefProcTab = "=procx";
else
DefProcTab = "=proctab";
proctab = uservect[1];
}
if (proctab == NULL || proctab[0] == 0)
{
/* no proctab in users file */
concat(DefProcTab, VERSION, buf);
proctab = buf;
}
}
else
{
/* proctab specified; check permissions */
if ((Status & (proctab[0] == '=' ? U_EPROCTAB : U_APROCTAB)) == 0)
{
printf("You may not specify this process table\n");
if (CallSysmod)
goto sysusage;
else
goto usage;
}
}
/* expand process table name */
if (proctab[0] == '=')
{
smove(ztack(ztack(Pathname, "/files/"), &proctab[1]), buf);
proctab = buf;
}
/* open and read the process table */
if ((ProcFile = fopen(proctab, "r")) == NULL)
{
printf("Proctab %s: %s\n", proctab, sys_errlist[errno]);
if (CallSysmod)
goto sysusage;
else
goto usage;
}
/* build internal form of the process table */
if (yyparse())
No_exec++;
/* don't bother executing if we have found errors */
if (No_exec)
{
if (!CallSysmod)
{
usage:
/* cat .../files/usage */
cat(ztack(Pathname, "/files/usage"));
exit(1);
}
else
{
sysusage:
cat(ztack(Pathname, "/files/sysusage"));
exit(1);
}
}
fclose(ProcFile);
/* set locks on the database */
if (!CallSysmod) {
dolocks();
if ( Alockdes >= 0 )
{
sprintf(str,"-l%d",(flagval('E') >0 ?M_EXCL : M_SHARE));
doflag(str,-1);
sprintf(str2,"-W%d",Wait_action);
doflag(str2,-1);
close(Alockdes);
}
}
/* satisfy process table (never returns) */
satisfypt(CallSysmod);
}
/*
** Process rubouts (just exit)
*/
rubproc()
{
exit(2);
}
/*
** DOFLAG -- process flag
**
** Parameters:
** flag -- the flag (as a string)
** where -- where it is called from
** -1 -- internally inserted
** 0 -- on user command line
** 1 -- from users file
**
** Return:
** none
**
** Side effects:
** All flags are inserted on the end of the
** "Flaglist" vector for passing to the processes.
** The "No_exec" flag is set if the flag is bad or you
** are not authorized to use it.
**
** Requires:
** Status -- to get the status bits set for this user.
** syserr -- for the obvious
** printf -- to print errors
** atoi -- to check syntax on numerically-valued flags
**
** Defines:
** doflag()
** Flagok -- a list of legal flags and attributes (for
** local use only).
** Relmode -- a list of legal relation modes.
**
** Called by:
** main
**
** History:
** 11/6/79 (6.2/8) (eric) -- -u flag processing dropped,
** since initucode does it anyhow. -E flag
** removed (what is it?). F_USER code dropped.
** F_DROP is still around; we may need it some-
** day. Also, test of U_SUPER flag and/or DBA
** status was wrong.
** 7/5/78 (eric) -- NETFLAG added to list.
** 3/27/78 (eric) -- EQUELFLAG added to the list.
** 1/29/78 -- do_u_flag broken off by eric
** 1/4/78 -- written by eric
*/
struct flag
{
char flagname; /* name of the flag */
char flagstat; /* status of flag (see below) */
int flagsyntx; /* syntax code for this flag */
int flagperm; /* status bits needed to use this flag */
char *flagpt; /* default proctab to use with this flag */
};
/* status bits for flag */
# define F_PLOK 01 /* allow +x form */
# define F_PLD 02 /* defaults to +x */
# define F_DBA 04 /* must be the DBA to use */
# define F_DROP 010 /* don't save in Flaglist */
/* syntax codes */
# define F_ACCPT 1 /* always accept */
# define F_C_SPEC 3 /* -cN spec */
# define F_I_SPEC 4 /* -inN spec */
# define F_F_SPEC 5 /* -fnxN.M spec */
# define F_CHAR 6 /* single character */
# define F_MODE 7 /* a modify mode */
# define F_INTERNAL 8 /* internal flag, e.g., -q */
# define F_EQUEL 9 /* EQUEL flag */
struct flag Flagok[] =
{
'a', F_PLD|F_PLOK, F_ACCPT, 0, NULL,
'b', F_PLD|F_PLOK, F_ACCPT, U_DRCTUPDT, NULL,
'c', 0, F_C_SPEC, 0, NULL,
'd', F_PLD|F_PLOK, F_ACCPT, 0, NULL,
'f', 0, F_F_SPEC, 0, NULL,
'i', 0, F_I_SPEC, 0, NULL,
'l', F_PLOK, F_INTERNAL, 0, NULL,
'n', 0, F_MODE, 0, NULL,
'q', F_PLD|F_PLOK, F_INTERNAL, 0, NULL,
'r', 0, F_MODE, 0, NULL,
's', F_PLD|F_PLOK, F_ACCPT, 0, NULL,
'v', 0, F_CHAR, 0, NULL,
'w', F_PLOK|F_DROP, F_ACCPT, 0, NULL,
'D', 0, F_ACCPT, U_TRACE, NULL,
'L', F_PLOK, F_ACCPT, 0, NULL,
'M', 0, F_ACCPT, U_TRACE, NULL,
'O', 0, F_ACCPT, U_TRACE, NULL,
'P', 0, F_ACCPT, U_TRACE, NULL,
'Q', 0, F_ACCPT, U_TRACE, NULL,
'T', 0, F_ACCPT, U_TRACE, NULL,
'U', F_PLOK, F_ACCPT, U_UPSYSCAT, NULL,
'W', 0, F_INTERNAL, 0, NULL,
'Z', 0, F_ACCPT, U_TRACE, NULL,
EQUELFLAG, 0, F_EQUEL, 0, "=equel",
NETFLAG, 0, F_EQUEL, 0, "=slave",
'@', 0, F_EQUEL, 0, NULL,
'*', 0, F_ACCPT, 0, NULL,
0, 0, 0, 0, NULL,
};
/* list of valid retrieve into or index modes */
char *Relmode[] =
{
"isam",
"cisam",
"hash",
"chash",
"heap",
"cheap",
"heapsort",
"cheapsort",
NULL
};
doflag(flag, where)
char *flag;
int where;
{
register char *p;
register struct flag *f;
auto int intxx;
register char *ptr;
int i;
int j;
extern int Status;
p = flag;
/* check for valid flag format (begin with + or -) */
if (p[0] != '+' && p[0] != '-')
goto badflag;
/* check for flag in table */
for (f = Flagok; f->flagname != p[1]; f++)
{
if (f->flagname == 0)
goto badflag;
}
/* check for +x form allowed */
if (p[0] == '+' && (f->flagstat & F_PLOK) == 0)
goto badflag;
/* check for permission to use the flag */
if ((f->flagperm != 0 && (Status & f->flagperm) == 0 &&
(((f->flagstat & F_PLD) == 0) ? (p[0] == '+') : (p[0] == '-'))) ||
((f->flagstat & F_DBA) != 0 && (Status & U_SUPER) == 0 &&
!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ)))
{
printf("You are not authorized to use the %s flag\n", p);
No_exec++;
}
/* check syntax */
switch (f->flagsyntx)
{
case F_ACCPT:
break;
case F_C_SPEC:
if ((intxx = atoi(&p[2])) > MAXFIELD)
goto badflag;
break;
case F_I_SPEC:
if (p[2] != '1' && p[2] != '2' && p[2] != '4')
goto badflag;
if ((intxx = atoi(&p[3])) > MAXFIELD)
goto badflag;
break;
case F_F_SPEC:
if (p[2] != '4' && p[2] != '8')
goto badflag;
switch (p[3])
{
case 'e':
case 'E':
case 'f':
case 'F':
case 'g':
case 'G':
case 'n':
case 'N':
break;
default:
goto badflag;
}
ptr = &p[4];
while (*ptr != '.')
if (*ptr == 0)
goto badflag;
else
ptr++;
*ptr = 0;
if ((intxx = atoi(&p[4])) > MAXFIELD)
goto badflag;
*ptr++ = '.';
if ((intxx = atoi(ptr)) > MAXFIELD)
goto badflag;
break;
case F_CHAR:
if (p[2] == 0 || p[3] != 0)
goto badflag;
break;
case F_MODE:
for (i = 0; (ptr = Relmode[i]) != NULL; i++)
{
if (sequal(&p[2], ptr))
break;
}
if (ptr == NULL)
goto badflag;
break;
case F_INTERNAL:
if (where >= 0)
goto badflag;
break;
case F_EQUEL:
ptr = &p[2];
for (i = 0; i < 20; i++, ptr++)
{
if (*ptr == CLOSED)
continue;
if (*ptr < 0100 || *ptr >= 0100 + NOFILE)
break;
j = (i / 2) + '0';
if ((i & 01) == 0)
{
Pipe[j].pip_rfd = *ptr & 077;
}
else
{
Pipe[j].pip_wfd = *ptr & 077;
}
}
break;
default:
syserr("doflag: syntx %d", f->flagsyntx);
}
/* save flag */
if (Nopts >= MAXOPTNS)
{
printf("Too many options to INGRES\n");
exit(1);
}
if ((f->flagstat & F_DROP) == 0)
Opt[Nopts++] = p;
/* change to new process table as appropriate */
if (f->flagpt != NULL)
DefProcTab = f->flagpt;
return;
badflag:
printf("Bad flag format: %s\n", p);
No_exec++;
return;
}
/*
** DOLOCKS -- set database lock
**
** A lock is set on the database.
*/
dolocks()
{
db_lock(flagval('E') > 0 ? M_EXCL : M_SHARE);
}
/*
** FLAGVAL -- return value of flag
**
** Parameter:
** flag -- the name of the flag
**
** Return:
** -1 -- flag is de-asserted (-x)
** 0 -- flag is not specified
** 1 -- flag is asserted (+x)
**
** Requires:
** Opt -- to scan the flags
**
** Defines:
** flagval
**
** Called by:
** buildint
** dolocks
**
** History:
** 3/27/78 (eric) -- changed to handle EQUEL flag
** normally.
** 1/4/78 -- written by eric
*/
flagval(flag)
char flag;
{
register char f;
register char **p;
register char *o;
f = flag;
/* start scanning option list */
for (p = Opt; (o = *p) != 0; p++)
{
if (o[1] == f)
if (o[0] == '+')
return (1);
else
return (-1);
}
return (0);
}
/*
** SATISFYPT -- satisfy the process table
**
** Well folks, now that you've read this far, this is it!!! I
** mean, this one really does it!!! It takes the internal form
** built by the parser and creates pipes as necessary, forks, and
** execs the INGRES processes. Isn't that neat?
**
** Parameters:
** none
**
** Returns:
** never
**
** Requires:
** Proctab -- the internal form
** ingexec -- to actually exec the process
** pipe -- to create the pipe
** syserr -- for the obvious
** fillpipe -- to extend a newly opened pipe through all
** further references to it.
** checkpipes -- to see if a given pipe will ever be
** referenced again.
** fork -- to create a new process
**
** Defines:
** satisfypt
**
** Called by:
** main
**
** History:
** 3/14/80 (eric) -- changed for version 7.0.
** 7/24/78 (eric) -- Actual file descriptors stored in
** 'prpipes' are changed to have the 0100 bit
** set internally (as well as externally), so
** fd 0 will work correctly.
** 1/4/78 -- written by eric
*/
satisfypt(callsysmod)
int callsysmod;
{
register struct proc *pr;
register proc_t *pp;
register int i;
int procno;
register int pip;
/* scan the process table */
for (procno = CM_MAXPROC - 1; procno >= 0; procno--)
{
pr = &ProcTab[procno];
if (pr->prpath[0] == '\0')
continue;
/* scan pipe vector, creating new pipes as needed */
pipeopen(pr->prmpipe, TRUE);
pipeopen(pr->prcm.cm_input, FALSE);
pipeopen(pr->prcm.cm_rinput, FALSE);
for (i = 0; i < CM_MAXPROC; i++)
{
pp = &pr->prcm.cm_proc[i];
pipeopen(pp->pr_file, TRUE);
pipeopen(pp->pr_ninput, FALSE);
}
/* substitute real file descriptors throughout */
pipexlat(&pr->prmpipe, TRUE);
pipexlat(&pr->prcm.cm_input, FALSE);
pipexlat(&pr->prcm.cm_rinput, FALSE);
for (i = 0; i < CM_MAXPROC; i++)
{
pp = &pr->prcm.cm_proc[i];
pipexlat(&pp->pr_file, TRUE);
pipexlat(&pp->pr_ninput, FALSE);
}
/* fork if necessary */
if (--NumProcs <= 0 || (i = fork()) == 0 )
{
/* child!! */
ingexec(procno);
}
/* parent */
if (i < 0)
syserr("satisfypt: fork");
/* scan pipes. close all not used in the future */
for (i = 0; i < 128; i++)
{
if (i == CLOSED)
continue;
if (Pipe[i].pip_rcnt <= 0 && Pipe[i].pip_rfd >= 0)
{
if (close(Pipe[i].pip_rfd) < 0)
syserr("satisfypt: close-r(%d)", Pipe[i].pip_rfd);
Pipe[i].pip_rfd = -1;
}
if (Pipe[i].pip_wcnt <= 0 && Pipe[i].pip_wfd >= 0)
{
if (close(Pipe[i].pip_wfd) < 0)
syserr("satisfypt: close-w(%d)", Pipe[i].pip_wfd);
Pipe[i].pip_wfd = -1;
}
}
}
syserr("satisfypt: fell out");
}
/*
** SYSFLAG -- process flags for sysmod
**
** Parameters:
** flag -- the flag (as a string)
** may be one of: -s, -S, -T?
**
** Return:
** none
**
** Side effects:
** All flags are inserted on the end of the
** "Flaglist" vector for passing to the processes.
** The "No_exec" flag is set if the flag is bad or you
** are not authorized to use it.
**
** Called by:
** main
**
*/
sysflag(flag)
char *flag;
{
register char *p;
p = flag;
if (p[0] != '-')
goto sysbadflag;
switch (p[1])
{
case 's':
if ((Status & U_SUPER) == 0)
{
printf("Only INGRES can use the -s flag\n");
No_exec++;
return;
}
bmove(Admin.adhdr.adowner, Usercode, UCODE_SZ);
return(0);
break;
case 'R':
case 'S':
break;
default:
goto sysbadflag;
}
if (!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ))
{
printf("You are not the dba for %s\n", Database);
No_exec++;
return;
}
/* save flag */
if (Nopts >= SYSMAXOPTNS)
{
printf("Too many options to SYSMOD\n");
exit(1);
}
Opt[Nopts++] = p;
return(0);
sysbadflag:
printf("Sysmod: bad flag format: %s \n", p);
No_exec++;
return;
}
/*
** PIPEOPEN -- open pipe if necessary.
*/
pipeopen(pipid, rw)
char pipid;
int rw;
{
register struct pipeinfo *pi;
int pipex[2];
if (pipid == '\0')
return;
pi = &Pipe[pipid];
if ((rw ? pi->pip_wfd : pi->pip_rfd) >= 0)
return;
if (pi->pip_rfd >= 0 || pi->pip_wfd >= 0)
syserr("pipeopen %o %d: rfd=%d, wfd=%d", pipid, rw, pi->pip_rfd, pi->pip_wfd);
if (pipid == CLOSED)
pi->pip_rfd = pi->pip_wfd = CLOSED;
else
{
if (pipe(pipex) < 0)
syserr("pipeopen: pipe");
pi->pip_rfd = pipex[0];
pi->pip_wfd = pipex[1];
}
}
/*
** CHECKPIPES -- check for pipe referenced in the future
**
** Parameters:
** proc -- point in the process table to start looking
** from.
** fd -- the file descriptor to look for.
**
** Return:
** zero -- it will be referenced in the future.
** one -- it is never again referenced.
**
** Requires:
** nothing
**
** Defines:
** checkpipes
**
** Called by:
** satisfypt
**
** History:
** 7/24/78 (eric) -- 0100 bit on file descriptors handled.
** 1/4/78 -- written by eric
*/
checkpipes(proc, fd)
struct proc *proc;
register int fd;
{
register struct proc *pr;
register proc_t *pp;
register int i;
for (pr = proc; pr < &ProcTab[CM_MAXPROC]; pr++)
{
if (pr->prpath[0] == '\0')
continue;
for (i = 0; i < CM_MAXPROC; i++)
{
pp = &pr->prcm.cm_proc[i];
if (pp->pr_file == fd || pp->pr_ninput == fd)
return (0);
}
}
return (1);
}
/*
** INGEXEC -- execute INGRES process
**
** This routine handles all the setup of the argument vector
** and then executes a process.
**
** Parameters:
** process -- a pointer to the process table entry which
** describes this process.
**
** Returns:
** never
**
** Side Effects:
** never returns, but starts up a new overlay. Notice
** that it does NOT fork.
**
** Requires:
** none
**
** Called By:
** satisfypt
**
** Trace Flags:
** none
**
** Diagnostics:
** none
**
** Syserrs:
** chdir %s -- could not change directory into the data-
** base.
** creat %s -- could not create the redirected standard
** output file.
** %s not executable -- could not execute the process.
**
** History:
** 8/9/78 (eric) -- changed "prparam" to be a colon-
** separated list of parameters (so the number
** is variable); also, moved parameter expansion
** into this routine from buildint() so that
** the colons in the dbu part of the proctab
** would not confuse things.
** 7/24/78 (eric) -- changed the technique of closing
** files 0 & 2 so that they will never be closed
** (even if requested in the status field)
** if they are mentioned in the pipe vector.
** Also, some fiddling is done to handle the
** 0100 bit on file descriptors correctly.
*/
ingexec(procno)
int procno;
{
char *vect[30];
register char **v;
char **opt;
int i;
register struct proc *pr;
register proc_t *pp;
register char *p;
int outfd;
char closeit[NOFILE];
char fdbuf[3];
v = vect;
pr = &ProcTab[procno];
*v++ = pr->prpath;
fdbuf[0] = pr->prcm.cm_rinput | 0100;
fdbuf[1] = pr->prtflag;
fdbuf[2] = '\0';
*v++ = fdbuf;
*v++ = Fileset;
*v++ = Usercode;
*v++ = Database;
*v++ = Pathname;
/* insert flag parameters */
for (opt = Opt; *opt; opt++)
*v++ = *opt;
*v = 0;
/* set up 'closeit' to tell which pipes to close */
for (i = 0; i < NOFILE; i++)
closeit[i] = TRUE;
closeit[pr->prmpipe & 077] = FALSE;
closeit[pr->prcm.cm_input & 077] = FALSE;
closeit[pr->prcm.cm_rinput & 077] = FALSE;
for (i = 0; i < CM_MAXPROC; i++)
{
pp = &pr->prcm.cm_proc[i];
if (pp->pr_ninput != CLOSED)
closeit[pp->pr_ninput & 077] = FALSE;
if (pp->pr_file != CLOSED)
closeit[pp->pr_file & 077] = FALSE;
}
closeit[1] = FALSE;
if ((pr->prstat & PR_CLSSIN) == 0)
closeit[0] = FALSE;
if ((pr->prstat & PR_CLSDOUT) == 0)
closeit[2] = FALSE;
/* close extra pipes (those not used by this process) */
for (i = 0; i < NOFILE; i++)
{
if (closeit[i])
close(i);
}
/* change to the correct directory */
if ((pr->prstat & PR_NOCHDIR) == 0)
{
if (chdir(Dbpath))
syserr("ingexec: chdir %s", Dbpath);
}
/* change to normal userid/groupid if a non-dangerous process */
if ((pr->prstat & PR_REALUID) != 0)
{
setuid(getuid());
# ifndef xB_UNIX
setgid(getgid());
# endif
}
# ifdef LEAVEOUT
/* change standard output if specified in proctab */
p = pr->prstdout;
if (*p != 0)
{
/* chew up fd 0 (just in case) */
outfd = dup(1);
close(1);
if (creat(p, 0666) != 1)
{
/* restore standard output and print error */
close(1);
dup(outfd); /* better go into slot 1 */
syserr("ingexec: creat %s", p);
}
close(outfd);
}
# endif LEAVEOUT
/*
** PLEASE NOTE THE TRICKERY USED HERE.
** In this code I depend on UNIX buffering pipes at least
** enough to handle one "CM" struct. If not, the following
** write will hang before the exec will call the process
** that will read it.
**
** The "correct" way to do this is to fork & have the
** parent write the CM struct. But how do I handle the
** last one (that does not fork)? I could also do an
** extra fork of a process to do the write. But some
** systems have a limit on processes, and besides, it
** seems like a lot of overhead for such a little thing.
**
** Perhaps I should encode the CM struct into argv
** instead & do it "right".
*/
/* output the control structure to the awaiting process... */
write(pr->prmpipe & 077, &pr->prcm, sizeof pr->prcm);
close(pr->prmpipe & 077);
/* give it the old college (or in this case, University) try */
execv(vect[0], vect);
syserr("\"%s\" not executable", vect[0]);
}
pipexlat(ppip, rw)
char *ppip;
int rw;
{
register struct pipeinfo *pi;
int cnt;
int fd;
if (*ppip == '\0' || *ppip == CLOSED)
return;
pi = &Pipe[*ppip];
if (rw)
{
cnt = --(pi->pip_wcnt);
fd = pi->pip_wfd;
}
else
{
cnt = --(pi->pip_rcnt);
fd = pi->pip_rfd;
}
if (cnt < 0)
syserr("pipexlat: cnt=%d: %o %d", cnt, *ppip, rw);
if (fd < 0 || fd > NOFILE)
syserr("pipexlat: fd=%d: %o %d", fd, *ppip, rw);
*ppip = fd;
}
/*
** YYLEX -- Return next token from proctab
**
** Parameters:
** none
**
** Returns:
** Next token
**
** Side Effects:
** Input from proctab
*/
# define BOLSTATE 0 /* beginning of line */
# define NORMSTATE 1 /* normal token */
# define EOFSTATE 2 /* end of file */
int LineNo; /* current line number */
yylex()
{
static int state;
static char *ptp;
auto int ix;
static char line[MAXLINE];
register int c;
register char *p;
switch (state)
{
case EOFSTATE:
return (0);
case BOLSTATE:
ptp = line;
for (;;)
{
LineNo++;
c = getc(ProcFile);
if (c < 0)
{
state = EOFSTATE;
return (0);
}
switch (c)
{
case '*':
case '#':
case '\n':
while (c != '\n' && (c = getc(ProcFile)) > 0)
continue;
break;
case ':':
while (c != '\n' && (c = getc(ProcFile)) > 0)
putchar(c);
break;
default:
/* regular line, return header */
state = NORMSTATE;
return (c);
}
}
case NORMSTATE:
yylval.yystr = ptp;
while ((c = getc(ProcFile)) != ':' && c != '\n' && c > 0)
{
*ptp++ = c;
if (c == '$')
{
c = getc(ProcFile);
if (c < 'A' || c > 'Z')
*ptp++ = c;
else
{
ptp--;
for (p = Macro[c - 'A']; (*ptp++ = *p++) != '\0'; )
continue;
ptp--;
}
}
}
/* compute next state */
if (c != ':')
state = BOLSTATE;
*ptp++ = '\0';
ix = atoi(yylval.yystr);
if ( *yylval.yystr <= '9' && *yylval.yystr >= '0')
{
if (yylval.yystr[0] == '0')
ix = oatoi(yylval.yystr);
yylval.yyint = ix;
return (INT);
}
else
return (STR);
default:
syserr("yylex: state %d", state);
}
}
yyerror(s)
char *s;
{
syserr("Line %d: Yacc error: %s", LineNo, s);
}
/*VARARGS1*/
usrerr(f, p1, p2, p3)
char *f;
{
printf("Line %d: ", LineNo);
printf(f, p1, p2, p3);
printf("\n");
}