# 2.11BSD#431 - /usr/ingres/source/equel/runtime/IIrdpipe.c

##### Functions

    IIrdpipe          X

       1: # include   "../../ingres.h"
       2: # include   "../../symbol.h"
       3: # include   "../../pipes.h"
       4: # include   "IIglobals.h"
       5:
       6: /*
       7: **  Buffered Read From Pipe
       8: **
       9: **	Reads from the pipe with the UNIX file descriptor `des' into
      10: **	the buffer `buf'.  `Mode' tells what is to be done.  `Msg' is
      11: **	the address of the input buffer, and `n' is the length of the
      12: **	info.  If `n' is zero, the data is assumed to be a null-
      13: **	terminated string.
      14: **
      15: **	`Buf' is defined in "../pipes.h" together with the modes.
      16: **	The pipe should be written by wrpipe() to insure that the
      17: **	pipe formats match.
      18: **
      19: **	Modes:
      20: **
      21: **	P_PRIME -- Primes the buffer.  This involves cleaning out all
      22: **		the header stuff so that a physical read is forced
      23: **		on the next normal call to rdpipe().  It also resets
      24: **		the error flag, etc.
      25: **
      26: **	P_NORM -- This is the normal mode.  If the buffer is empty,
      27: **		it is filled from the pipe.  `N' bytes are moved into
      28: **		`msg'.  If `n' is zero, bytes are moved into `msg' up
      29: **		to and including the first null byte.  The pipe is
      30: **		read whenever necessary, so the size of the data
      31: **		buffer (controlled by PBUFSIZ) has absolutely no
      32: **		effect on operation.
      33: **
      34: **	P_SYNC -- This mode reads the buffer, filling the pipe as
      35: **		necessary, until an End Of Pipe (EOP) is encountered.
      36: **		An EOP is defined as an empty buffer with a mode
      37: **		("hdrstat") of "END_STAT".  Any data left in the pipe
      38: **		is thrown away, but error messages are not.  Anything
      39: **		not already read by the user is read by P_SYNC, so if
      40: **		you are not certain that you have already read the
      41: **		previous EOP.
      42: **
      43: **	P_EXECID -- The first (exec_id) field of the pipe buffer header
      44: **		is read and returned.  This is used (for instance) by
      45: **		the DBU routines, which must get the exec_id, but must
      46: **		not read the rest of the pipe in case they must overlay
      47: **		themselves.  It must ALWAYS be followed by a rdpipe of
      48: **		mode P_FUNCID!!
      49: **
      50: **	P_FUNCID -- The second through last bytes of the pipe are read
      51: **		into the buffer, and the function code ("func_id") is
      52: **		returned.  This is the second half of a P_EXECID call.
      53: **
      54: **	P_INT -- In the event of an interrupt, a wrpipe() call should
      55: **		be made to all writable pipes of mode P_INT, and then
      56: **		rdpipe() calls should be made on all readable pipes
      57: **		of this mode.  This clears out the pipe up until a
      58: **		special type of pipe header ("SYNC_STAT") is read.  It
      59: **		is absolutely critical that this is called in conjunc-
      60: **		tion with all other processes.  This mode is used in
      61: **		resyncpipes(), which performs all the correct calls
      62: **		in the correct order.
      63: **
      64: **	In all cases except P_INT mode, if an error is read from the
      65: **	pipe it is automatically passed to proc_error().  This routine
      66: **	is responsible for passing the error message to the next higher
      67: **	process.
      68: **
      69: **	If an end of file is read from the pipe, the end_job() routine
      70: **	is called.  This routine should do any necessary end of job
      71: **	processing needed (closing relations, etc.) and return with
      72: **	a zero value.
      73: **
      74: **	Default proc_error() and end_job() routines exist in the
      75: **	library, so if you don't want any extra processing, you can
      76: **	just not bother to define them.
      77: **
      78: **	In general, the number of bytes actually read is returned.  If
      79: **	you read an EOP, zero is returned.
      80: */
      81:
      82: IIrdpipe(mode, buf1, des, msg, n)
      83: int     mode;
      84: char        *msg;
      85: int     n;
      86: int     des;        /* UNIX file descriptor for pipe */
      87: struct pipfrmt  *buf1;
      88: {
      89:     register int        knt;
      90:     register int        syncflg;
      91:     int         i;
      92:     extern char     *IIproc_name;
      93:     char            *proc_name;
      94:     register struct pipfrmt *buf;
      95:     char            *argv[10], args[512];
      96:     char            *ap;
      97:     int         argc, err;
      98:
      99: #	ifdef xATR1
     100:     proc_name = IIproc_name ? IIproc_name : "";
     101: #	endif
     102:
     103:     buf = buf1;
     104:
     105: #	ifdef xATR1
     106:     if (IIdebug > 1)
     107:         printf("\n%s ent rdpipe md %d buf %u des %d\n", proc_name, mode, buf, des);
     108: #	endif
     109:     syncflg = 0;
     110:     switch (mode)
     111:     {
     112:
     113:       case P_PRIME:
     114:         buf->pbuf_pt = buf->buf_len = buf->err_id = 0;
     115:         buf->hdrstat = NORM_STAT;
     116:         return (0);
     117:
     118:       case P_NORM:
     119:         break;
     120:
     121:       case P_SYNC:
     122:         syncflg++;
     123:         break;
     124:
     125:       case P_EXECID:
     126:         if (read(des, &buf->exec_id, 1) < 1)
     127:         {
     128:             goto eoj;
     129:         }
     130: #		ifdef xATR3
     131:         if (IIdebug > 1)
     132:             printf("%s rdpipe ret %c\n", proc_name,  buf->exec_id);
     133: #		endif
     134:         return (buf->exec_id);
     135:
     136:       case P_FUNCID:
     137:         i = read(des, &buf->func_id, HDRSIZ+PBUFSIZ-1) + 1;
     138:         buf->pbuf_pt = -1;
     139:         goto chkerr;
     140:
     141:       case P_INT:
     142:         syncflg--;
     143:         buf->hdrstat = NORM_STAT;
     144:         break;
     145:
     146:       default:
     147:         IIsyserr("rdpipe: bad call %d", mode);
     148:     }
     149:     knt = 0;
     150:     if (buf->pbuf_pt < 0)
     151:         buf->pbuf_pt = 0;
     152:
     153:     do
     154:     {
     155:         /* check for buffer empty */
     156:         while (buf->pbuf_pt >= buf->buf_len || syncflg)
     157:         {
     158:             /* read a new buffer full */
     159:             if (buf->hdrstat == LAST_STAT && syncflg >= 0)
     160:             {
     161:                 goto out;
     162:             }
     163: #			ifdef xATR3
     164:             if (IIdebug > 1)
     165:             {
     166:                 printf("%s rdng %d w len %d pt %d err %d sf %d\n",
     167:                     proc_name, des, buf->buf_len, buf->pbuf_pt, buf->err_id, syncflg);
     168:             }
     169: #			endif
     170:             i = read(des, buf, HDRSIZ+PBUFSIZ);
     171:             if (i == 0)
     172:             {
     173:             eoj:
     174: #				ifdef xATR3
     175:                 if (IIdebug > 1)
     176:                     printf("%s rdpipe exit\n", proc_name);
     177: #				endif
     178:                 if (syncflg < 0)
     179:                     IIsyserr("rdpipe: EOF %d", des);
     180:                 /* exit(end_job(buf, des)); */
     181:                 exit(-1);
     182:             }
     183:             buf->pbuf_pt = 0;
     184:         chkerr:
     185: #			ifdef xATR2
     186:             if (IIdebug > 1)
     187:                 IIprpipe(buf);
     188: #			endif
     189:             if (i < HDRSIZ+PBUFSIZ)
     190:                 IIsyserr("rdpipe: rd err buf %u des %d", buf, des);
     191:             if (buf->hdrstat == SYNC_STAT)
     192:             {
     193:                 if (syncflg < 0)
     194:                     return (1);
     195:                 else
     196:                     IIsyserr("rdpipe: unexpected SYNC_STAT");
     197:             }
     198:             if (buf->err_id != 0 && syncflg >= 0)
     199:             {
     200: #				ifdef xATR2
     201:                 if (IIdebug > 1)
     202:                     printf("%s rdpipe err %d\n", proc_name, buf->err_id);
     203: #				endif
     204:                 /* proc_error(buf, des); */
     205:                 /* The error parameters are read here
     206: 				** and put into an argv, argc structure
     207: 				** so that the user doesn't have to use
     208: 				** Ingres utilities to write an intelligent
     209: 				** error handler.
     210: 				*/
     211:                 ap = args;
     212:                 argc = 0;
     213:                 err = buf->err_id;
     214:                 while (i = IIrdpipe(P_NORM,buf,des,ap,0))
     215:                 {
     216:                     argv[argc++] = ap;
     217:                     ap += i;
     218:                     if (argc > 10 || (args - ap) >= 500)
     219:                         IIsyserr("Too many error parameters!");
     220:                 }
     221:                 IIerror(err, argc, argv);
     222: #				ifdef xATR3
     223:                 if (IIdebug > 1)
     224:                     printf("%s pe ret\n", proc_name);
     225: #				endif
     226:                 buf->pbuf_pt = buf->buf_len;
     227:                 buf->hdrstat = NORM_STAT;
     228:             }
     229:             if (buf->pbuf_pt < 0)
     230:             {
     231:                 /* P_FUNCID mode */
     232: #				ifdef xATR1
     233:                 if (IIdebug > 1)
     234:                     printf("%s rdpipe ret %c\n",
     235:                         proc_name, buf->func_id);
     236: #				endif
     237:                 return (buf->func_id);
     238:             }
     239:         }
     240:         /* get a byte of information */
     241:         msg[knt++] = buf->pbuf[buf->pbuf_pt++];
     242:     } while ((n == 0) ? (msg[knt-1]) : (knt < n));
     243:
     244: out:
     245: #	ifdef xATR1
     246:     if (IIdebug > 1)
     247:     {
     248:         printf("%s rdpipe ret %d", proc_name, knt);
     249:         if (n == 0 && syncflg == 0)
     250:             printf(", str `%s'", msg);
     251:         printf("\n");
     252:     }
     253: #	endif
     254:     return(knt);
     255: }

#### Defined functions

IIrdpipe defined in line 82; used 17 times

- in line 214
- in /usr/ingres/source/equel/runtime/IIflushtup.c line 32-42(5)
- in /usr/ingres/source/equel/runtime/IIgettup.c line 38-41(2)
- in /usr/ingres/source/equel/runtime/IIingres.c line 56
- in /usr/ingres/source/equel/runtime/IIn_get.c line 51
- in /usr/ingres/source/equel/runtime/IIn_ret.c line 47, 139
- in /usr/ingres/source/equel/runtime/IIresync.c line 34-38(3)
- in /usr/ingres/source/equel/runtime/IIsync.c line 35-36(2)

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