![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ingres.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / support|
Return to ingres.y CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / support |
1.1 root 1: %{
2:
3: # include <stdio.h>
4: # include <ctype.h>
5: # include <ingres.h>
6: # include <aux.h>
7: # include <version.h>
8: # include <access.h>
9: # include <lock.h>
10: # include <opsys.h>
11: # include <ctlmod.h>
12: # include <sccs.h>
13:
14:
15: /*
16: ** INGRES -- INGRES startup
17: **
18: ** This program starts up the entire system.
19: **
20: ** Parameters:
21: ** 1 -- database name
22: ** 2 -- optional process table name
23: ** x -- flags of the form +x or -x may be freely inter-
24: ** sperced in the argument list.
25: **
26: ** Return:
27: ** none if successful
28: ** 1 -- user error (no database, etc)
29: ** -1 -- system error
30: **
31: ** Flags:
32: ** -&xxxx -- EQUEL flag: xxxx are file descriptors for the
33: ** status return pipe, the command write pipe, the
34: ** data return pipe, and the data transfer pipe
35: ** respectively.
36: ** -@xxxx -- xxxx is same as EQUEL flag, but no flags
37: ** are set.
38: ** -*?? -- Masterid flag. Gives the siteid of the master
39: ** site in a distributed ingres. (Used in dist.
40: ** ingres' initproc() function.)
41: ** -|xxxx -- Network flag. This flag is just passed to
42: ** the other processes, to be processed by the
43: ** DBU's.
44: ** -uusername -- set effective user to be username. You
45: ** must be INGRES or the DBA for the database to
46: ** use this option.
47: ** -cN -- set minimum character field output width to be
48: ** N, default 6. This is the fewest number of
49: ** characters which may be output in any "c" type
50: ** field.
51: ** -inN -- integer output width. this is the width of
52: ** an integer field. The small "n" is the size
53: ** of the internal field ("1", "2", or "4") and
54: ** N is the width of the field for that flag.
55: ** The defaults are -i16, -i26, and -i413.
56: ** -fnxN.M -- floating point output width and precision.
57: ** Small "n" is the internal width in bytes ("4"
58: ** or "8"), x is the format (f, F, g, G, e, E,
59: ** n, or N), N is the field width, and M is the
60: ** precision (number of digits after the decimal
61: ** point). The formats are:
62: ** "f" or "F": FORTRAN-style F format: digits,
63: ** decimal point, digits, no exponent.
64: ** "e" or "E": FORTRAN-style E format: digits,
65: ** decimal point, digits, letter "e" (or
66: ** "E", depending on "x" in the param-
67: ** eter), and an exponent. The scaling
68: ** factor is always one, that is, there
69: ** is always one digit before the decimal
70: ** point.
71: ** "g" or "G": F format if it will fit in the
72: ** field, otherwise E format. Space is
73: ** always left at the right of the field
74: ** for the exponent, so that decimal
75: ** points will align.
76: ** "n" or "N": like G, except that space is not
77: ** left for the decimal point in F style
78: ** format (useful if you expect everything
79: ** to fit, but you're not sure).
80: ** The default is -fn10.3.
81: ** -vx -- set vertical seperator for print operations
82: ** and retrieves to the terminal to be "x". The
83: ** default is vertical bar ("|").
84: ** +w -- database wait state. If set ("+w"), you will
85: ** wait until the database is not busy. If clear,
86: ** you will be informed if the database is busy.
87: ** If not specified, the same operations take
88: ** place depending on whether or not you are
89: ** running in background (determined by whether
90: ** or not your input is a teletype). If in fore-
91: ** ground, you are informed; if in background,
92: ** you wait.
93: ** -M -- monitor trace flag
94: ** -P -- parser trace flag
95: ** -O -- ovqp trace flag
96: ** -Q -- qrymod trace flag
97: ** -D -- decomp trace flag
98: ** -Z -- dbu trace flag. These flags require the 020 bit
99: ** in the status field of the users file to be
100: ** set. The syntax is loose and is described
101: ** elsewhere. Briefly, "-Z" sets all flags except
102: ** the last 20, "-Z4" sets flag 4, and "-Z5/7"
103: ** sets all flags from 5 through 7.
104: ** +L -- enable/disable upper to lower case mapping in the
105: ** parser. Used for debugging.
106: ** -rmode -- retrieve into mode
107: ** -nmode -- index mode. These flags give the default
108: ** modify mode for retrieve into and index. They
109: ** default to cheapsort and isam. "Mode" can be
110: ** any mode to modify except "truncated".
111: ** +a -- enable/disable autoclear function in monitor.
112: ** Default on.
113: ** +b -- enable/disable batch update. Default on.
114: ** The 02 bit is needed to clear this flag.
115: ** +d -- enable/disable printing of the dayfile. Default
116: ** on.
117: ** +s -- enable/disable printing of almost everything from
118: ** the monitor.
119: ** +U -- enable/disable direct update of system catalogs.
120: ** Default off. The 04 bit is needed to set this
121: ** option.
122: **
123: ** Files:
124: ** .../files/usage -- to print a "usage: ..." message.
125: ** .../data/base/<database>/admin -- to determine
126: ** existance and some info about <database>.
127: ** .../files/dayfile<VERSION> -- dayfile (printed by
128: ** monitor).
129: ** .../files/users -- file with UNIX uid -> INGRES code
130: ** mapping, plus a pile of other information about
131: ** the user.
132: ** .../files/proctab<VERSION> -- default process table
133: **
134: **
135: ** Note:
136: ** this is also the startup program for sysmod.
137: ** different flags are expected and the default process table
138: ** is different from that of ingres.
139: **
140: */
141:
142: SCCSID(@(#)ingres.y 8.4 12/18/85)
143:
144: # define MAXOPTNS 10 /* maximum number of options you can specify */
145: # define SYSMAXOPTNS 6 /* maximum number of options to sysmod */
146: # define MAXPROCS 10 /* maximum number of processes in the system */
147: # define EQUELFLAG '&'
148: # define NETFLAG '|' /* network slave flag */
149: # define CLOSED '?'
150:
151: char Fileset[10];
152: char *Database;
153: extern char *Dbpath; /* defined in initucode */
154: struct admin Admin; /* set in initucode */
155: struct lockreq Lock;
156: FILE *ProcFile; /* fildes for the process table */
157: char *DefProcTab = NULL; /* default process table name */
158: char *Opt[MAXOPTNS + 1];
159: int Nopts;
160: int No_exec; /* if set, don't execute */
161: int NumProcs; /* number of processes this system */
162:
163:
164: /*
165: ** Internal form of process descriptions.
166: */
167:
168: struct proc
169: {
170: short prstat; /* status bits, see below */
171: char prmpipe; /* initial pipe to this process */
172: char prtflag; /* trace flag for CM this proc */
173: char prpath[50]; /* pathname of this process */
174: struct _cm_t prcm; /* cm info passed to this proc */
175: };
176:
177: /* bits for prstat */
178: # define PR_REALUID 0001 /* run as the user, not INGRES */
179: # define PR_NOCHDIR 0002 /* don't chdir into database */
180: # define PR_CLSSIN 0004 /* close standard input */
181: # define PR_CLSDOUT 0010 /* close diagnostic output */
182:
183: struct proc ProcTab[CM_MAXPROC];
184:
185:
186: /*
187: ** Open pipe info.
188: */
189:
190: struct pipeinfo
191: {
192: char pip_rfd; /* read file descriptor */
193: char pip_wfd; /* write file descriptor */
194: short pip_rcnt; /* read reference count */
195: short pip_wcnt; /* write reference count */
196: };
197:
198: struct pipeinfo Pipe[128];
199:
200:
201: /*
202: ** Macro definitions
203: */
204:
205: char Macro[26][80];
206:
207:
208: /* system error messages, etc. */
209: extern int sys_nerr;
210: extern char *sys_errlist[];
211: extern int errno;
212:
213: /* globals used by the grammar. */
214: struct proc *Proc;
215: state_t *StateP;
216: proc_t *ProcP;
217: int ProcNo;
218: int RemStat;
219:
220:
221: %}
222:
223: %union
224: {
225: int yyint; /* integer */
226: char *yystr; /* string */
227: char yypip; /* pipe id */
228: char yychar; /* single character */
229: }
230:
231: %token <yyint> INT
232: %token <yystr> STR
233:
234: %type <yyint> procno stateno funcno
235: %type <yyint> flags
236: %type <yystr> pathname printname
237: %type <yypip> pipe_id
238: %type <yychar>macro_id tflag
239:
240: %%
241:
242: proctab: spec_list
243: ;
244:
245: spec_list: spec
246: | spec_list spec
247: ;
248:
249: spec: proc_line states
250: | macro_defn
251: ;
252:
253: /*
254: ** Lines beginning with "P" introduce new processes.
255: **
256: ** procno is the number of the process being defined.
257: ** pathname is the pathname of the executable object
258: ** of this module.
259: ** printname is the name to be used as "Procname" in
260: ** this module for activities unconnected with
261: ** particular modules.
262: ** pipe_id is the pipe to use as the normal input for
263: ** this process. It must be listed as a pipe
264: ** in at least one of the constituent state
265: ** definitions.
266: ** flags are flags associated with this process. They
267: ** are not actually passed to the process, but
268: ** are used internally. See the #defines after
269: ** /^struct proc/.
270: */
271:
272: proc_line: 'P' procno pathname printname pipe_id flags tflag
273: {
274: NumProcs++;
275: Proc = &ProcTab[$2];
276: smove($3, Proc->prpath);
277: Proc->prmpipe = Proc->prcm.cm_input = Proc->prcm.cm_rinput
278: = Proc->prcm.cm_proc[$2].pr_ninput = $5;
279: smove($4, Proc->prcm.cm_myname);
280: Proc->prcm.cm_myproc = $2;
281: Proc->prstat = $6;
282: Proc->prtflag = $7;
283: Pipe[$5].pip_rcnt += 3;
284: Pipe[$5].pip_wcnt++;
285: }
286: ;
287:
288: states: state_line
289: | states state_line
290: ;
291:
292: state_line: local_line
293: | remote_line
294: ;
295:
296: local_line: 'L' stateno flags funcno stateno
297: {
298: StateP = &Proc->prcm.cm_state[$2];
299: StateP->st_type = ST_LOCAL;
300: StateP->st_stat = $3;
301: StateP->st_v.st_loc.st_funcno = $4;
302: StateP->st_v.st_loc.st_next = $5;
303: }
304: ;
305:
306: remote_line: remote_header stateno_list
307: ;
308:
309: remote_header: 'R' procno flags pipe_id pipe_id flags
310: {
311: ProcNo = $2;
312: ProcP = &Proc->prcm.cm_proc[ProcNo];
313: RemStat = $3;
314: ProcP->pr_file = $4;
315: ProcP->pr_ninput = $5;
316: ProcP->pr_stat = $6;
317: Pipe[$4].pip_wcnt++;
318: Pipe[$5].pip_rcnt++;
319: }
320: ;
321:
322: stateno_list: /* empty */
323: | stateno_list remote_stateno
324: ;
325:
326: remote_stateno: stateno
327: {
328: StateP = &Proc->prcm.cm_state[$1];
329: StateP->st_type = ST_REMOT;
330: StateP->st_stat = RemStat;
331: StateP->st_v.st_rem.st_proc = ProcNo;
332: }
333: ;
334:
335: /*
336: ** Macro definitions.
337: */
338:
339: macro_defn: 'D' macro_id STR
340: {
341: smove($3, Macro[$2 - 'A']);
342: }
343:
344: /*
345: ** Productions for things that perhaps ought to be in the scanner.
346: */
347:
348: procno: INT
349: {
350: if ($1 < 0 || $1 >= CM_MAXPROC)
351: {
352: usrerr("Illegal proc number %d", $1);
353: YYERROR;
354: }
355: }
356: ;
357:
358: stateno: INT
359: {
360: if ($1 < 0 || $1 >= CM_MAXST)
361: {
362: usrerr("Illegal state number %d", $1);
363: YYERROR;
364: }
365: }
366: ;
367:
368: funcno: INT
369: {
370: if ($1 < 0)
371: {
372: usrerr("Illegal funcno %d", $1);
373: YYERROR;
374: }
375: }
376: ;
377:
378: pathname: STR
379: ;
380:
381: printname: STR
382: ;
383:
384: pipe_id: STR
385: {
386: if ((islower($1[0]) || $1[0] == CLOSED) && $1[1] == '\0')
387: $$ = $1[0];
388: else if ($1[0] == '|' && isdigit($1[1]) && $1[2] == '\0')
389: $$ = $1[1];
390: else
391: {
392: usrerr("Invalid pipe id \"%s\"", $1);
393: YYERROR;
394: }
395: }
396: ;
397:
398: tflag: STR
399: {
400: if ($1[1] != '\0')
401: {
402: usrerr("Invalid trace flag \"%s\"", $1);
403: YYERROR;
404: }
405: else
406: $$ = $1[0];
407: }
408: ;
409:
410: flags: INT
411: ;
412:
413: macro_id: STR
414: {
415: if ($1[0] < 'A' || $1[0] > 'Z' || $1[1] != '\0')
416: {
417: usrerr("Invalid macro name \"%s\"", $1);
418: YYERROR;
419: }
420: else
421: $$ = $1[0];
422: }
423:
424: %%
425:
426: main(argc, argv)
427: int argc;
428: char **argv;
429: {
430: register int i;
431: register int j;
432: extern char *Proc_name;
433: int fd;
434: extern int Status;
435: char *proctab;
436: register char *p;
437: char *ptr;
438: extern char *Flagvect[]; /* defined in initucode.c */
439: extern char *Parmvect[]; /* ditto */
440: char *uservect[4];
441: char buf[MAXLINE+1];
442: char str[MAXLINE+1]; /* a string to put the Alockdes value into */
443: char str2[MAXLINE+1];
444: extern int Wait_action; /* action on lock driver */
445: int CallSysmod = FALSE;
446: struct proc *pr;
447: int len;
448: char *sysptr;
449:
450: /*
451: ** sysmod is linked to ingres.
452: ** check whether ingres or sysmod was called.
453: */
454: len = strlen(argv[0]);
455: sysptr = &argv[0][len - 6];
456: if (sequal( sysptr, "sysmod"))
457: {
458: CallSysmod = TRUE;
459: Proc_name = "SYSMOD";
460: }
461: else
462: Proc_name = "INGRES";
463:
464:
465: itoa(getpid(), Fileset);
466: proctab = NULL;
467: Database = NULL;
468:
469: /*
470: ** Initialize everything, like Flagvect, Parmvect, Usercode,
471: ** etc.
472: */
473:
474: for (i = 0; i < 128; i++)
475: Pipe[i].pip_rfd = Pipe[i].pip_wfd = -1;
476:
477: i = initucode(argc, argv, TRUE, uservect, CallSysmod?M_EXCL:-1);
478: switch (i)
479: {
480: case 0: /* ok */
481: case INDIRECT:
482: break;
483:
484: case NODB: /* database does not exist */
485: case INDNODB:
486: printf("Database %s does not exist\n", Parmvect[0]);
487: if (CallSysmod)
488: goto sysusage;
489: else
490: goto usage;
491:
492: case NOACCESS: /* you are not authorized */
493: printf("You may not access database %s\n", Database);
494: if (CallSysmod)
495: goto sysusage;
496: else
497: goto usage;
498:
499: case INVALIDUSR: /* not a valid user */
500: printf("You are not a valid INGRES user\n");
501: if (CallSysmod)
502: goto sysusage;
503: else
504: goto usage;
505:
506: case NODBNAME: /* no database name specified */
507: printf("No database name specified\n");
508: if (CallSysmod)
509: goto sysusage;
510: else
511: goto usage;
512:
513: default:
514: syserr("initucode %d", i);
515: }
516:
517: /*
518: ** Extract database name and process table name from
519: ** parameter vector.
520: ** Initialize the $P macro.
521: */
522:
523: Database = Parmvect[0];
524: proctab = Parmvect[1];
525: smove(Pathname, Macro['P' - 'A']);
526:
527: if (!CallSysmod)
528: {
529: /* scan flags in users file */
530: for (p = uservect[0]; *p != '\0'; p++)
531: {
532: /* skip initial blanks and tabs */
533: if (*p == ' ' || *p == '\t')
534: continue;
535: ptr = p;
536:
537: /* find end of flag and null-terminate it */
538: while (*p != '\0' && *p != ' ' && *p != '\t')
539: p++;
540: i = *p;
541: *p = '\0';
542:
543: /* process the flag */
544: doflag(ptr, 1);
545: if (i == '\0')
546: break;
547: }
548:
549: /* scan flags on command line */
550: for (i = 0; (p = Flagvect[i]) != NULL; i++)
551: doflag(p, 0);
552:
553: /* check for query modification specified for this database */
554: if ((Admin.adhdr.adflags & A_QRYMOD) == 0)
555: doflag("-q", -1);
556: }
557: /* special routine for handling sysmod flags */
558: else
559: {
560: DefProcTab = "=sysmod";
561: if ( Flagvect[0] == NULL)
562: {
563: if (!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ))
564: {
565: printf("You are not the dba for %s\n", Database);
566: No_exec++;
567: }
568: }
569: for (i = 0; (p = Flagvect[i]) != NULL; i++)
570: sysflag(p);
571: }
572:
573:
574: /* close any extraneous files, being careful not to close anything we need */
575: for (i = 3; i < NOFILE; i++)
576: {
577: for (j = '0'; j <= '9'; j++)
578: {
579: if (Pipe[j].pip_wfd == i || Pipe[j].pip_rfd == i)
580: break;
581: }
582: if (j > '9')
583: close(i);
584: }
585:
586: /* determine process table */
587: if (proctab == NULL)
588: {
589: /* use default proctab */
590: if (DefProcTab == NULL)
591: {
592: if (argv[0][length(argv[0]) - 1] == 'x')
593: DefProcTab = "=procx";
594: else
595: DefProcTab = "=proctab";
596: proctab = uservect[1];
597: }
598: if (proctab == NULL || proctab[0] == 0)
599: {
600: /* no proctab in users file */
601: concat(DefProcTab, VERSION, buf);
602: proctab = buf;
603: }
604: }
605: else
606: {
607: /* proctab specified; check permissions */
608: if ((Status & (proctab[0] == '=' ? U_EPROCTAB : U_APROCTAB)) == 0)
609: {
610: printf("You may not specify this process table\n");
611: if (CallSysmod)
612: goto sysusage;
613: else
614: goto usage;
615: }
616: }
617:
618: /* expand process table name */
619: if (proctab[0] == '=')
620: {
621: smove(ztack(ztack(Pathname, "/files/"), &proctab[1]), buf);
622: proctab = buf;
623: }
624:
625: /* open and read the process table */
626: if ((ProcFile = fopen(proctab, "r")) == NULL)
627: {
628: printf("Proctab %s: %s\n", proctab, sys_errlist[errno]);
629: if (CallSysmod)
630: goto sysusage;
631: else
632: goto usage;
633: }
634:
635: /* build internal form of the process table */
636: if (yyparse())
637: No_exec++;
638:
639: /* don't bother executing if we have found errors */
640: if (No_exec)
641: {
642: if (!CallSysmod)
643: {
644: usage:
645: /* cat .../files/usage */
646: cat(ztack(Pathname, "/files/usage"));
647: exit(1);
648: }
649: else
650: {
651: sysusage:
652: cat(ztack(Pathname, "/files/sysusage"));
653: exit(1);
654: }
655: }
656:
657: fclose(ProcFile);
658:
659: /* set locks on the database */
660: if (!CallSysmod) {
661: dolocks();
662: if ( Alockdes >= 0 )
663: {
664: sprintf(str,"-l%d",(flagval('E') >0 ?M_EXCL : M_SHARE));
665: doflag(str,-1);
666: sprintf(str2,"-W%d",Wait_action);
667: doflag(str2,-1);
668: close(Alockdes);
669: }
670: }
671:
672: /* satisfy process table (never returns) */
673: satisfypt(CallSysmod);
674: }
675:
676:
677:
678: /*
679: ** Process rubouts (just exit)
680: */
681:
682: rubproc()
683: {
684: exit(2);
685: }
686: /*
687: ** DOFLAG -- process flag
688: **
689: ** Parameters:
690: ** flag -- the flag (as a string)
691: ** where -- where it is called from
692: ** -1 -- internally inserted
693: ** 0 -- on user command line
694: ** 1 -- from users file
695: **
696: ** Return:
697: ** none
698: **
699: ** Side effects:
700: ** All flags are inserted on the end of the
701: ** "Flaglist" vector for passing to the processes.
702: ** The "No_exec" flag is set if the flag is bad or you
703: ** are not authorized to use it.
704: **
705: ** Requires:
706: ** Status -- to get the status bits set for this user.
707: ** syserr -- for the obvious
708: ** printf -- to print errors
709: ** atoi -- to check syntax on numerically-valued flags
710: **
711: ** Defines:
712: ** doflag()
713: ** Flagok -- a list of legal flags and attributes (for
714: ** local use only).
715: ** Relmode -- a list of legal relation modes.
716: **
717: ** Called by:
718: ** main
719: **
720: ** History:
721: ** 11/6/79 (6.2/8) (eric) -- -u flag processing dropped,
722: ** since initucode does it anyhow. -E flag
723: ** removed (what is it?). F_USER code dropped.
724: ** F_DROP is still around; we may need it some-
725: ** day. Also, test of U_SUPER flag and/or DBA
726: ** status was wrong.
727: ** 7/5/78 (eric) -- NETFLAG added to list.
728: ** 3/27/78 (eric) -- EQUELFLAG added to the list.
729: ** 1/29/78 -- do_u_flag broken off by eric
730: ** 1/4/78 -- written by eric
731: */
732:
733: struct flag
734: {
735: char flagname; /* name of the flag */
736: char flagstat; /* status of flag (see below) */
737: int flagsyntx; /* syntax code for this flag */
738: int flagperm; /* status bits needed to use this flag */
739: char *flagpt; /* default proctab to use with this flag */
740: };
741:
742: /* status bits for flag */
743: # define F_PLOK 01 /* allow +x form */
744: # define F_PLD 02 /* defaults to +x */
745: # define F_DBA 04 /* must be the DBA to use */
746: # define F_DROP 010 /* don't save in Flaglist */
747:
748: /* syntax codes */
749: # define F_ACCPT 1 /* always accept */
750: # define F_C_SPEC 3 /* -cN spec */
751: # define F_I_SPEC 4 /* -inN spec */
752: # define F_F_SPEC 5 /* -fnxN.M spec */
753: # define F_CHAR 6 /* single character */
754: # define F_MODE 7 /* a modify mode */
755: # define F_INTERNAL 8 /* internal flag, e.g., -q */
756: # define F_EQUEL 9 /* EQUEL flag */
757:
758: struct flag Flagok[] =
759: {
760: 'a', F_PLD|F_PLOK, F_ACCPT, 0, NULL,
761: 'b', F_PLD|F_PLOK, F_ACCPT, U_DRCTUPDT, NULL,
762: 'c', 0, F_C_SPEC, 0, NULL,
763: 'd', F_PLD|F_PLOK, F_ACCPT, 0, NULL,
764: 'f', 0, F_F_SPEC, 0, NULL,
765: 'i', 0, F_I_SPEC, 0, NULL,
766: 'l', F_PLOK, F_INTERNAL, 0, NULL,
767: 'n', 0, F_MODE, 0, NULL,
768: 'q', F_PLD|F_PLOK, F_INTERNAL, 0, NULL,
769: 'r', 0, F_MODE, 0, NULL,
770: 's', F_PLD|F_PLOK, F_ACCPT, 0, NULL,
771: 'v', 0, F_CHAR, 0, NULL,
772: 'w', F_PLOK|F_DROP, F_ACCPT, 0, NULL,
773: 'D', 0, F_ACCPT, U_TRACE, NULL,
774: 'L', F_PLOK, F_ACCPT, 0, NULL,
775: 'M', 0, F_ACCPT, U_TRACE, NULL,
776: 'O', 0, F_ACCPT, U_TRACE, NULL,
777: 'P', 0, F_ACCPT, U_TRACE, NULL,
778: 'Q', 0, F_ACCPT, U_TRACE, NULL,
779: 'T', 0, F_ACCPT, U_TRACE, NULL,
780: 'U', F_PLOK, F_ACCPT, U_UPSYSCAT, NULL,
781: 'W', 0, F_INTERNAL, 0, NULL,
782: 'Z', 0, F_ACCPT, U_TRACE, NULL,
783: EQUELFLAG, 0, F_EQUEL, 0, "=equel",
784: NETFLAG, 0, F_EQUEL, 0, "=slave",
785: '@', 0, F_EQUEL, 0, NULL,
786: '*', 0, F_ACCPT, 0, NULL,
787: 0, 0, 0, 0, NULL,
788: };
789:
790: /* list of valid retrieve into or index modes */
791: char *Relmode[] =
792: {
793: "isam",
794: "cisam",
795: "hash",
796: "chash",
797: "heap",
798: "cheap",
799: "heapsort",
800: "cheapsort",
801: NULL
802: };
803:
804:
805: doflag(flag, where)
806: char *flag;
807: int where;
808: {
809: register char *p;
810: register struct flag *f;
811: auto int intxx;
812: register char *ptr;
813: int i;
814: int j;
815: extern int Status;
816:
817: p = flag;
818:
819: /* check for valid flag format (begin with + or -) */
820: if (p[0] != '+' && p[0] != '-')
821: goto badflag;
822:
823: /* check for flag in table */
824: for (f = Flagok; f->flagname != p[1]; f++)
825: {
826: if (f->flagname == 0)
827: goto badflag;
828: }
829:
830: /* check for +x form allowed */
831: if (p[0] == '+' && (f->flagstat & F_PLOK) == 0)
832: goto badflag;
833:
834: /* check for permission to use the flag */
835: if ((f->flagperm != 0 && (Status & f->flagperm) == 0 &&
836: (((f->flagstat & F_PLD) == 0) ? (p[0] == '+') : (p[0] == '-'))) ||
837: ((f->flagstat & F_DBA) != 0 && (Status & U_SUPER) == 0 &&
838: !bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ)))
839: {
840: printf("You are not authorized to use the %s flag\n", p);
841: No_exec++;
842: }
843:
844: /* check syntax */
845: switch (f->flagsyntx)
846: {
847: case F_ACCPT:
848: break;
849:
850: case F_C_SPEC:
851: if ((intxx = atoi(&p[2])) > MAXFIELD)
852: goto badflag;
853: break;
854:
855: case F_I_SPEC:
856: if (p[2] != '1' && p[2] != '2' && p[2] != '4')
857: goto badflag;
858: if ((intxx = atoi(&p[3])) > MAXFIELD)
859: goto badflag;
860: break;
861:
862: case F_F_SPEC:
863: if (p[2] != '4' && p[2] != '8')
864: goto badflag;
865: switch (p[3])
866: {
867: case 'e':
868: case 'E':
869: case 'f':
870: case 'F':
871: case 'g':
872: case 'G':
873: case 'n':
874: case 'N':
875: break;
876:
877: default:
878: goto badflag;
879:
880: }
881: ptr = &p[4];
882: while (*ptr != '.')
883: if (*ptr == 0)
884: goto badflag;
885: else
886: ptr++;
887: *ptr = 0;
888: if ((intxx = atoi(&p[4])) > MAXFIELD)
889: goto badflag;
890: *ptr++ = '.';
891: if ((intxx = atoi(ptr)) > MAXFIELD)
892: goto badflag;
893: break;
894:
895: case F_CHAR:
896: if (p[2] == 0 || p[3] != 0)
897: goto badflag;
898: break;
899:
900: case F_MODE:
901: for (i = 0; (ptr = Relmode[i]) != NULL; i++)
902: {
903: if (sequal(&p[2], ptr))
904: break;
905: }
906: if (ptr == NULL)
907: goto badflag;
908: break;
909:
910: case F_INTERNAL:
911: if (where >= 0)
912: goto badflag;
913: break;
914:
915: case F_EQUEL:
916: ptr = &p[2];
917: for (i = 0; i < 20; i++, ptr++)
918: {
919: if (*ptr == CLOSED)
920: continue;
921: if (*ptr < 0100 || *ptr >= 0100 + NOFILE)
922: break;
923: j = (i / 2) + '0';
924: if ((i & 01) == 0)
925: {
926: Pipe[j].pip_rfd = *ptr & 077;
927: }
928: else
929: {
930: Pipe[j].pip_wfd = *ptr & 077;
931: }
932: }
933: break;
934:
935: default:
936: syserr("doflag: syntx %d", f->flagsyntx);
937:
938: }
939:
940: /* save flag */
941: if (Nopts >= MAXOPTNS)
942: {
943: printf("Too many options to INGRES\n");
944: exit(1);
945: }
946: if ((f->flagstat & F_DROP) == 0)
947: Opt[Nopts++] = p;
948:
949: /* change to new process table as appropriate */
950: if (f->flagpt != NULL)
951: DefProcTab = f->flagpt;
952:
953: return;
954:
955: badflag:
956: printf("Bad flag format: %s\n", p);
957: No_exec++;
958: return;
959: }
960: /*
961: ** DOLOCKS -- set database lock
962: **
963: ** A lock is set on the database.
964: */
965:
966: dolocks()
967: {
968: db_lock(flagval('E') > 0 ? M_EXCL : M_SHARE);
969: }
970: /*
971: ** FLAGVAL -- return value of flag
972: **
973: ** Parameter:
974: ** flag -- the name of the flag
975: **
976: ** Return:
977: ** -1 -- flag is de-asserted (-x)
978: ** 0 -- flag is not specified
979: ** 1 -- flag is asserted (+x)
980: **
981: ** Requires:
982: ** Opt -- to scan the flags
983: **
984: ** Defines:
985: ** flagval
986: **
987: ** Called by:
988: ** buildint
989: ** dolocks
990: **
991: ** History:
992: ** 3/27/78 (eric) -- changed to handle EQUEL flag
993: ** normally.
994: ** 1/4/78 -- written by eric
995: */
996:
997: flagval(flag)
998: char flag;
999: {
1000: register char f;
1001: register char **p;
1002: register char *o;
1003:
1004: f = flag;
1005:
1006: /* start scanning option list */
1007: for (p = Opt; (o = *p) != 0; p++)
1008: {
1009: if (o[1] == f)
1010: if (o[0] == '+')
1011: return (1);
1012: else
1013: return (-1);
1014: }
1015: return (0);
1016: }
1017: /*
1018: ** SATISFYPT -- satisfy the process table
1019: **
1020: ** Well folks, now that you've read this far, this is it!!! I
1021: ** mean, this one really does it!!! It takes the internal form
1022: ** built by the parser and creates pipes as necessary, forks, and
1023: ** execs the INGRES processes. Isn't that neat?
1024: **
1025: ** Parameters:
1026: ** none
1027: **
1028: ** Returns:
1029: ** never
1030: **
1031: ** Requires:
1032: ** Proctab -- the internal form
1033: ** ingexec -- to actually exec the process
1034: ** pipe -- to create the pipe
1035: ** syserr -- for the obvious
1036: ** fillpipe -- to extend a newly opened pipe through all
1037: ** further references to it.
1038: ** checkpipes -- to see if a given pipe will ever be
1039: ** referenced again.
1040: ** fork -- to create a new process
1041: **
1042: ** Defines:
1043: ** satisfypt
1044: **
1045: ** Called by:
1046: ** main
1047: **
1048: ** History:
1049: ** 3/14/80 (eric) -- changed for version 7.0.
1050: ** 7/24/78 (eric) -- Actual file descriptors stored in
1051: ** 'prpipes' are changed to have the 0100 bit
1052: ** set internally (as well as externally), so
1053: ** fd 0 will work correctly.
1054: ** 1/4/78 -- written by eric
1055: */
1056:
1057:
1058:
1059: satisfypt(callsysmod)
1060: int callsysmod;
1061: {
1062: register struct proc *pr;
1063: register proc_t *pp;
1064: register int i;
1065: int procno;
1066: register int pip;
1067:
1068: /* scan the process table */
1069: for (procno = CM_MAXPROC - 1; procno >= 0; procno--)
1070: {
1071:
1072: pr = &ProcTab[procno];
1073: if (pr->prpath[0] == '\0')
1074: continue;
1075:
1076: /* scan pipe vector, creating new pipes as needed */
1077: pipeopen(pr->prmpipe, TRUE);
1078: pipeopen(pr->prcm.cm_input, FALSE);
1079: pipeopen(pr->prcm.cm_rinput, FALSE);
1080: for (i = 0; i < CM_MAXPROC; i++)
1081: {
1082: pp = &pr->prcm.cm_proc[i];
1083: pipeopen(pp->pr_file, TRUE);
1084: pipeopen(pp->pr_ninput, FALSE);
1085: }
1086:
1087: /* substitute real file descriptors throughout */
1088: pipexlat(&pr->prmpipe, TRUE);
1089: pipexlat(&pr->prcm.cm_input, FALSE);
1090: pipexlat(&pr->prcm.cm_rinput, FALSE);
1091: for (i = 0; i < CM_MAXPROC; i++)
1092: {
1093: pp = &pr->prcm.cm_proc[i];
1094: pipexlat(&pp->pr_file, TRUE);
1095: pipexlat(&pp->pr_ninput, FALSE);
1096: }
1097:
1098: /* fork if necessary */
1099: if (--NumProcs <= 0 || (i = fork()) == 0 )
1100: {
1101: /* child!! */
1102: ingexec(procno);
1103: }
1104:
1105: /* parent */
1106: if (i < 0)
1107: syserr("satisfypt: fork");
1108:
1109: /* scan pipes. close all not used in the future */
1110: for (i = 0; i < 128; i++)
1111: {
1112: if (i == CLOSED)
1113: continue;
1114: if (Pipe[i].pip_rcnt <= 0 && Pipe[i].pip_rfd >= 0)
1115: {
1116: if (close(Pipe[i].pip_rfd) < 0)
1117: syserr("satisfypt: close-r(%d)", Pipe[i].pip_rfd);
1118: Pipe[i].pip_rfd = -1;
1119: }
1120: if (Pipe[i].pip_wcnt <= 0 && Pipe[i].pip_wfd >= 0)
1121: {
1122: if (close(Pipe[i].pip_wfd) < 0)
1123: syserr("satisfypt: close-w(%d)", Pipe[i].pip_wfd);
1124: Pipe[i].pip_wfd = -1;
1125: }
1126: }
1127: }
1128: syserr("satisfypt: fell out");
1129: }
1130:
1131:
1132: /*
1133: ** SYSFLAG -- process flags for sysmod
1134: **
1135: ** Parameters:
1136: ** flag -- the flag (as a string)
1137: ** may be one of: -s, -S, -T?
1138: **
1139: ** Return:
1140: ** none
1141: **
1142: ** Side effects:
1143: ** All flags are inserted on the end of the
1144: ** "Flaglist" vector for passing to the processes.
1145: ** The "No_exec" flag is set if the flag is bad or you
1146: ** are not authorized to use it.
1147: **
1148: ** Called by:
1149: ** main
1150: **
1151: */
1152:
1153: sysflag(flag)
1154: char *flag;
1155: {
1156: register char *p;
1157:
1158: p = flag;
1159:
1160: if (p[0] != '-')
1161: goto sysbadflag;
1162:
1163: switch (p[1])
1164: {
1165: case 's':
1166: if ((Status & U_SUPER) == 0)
1167: {
1168: printf("Only INGRES can use the -s flag\n");
1169: No_exec++;
1170: return;
1171: }
1172: bmove(Admin.adhdr.adowner, Usercode, UCODE_SZ);
1173: return(0);
1174: break;
1175:
1176: case 'R':
1177: case 'S':
1178: break;
1179:
1180: default:
1181: goto sysbadflag;
1182: }
1183:
1184: if (!bequal(Usercode, Admin.adhdr.adowner, UCODE_SZ))
1185: {
1186: printf("You are not the dba for %s\n", Database);
1187: No_exec++;
1188: return;
1189: }
1190:
1191:
1192: /* save flag */
1193: if (Nopts >= SYSMAXOPTNS)
1194: {
1195: printf("Too many options to SYSMOD\n");
1196: exit(1);
1197: }
1198:
1199: Opt[Nopts++] = p;
1200:
1201:
1202: return(0);
1203:
1204:
1205: sysbadflag:
1206: printf("Sysmod: bad flag format: %s \n", p);
1207: No_exec++;
1208: return;
1209:
1210: }
1211:
1212: /*
1213: ** PIPEOPEN -- open pipe if necessary.
1214: */
1215:
1216: pipeopen(pipid, rw)
1217: char pipid;
1218: int rw;
1219: {
1220: register struct pipeinfo *pi;
1221: int pipex[2];
1222:
1223: if (pipid == '\0')
1224: return;
1225:
1226: pi = &Pipe[pipid];
1227:
1228: if ((rw ? pi->pip_wfd : pi->pip_rfd) >= 0)
1229: return;
1230: if (pi->pip_rfd >= 0 || pi->pip_wfd >= 0)
1231: syserr("pipeopen %o %d: rfd=%d, wfd=%d", pipid, rw, pi->pip_rfd, pi->pip_wfd);
1232: if (pipid == CLOSED)
1233: pi->pip_rfd = pi->pip_wfd = CLOSED;
1234: else
1235: {
1236: if (pipe(pipex) < 0)
1237: syserr("pipeopen: pipe");
1238: pi->pip_rfd = pipex[0];
1239: pi->pip_wfd = pipex[1];
1240: }
1241: }
1242: /*
1243: ** CHECKPIPES -- check for pipe referenced in the future
1244: **
1245: ** Parameters:
1246: ** proc -- point in the process table to start looking
1247: ** from.
1248: ** fd -- the file descriptor to look for.
1249: **
1250: ** Return:
1251: ** zero -- it will be referenced in the future.
1252: ** one -- it is never again referenced.
1253: **
1254: ** Requires:
1255: ** nothing
1256: **
1257: ** Defines:
1258: ** checkpipes
1259: **
1260: ** Called by:
1261: ** satisfypt
1262: **
1263: ** History:
1264: ** 7/24/78 (eric) -- 0100 bit on file descriptors handled.
1265: ** 1/4/78 -- written by eric
1266: */
1267:
1268: checkpipes(proc, fd)
1269: struct proc *proc;
1270: register int fd;
1271: {
1272: register struct proc *pr;
1273: register proc_t *pp;
1274: register int i;
1275:
1276: for (pr = proc; pr < &ProcTab[CM_MAXPROC]; pr++)
1277: {
1278: if (pr->prpath[0] == '\0')
1279: continue;
1280: for (i = 0; i < CM_MAXPROC; i++)
1281: {
1282: pp = &pr->prcm.cm_proc[i];
1283: if (pp->pr_file == fd || pp->pr_ninput == fd)
1284: return (0);
1285: }
1286: }
1287: return (1);
1288: }
1289: /*
1290: ** INGEXEC -- execute INGRES process
1291: **
1292: ** This routine handles all the setup of the argument vector
1293: ** and then executes a process.
1294: **
1295: ** Parameters:
1296: ** process -- a pointer to the process table entry which
1297: ** describes this process.
1298: **
1299: ** Returns:
1300: ** never
1301: **
1302: ** Side Effects:
1303: ** never returns, but starts up a new overlay. Notice
1304: ** that it does NOT fork.
1305: **
1306: ** Requires:
1307: ** none
1308: **
1309: ** Called By:
1310: ** satisfypt
1311: **
1312: ** Trace Flags:
1313: ** none
1314: **
1315: ** Diagnostics:
1316: ** none
1317: **
1318: ** Syserrs:
1319: ** chdir %s -- could not change directory into the data-
1320: ** base.
1321: ** creat %s -- could not create the redirected standard
1322: ** output file.
1323: ** %s not executable -- could not execute the process.
1324: **
1325: ** History:
1326: ** 8/9/78 (eric) -- changed "prparam" to be a colon-
1327: ** separated list of parameters (so the number
1328: ** is variable); also, moved parameter expansion
1329: ** into this routine from buildint() so that
1330: ** the colons in the dbu part of the proctab
1331: ** would not confuse things.
1332: ** 7/24/78 (eric) -- changed the technique of closing
1333: ** files 0 & 2 so that they will never be closed
1334: ** (even if requested in the status field)
1335: ** if they are mentioned in the pipe vector.
1336: ** Also, some fiddling is done to handle the
1337: ** 0100 bit on file descriptors correctly.
1338: */
1339:
1340: ingexec(procno)
1341: int procno;
1342: {
1343: char *vect[30];
1344: register char **v;
1345: char **opt;
1346: int i;
1347: register struct proc *pr;
1348: register proc_t *pp;
1349: register char *p;
1350: int outfd;
1351: char closeit[NOFILE];
1352: char fdbuf[3];
1353:
1354: v = vect;
1355: pr = &ProcTab[procno];
1356:
1357: *v++ = pr->prpath;
1358: fdbuf[0] = pr->prcm.cm_rinput | 0100;
1359: fdbuf[1] = pr->prtflag;
1360: fdbuf[2] = '\0';
1361: *v++ = fdbuf;
1362: *v++ = Fileset;
1363: *v++ = Usercode;
1364: *v++ = Database;
1365: *v++ = Pathname;
1366:
1367: /* insert flag parameters */
1368: for (opt = Opt; *opt; opt++)
1369: *v++ = *opt;
1370: *v = 0;
1371:
1372: /* set up 'closeit' to tell which pipes to close */
1373: for (i = 0; i < NOFILE; i++)
1374: closeit[i] = TRUE;
1375: closeit[pr->prmpipe & 077] = FALSE;
1376: closeit[pr->prcm.cm_input & 077] = FALSE;
1377: closeit[pr->prcm.cm_rinput & 077] = FALSE;
1378: for (i = 0; i < CM_MAXPROC; i++)
1379: {
1380: pp = &pr->prcm.cm_proc[i];
1381: if (pp->pr_ninput != CLOSED)
1382: closeit[pp->pr_ninput & 077] = FALSE;
1383: if (pp->pr_file != CLOSED)
1384: closeit[pp->pr_file & 077] = FALSE;
1385: }
1386: closeit[1] = FALSE;
1387: if ((pr->prstat & PR_CLSSIN) == 0)
1388: closeit[0] = FALSE;
1389: if ((pr->prstat & PR_CLSDOUT) == 0)
1390: closeit[2] = FALSE;
1391:
1392: /* close extra pipes (those not used by this process) */
1393: for (i = 0; i < NOFILE; i++)
1394: {
1395: if (closeit[i])
1396: close(i);
1397: }
1398:
1399: /* change to the correct directory */
1400: if ((pr->prstat & PR_NOCHDIR) == 0)
1401: {
1402: if (chdir(Dbpath))
1403: syserr("ingexec: chdir %s", Dbpath);
1404: }
1405:
1406: /* change to normal userid/groupid if a non-dangerous process */
1407: if ((pr->prstat & PR_REALUID) != 0)
1408: {
1409: setuid(getuid());
1410: # ifndef xB_UNIX
1411: setgid(getgid());
1412: # endif
1413: }
1414:
1415: # ifdef LEAVEOUT
1416: /* change standard output if specified in proctab */
1417: p = pr->prstdout;
1418: if (*p != 0)
1419: {
1420: /* chew up fd 0 (just in case) */
1421: outfd = dup(1);
1422: close(1);
1423: if (creat(p, 0666) != 1)
1424: {
1425: /* restore standard output and print error */
1426: close(1);
1427: dup(outfd); /* better go into slot 1 */
1428: syserr("ingexec: creat %s", p);
1429: }
1430: close(outfd);
1431: }
1432: # endif LEAVEOUT
1433:
1434: /*
1435: ** PLEASE NOTE THE TRICKERY USED HERE.
1436: ** In this code I depend on UNIX buffering pipes at least
1437: ** enough to handle one "CM" struct. If not, the following
1438: ** write will hang before the exec will call the process
1439: ** that will read it.
1440: **
1441: ** The "correct" way to do this is to fork & have the
1442: ** parent write the CM struct. But how do I handle the
1443: ** last one (that does not fork)? I could also do an
1444: ** extra fork of a process to do the write. But some
1445: ** systems have a limit on processes, and besides, it
1446: ** seems like a lot of overhead for such a little thing.
1447: **
1448: ** Perhaps I should encode the CM struct into argv
1449: ** instead & do it "right".
1450: */
1451:
1452: /* output the control structure to the awaiting process... */
1453: write(pr->prmpipe & 077, &pr->prcm, sizeof pr->prcm);
1454: close(pr->prmpipe & 077);
1455:
1456: /* give it the old college (or in this case, University) try */
1457: execv(vect[0], vect);
1458: syserr("\"%s\" not executable", vect[0]);
1459: }
1460:
1461:
1462:
1463: pipexlat(ppip, rw)
1464: char *ppip;
1465: int rw;
1466: {
1467: register struct pipeinfo *pi;
1468: int cnt;
1469: int fd;
1470:
1471: if (*ppip == '\0' || *ppip == CLOSED)
1472: return;
1473: pi = &Pipe[*ppip];
1474:
1475: if (rw)
1476: {
1477: cnt = --(pi->pip_wcnt);
1478: fd = pi->pip_wfd;
1479: }
1480: else
1481: {
1482: cnt = --(pi->pip_rcnt);
1483: fd = pi->pip_rfd;
1484: }
1485:
1486: if (cnt < 0)
1487: syserr("pipexlat: cnt=%d: %o %d", cnt, *ppip, rw);
1488: if (fd < 0 || fd > NOFILE)
1489: syserr("pipexlat: fd=%d: %o %d", fd, *ppip, rw);
1490:
1491: *ppip = fd;
1492: }
1493: /*
1494: ** YYLEX -- Return next token from proctab
1495: **
1496: ** Parameters:
1497: ** none
1498: **
1499: ** Returns:
1500: ** Next token
1501: **
1502: ** Side Effects:
1503: ** Input from proctab
1504: */
1505:
1506: # define BOLSTATE 0 /* beginning of line */
1507: # define NORMSTATE 1 /* normal token */
1508: # define EOFSTATE 2 /* end of file */
1509: int LineNo; /* current line number */
1510:
1511: yylex()
1512: {
1513: static int state;
1514: static char *ptp;
1515: auto int ix;
1516: static char line[MAXLINE];
1517: register int c;
1518: register char *p;
1519:
1520: switch (state)
1521: {
1522: case EOFSTATE:
1523: return (0);
1524:
1525: case BOLSTATE:
1526: ptp = line;
1527: for (;;)
1528: {
1529: LineNo++;
1530: c = getc(ProcFile);
1531: if (c < 0)
1532: {
1533: state = EOFSTATE;
1534: return (0);
1535: }
1536: switch (c)
1537: {
1538: case '*':
1539: case '#':
1540: case '\n':
1541: while (c != '\n' && (c = getc(ProcFile)) > 0)
1542: continue;
1543: break;
1544:
1545: case ':':
1546: while (c != '\n' && (c = getc(ProcFile)) > 0)
1547: putchar(c);
1548: break;
1549:
1550: default:
1551: /* regular line, return header */
1552: state = NORMSTATE;
1553: return (c);
1554: }
1555: }
1556:
1557: case NORMSTATE:
1558: yylval.yystr = ptp;
1559: while ((c = getc(ProcFile)) != ':' && c != '\n' && c > 0)
1560: {
1561: *ptp++ = c;
1562: if (c == '$')
1563: {
1564: c = getc(ProcFile);
1565: if (c < 'A' || c > 'Z')
1566: *ptp++ = c;
1567: else
1568: {
1569: ptp--;
1570: for (p = Macro[c - 'A']; (*ptp++ = *p++) != '\0'; )
1571: continue;
1572: ptp--;
1573: }
1574: }
1575: }
1576:
1577: /* compute next state */
1578: if (c != ':')
1579: state = BOLSTATE;
1580:
1581: *ptp++ = '\0';
1582: ix = atoi(yylval.yystr);
1583: if ( *yylval.yystr <= '9' && *yylval.yystr >= '0')
1584: {
1585: if (yylval.yystr[0] == '0')
1586: ix = oatoi(yylval.yystr);
1587: yylval.yyint = ix;
1588: return (INT);
1589: }
1590: else
1591: return (STR);
1592:
1593: default:
1594: syserr("yylex: state %d", state);
1595: }
1596: }
1597:
1598:
1599:
1600:
1601: yyerror(s)
1602: char *s;
1603: {
1604: syserr("Line %d: Yacc error: %s", LineNo, s);
1605: }
1606:
1607:
1608: /*VARARGS1*/
1609: usrerr(f, p1, p2, p3)
1610: char *f;
1611: {
1612: printf("Line %d: ", LineNo);
1613: printf(f, p1, p2, p3);
1614: printf("\n");
1615: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.