# 2.11BSD#431 - /usr/ingres/source/monitor/main.c

##### Functions

    end_job           X
    main              X
    proc_error        X
    rubproc           X

##### Macros

    ERRDELIM          X

       1: # include   <stdio.h>
       2:
       3: # include   "../ingres.h"
       4: # include   "../aux.h"
       5: # include   "../unix.h"
       6: # include   "../pipes.h"
       7: # include   "monitor.h"
       8:
       9: # define    ERRDELIM    '~'
      10:
      11: /*
      12: **  INTERACTIVE TERMINAL MONITOR
      13: **
      14: **	The monitor gathers text from the standard input and performs
      15: **	a variety of rudimentary editting functions.  This program
      16: **	is the main setup.  Monitor() is then called, which does the
      17: **	real work.
      18: **
      19: **	variables:
      20: **	Nodayfile -- zero prints all messages; positive one suppresses
      21: **		dayfile and logout but not prompts; negative one
      22: **		suppresses all printed material except results from \p.
      23: **	Newline -- set when the last character in the query buffer
      24: **		is a newline.
      25: **	Prompt -- set when a prompt character is needed.
      26: **	Autoclear -- set when the query buffer should be cleared before
      27: **		putting another character in.
      28: **	Nautoclear -- if set, suppresses the autoclear function
      29: **		entirely.
      30: **
      31: **	flags:
      32: **	-M -- trace flag
      33: **	-d -- suppress dayfile
      34: **	-s -- suppress prompt (sets -d)
      35: **	-a -- disable autoclear function
      36: **
      37: **	The last three options can be set by stating "+x".
      38: **
      39: **	Uses trace flag 9
      40: **	Proc_error uses trace flag 11
      41: **
      42: **	History:
      43: **		8/15/79 (eric) (6.2/7) -- added {database} and
      44: **			{usercode} macros.
      45: **		3/2/79 (eric) -- rubproc changed to know about the
      46: **			Trapfile stuff.
      47: */
      48:
      49: extern char *Usercode;
      50: extern char *Database;
      51:
      52: main(argc, argv)
      53: int argc;
      54: char    *argv[];
      55: {
      56:     register int        ndx;
      57:     extern char     *Proc_name;
      58:     register char       *p;
      59:     extern          quit();
      60:     extern int      (*Exitfn)();
      61:     extern int      Equel;
      62:     char            buff[100];
      63:     extern char     **Xparams;
      64:     char            *getufield();
      65:
      66:     /* insure that permissions are ok */
      67:     setuid(getuid());
      68: #	ifndef xB_UNIX
      69:     setgid(getgid());
      70: #	endif
      71:
      72:     setexit();
      73:     signal(13, &quit);
      74:
      75: #	ifdef xMTR1
      76:     tTrace(&argc, argv, 'M');
      77: #	endif
      78:     initproc("MONITOR", argv);
      79:     Exitfn = &quit;
      80:
      81:     /* process arguments */
      82:     if (!setflag(argv, 'd', 1))
      83:         Nodayfile = 1;
      84:     if (!setflag(argv, 's', 1))
      85:         Nodayfile = -1;
      86:     Nautoclear = !setflag(argv, 'a', 1);
      87: #	ifdef xMTR3
      88:     if (tTf(9, 0))
      89:     {
      90:         close(ndx = dup(0));
      91:         printf("0 dups as %d\n", ndx);
      92:     }
      93: #	endif
      94: #	ifdef xMTR2
      95:     if (tTf(9, 1))
      96:         prargs(argc, argv);
      97:     if (tTf(9, 2))
      98:     {
      99:         printf("R_up %d W_up %d R_down %d W_down %d\n",
     100:             R_up, W_up, R_down, W_down);
     101:         printf("R_front %d W_front %d Equel %d\n",
     102:             R_front, W_front, Equel);
     103:     }
     104: #	endif
     105:     smove(Version, Versn);
     106:     for (p = Versn; *p != '/'; p++)
     107:         if (!*p)
     108:             break;
     109:     *p = '\0';
     110:
     111:     /* preinitialize macros */
     112:     macinit(0, 0, 0);
     113:     macdefine("{pathname}", Pathname, 1);
     114:     macdefine("{database}", Database, 1);
     115:     macdefine("{usercode}", Usercode, 1);
     116:
     117:     /* print the dayfile */
     118:     if (Nodayfile >= 0)
     119:     {
     120:         time(buff);
     121:         printf("INGRES version %s login\n%s", Version, ctime(buff));
     122:     }
     123:     if (Nodayfile == 0 && (Qryiop = fopen(ztack(ztack(Pathname, "/files/dayfile"), Versn), "r")) != NULL)
     124:     {
     125:         while ((ndx = getc(Qryiop)) > 0)
     126:             putchar(ndx);
     127:         fclose(Qryiop);
     128:     }
     129:
     130:     /* SET UP LOGICAL QUERY-BUFFER FILE */
     131:     concat("/tmp/INGQ", Fileset, Qbname);
     132:     if ((Qryiop = fopen(Qbname, "w")) == NULL)
     133:         syserr("main: open(%s)", Qbname);
     134:
     135:     /* GO TO IT ... */
     136:     Prompt = Newline = TRUE;
     137:     Userdflag = Nodayfile;
     138:     Nodayfile = -1;
     139:
     140:     /* run the system initialization file */
     141:     setexit();
     142:     Phase++;
     143:     include(Xparams[0]);
     144:
     145:     /* find out what the user initialization file is */
     146:     setexit();
     147:     if (getuser(Usercode, buff) == 0)
     148:     {
     149:         p = getufield(buff, 7);
     150:         if (*p != 0)
     151:             include(p);
     152:     }
     153:     getuser(0, 0);
     154:
     155:     Nodayfile = Userdflag;
     156:
     157:     /* get user input from terminal */
     158:     Input = stdin;
     159:     setbuf(stdin, NULL);
     160:     setexit();
     161:     xwait();
     162:     monitor();
     163:     quit();
     164: }
     165:
     166:
     167:
     168:
     169:
     170: /*
     171: **  CATCH SIGNALS
     172: **
     173: **	clear out pipes and respond to user
     174: **
     175: **	Uses trace flag 10
     176: */
     177:
     178: rubproc()
     179: {
     180:     register int    i;
     181:     long        ltemp;
     182:
     183: #	ifdef xMTR3
     184:     if (tTf(10, 0))
     185:         printf("caught sig\n");
     186: #	endif
     187:     if (Xwaitpid == 0)
     188:         printf("\nInterrupt\n");
     189:     resyncpipes();
     190:     for (i = 3; i < MAXFILES; i++)
     191:     {
     192:         if (i == Qryiop->_file || i == R_down || i == W_down ||
     193:             (Trapfile != NULL && i == Trapfile->_file))
     194:             continue;
     195:         close(i);
     196:     }
     197:     ltemp = 0;
     198:     lseek(stdin->_file, ltemp, 2);
     199:     Newline = Prompt = TRUE;
     200:     Nodayfile = Userdflag;
     201:     Oneline = FALSE;
     202:     Idepth = 0;
     203:     setbuf(stdin, NULL);
     204:     Input = stdin;
     205: }
     206:
     207:
     208: /*
     209: **  PROCESS ERROR MESSAGE
     210: **
     211: **	This routine takes an error message off of the pipe and
     212: **	processes it for output to the terminal.  This involves doing
     213: **	a lookup in the .../files/error? files, where ? is the thous-
     214: **	ands digit of the error number.  The associated error message
     215: **	then goes through parameter substitution and is printed.
     216: **
     217: **	In the current version, the error message is just printed.
     218: **
     219: **	Uses trace flag 11
     220: */
     221:
     222: proc_error(s1, rpipnum)
     223: struct pipfrmt  *s1;
     224: int     rpipnum;
     225: {
     226:     register struct pipfrmt *s;
     227:     register char       c;
     228:     char            *pv[10];
     229:     char            parm[512];
     230:     int         pc;
     231:     register char       *p;
     232:     int         i;
     233:     char            buf[sizeof parm + 30];
     234:     int         err;
     235:     FILE            *iop;
     236:     char            *errfilen();
     237:     char            *mcall();
     238:
     239:     s = s1;
     240:     err = s->err_id;
     241:     Error_id = err;
     242:
     243:     /* read in the parameters */
     244:     pc = 0;
     245:     p = parm;
     246:     while (i = rdpipe(P_NORM, s, R_down, p, 0))
     247:     {
     248:         pv[pc] = p;
     249: #		ifdef xMTR3
     250:         if (tTf(11, 1))
     251:             printf("pv[%d] = %s, i=%d\n", pc, p, i);
     252: #		endif
     253:         p += i;
     254:         pc++;
     255:         if (pc >= 10 || (p - parm) >= 500)
     256:         {
     257:             /* buffer overflow; throw him off */
     258:             syserr("Your error buffer overfloweth @ pc %d err %d p-p %d",
     259:                 pc, err, p - parm);
     260:         }
     261:     }
     262:     pv[pc] = 0;
     263:     rdpipe(P_PRIME, s);
     264:
     265:     /* try calling the {catcherror} macro -- maybe not print */
     266:     p = buf;
     267:     p += smove("{catcherror; ", p);
     268:     p += smove(iocv(err), p);
     269:     p += smove("}", p);
     270:
     271:     p = mcall(buf);
     272:     if (sequal(p, "0"))
     273:         return (1);
     274:
     275:     /* open the appropriate error file */
     276:     p = errfilen(err / 1000);
     277:
     278: #	ifdef xMTR3
     279:     if (tTf(11, -1))
     280:         printf("proc_error: ");
     281:     if (tTf(11, 0))
     282:         printf("%d, %s", err, p);
     283: #	endif
     284:
     285:     if ((iop = fopen(p, "r")) == NULL)
     286:         syserr("proc_error: open(%s)", p);
     287:
     288:     /* read in the code and check for correct */
     289:     for (;;)
     290:     {
     291:         p = buf;
     292:         while ((c = getc(iop)) != '\t')
     293:         {
     294:             if (c <= 0)
     295:             {
     296:                 /* no code exists, print the args */
     297:                 printf("%d:", err);
     298:                 for (i = 0; i < pc; i++)
     299:                     printf(" `%s'", pv[i]);
     300:                 printf("\n");
     301:                 fclose(iop);
     302:                 return (1);
     303:             }
     304:             *p++ = c;
     305:         }
     306:         *p = 0;
     307:         if (atoi(buf, &i))
     308:             syserr("proc_error: bad error file %d\n%s",
     309:                 err, buf);
     310:         if (i != err)
     311:         {
     312:             while ((c = getc(iop)) != ERRDELIM)
     313:                 if (c <= 0)
     314:                     syserr("proc_error: format err %d", err);
     315:             getc(iop);  /* throw out the newline */
     316:             continue;
     317:         }
     318:
     319:         /* got the correct line, print it doing parameter substitution */
     320:         printf("%d: ", err);
     321:         c = '\n';
     322:         for (;;)
     323:         {
     324:             c = getc(iop);
     325:             if (c <= 0 || c == ERRDELIM)
     326:             {
     327:                 printf("\n");
     328:                 fclose(iop);
     329:                 return (1);
     330:             }
     331:             if (c == '%')
     332:             {
     333:                 c = getc(iop);
     334:                 for (p = pv[c - '0']; c = *p; p++)
     335:                 {
     336:                     if (c < 040 || c >= 0177)
     337:                         printf("\\%o", c);
     338:                     else
     339:                         putchar(c);
     340:                 }
     341:                 continue;
     342:             }
     343:             printf("%c", c);
     344:         }
     345:     }
     346: }
     347:
     348:
     349:
     350: /*
     351: **  END_JOB -- "cannot happen"
     352: */
     353:
     354: end_job()
     355: {
     356:     syserr("end_job??");
     357: }

#### Defined functions

end_job defined in line 354; never used
main defined in line 52; never used
proc_error defined in line 222; never used
rubproc defined in line 178; never used

#### Defined macros

ERRDELIM defined in line 9; used 2 times

- in line 312, 325

Last modified: 1995-02-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1555 |