Return to pb_read.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / ctlmod

Annotation of 43BSD/ingres/source/ctlmod/pb_read.c, revision 1.1.1.1

1.1       root        1: # include      "ctlmod.h"
                      2: # include      "pipes.h"
                      3: # include      <sccs.h>
                      4: 
                      5: SCCSID(@(#)pb_read.c   8.1     12/31/84)
                      6: 
                      7: /*
                      8: **  PB_READ -- read a pipe block
                      9: **
                     10: **     This routine reads a pipe block into *ppb.  It also handles
                     11: **     all the low level protocol: RESET blocks, SYNC blocks, META
                     12: **     blocks, blocks intended for another process, etc.
                     13: **
                     14: **     When this routine returns, it returns with a block intended
                     15: **     for this process, which must be a REGULAR block, a RESPONSE
                     16: **     block, or an ERROR block.
                     17: **
                     18: **     Parameters:
                     19: **             ppb -- a pointer to the area which wants the block.
                     20: **
                     21: **     Returns:
                     22: **             none
                     23: **
                     24: **     Side Effects:
                     25: **             ppb is set to the named block.
                     26: **             Virtually any amount of stuff can happen, depending
                     27: **                     on what is coming through the pipe.
                     28: **
                     29: **     Trace Flags:
                     30: **             12.4 - 12.9
                     31: */
                     32: 
                     33: 
                     34: pb_read(ppb)
                     35: register pb_t  *ppb;
                     36: {
                     37:        register int    type;
                     38:        register int    from;
                     39:        extern int      (*ExitFn)();
                     40: 
                     41:        /*
                     42:        **  Top Loop.
                     43:        **      Hang waiting for a normal block.  Other blocks are
                     44:        **              handled inside the loop.
                     45:        **      We multiplex 'from' in here temporarily.
                     46:        */
                     47: 
                     48:        for (;;)
                     49:        {
                     50: # ifdef xCTR1
                     51:                if (tTf(12, 4))
                     52:                        lprintf("pb_read: fd=%d:\n", Cm.cm_input);
                     53: # endif
                     54:                from = pb_rphys(ppb, Cm.cm_input);
                     55:                if (from == 0)
                     56:                {
                     57: # ifdef xCTR1
                     58:                        if (tTf(12, 4))
                     59:                                lprintf("EOF\n");
                     60: # endif
                     61:                        (*ExitFn)(0);
                     62:                }
                     63:                else if (from != PB_IOSIZE)
                     64:                        syserr("pb_read: read error (%d)", from);
                     65: # ifdef xCTR1
                     66:                if (tTf(12, 4))
                     67:                        pb_dump(ppb, TRUE);
                     68: # endif
                     69: 
                     70:                /* set up buffer pointers, etc. */
                     71:                ppb->pb_xptr = ppb->pb_data;
                     72:                ppb->pb_nleft = ppb->pb_nused;
                     73:                type = ppb->pb_type;
                     74:                from = ppb->pb_from;
                     75: # ifdef xCM_DEBUG
                     76:                if (from > CM_MAXPROC || from < 0)
                     77:                        syserr("pb_read: from %d", from);
                     78: # endif
                     79: 
                     80:                /* mark this block if possibly from the front */
                     81:                if (Cm.cm_input == Cm.cm_proc[0].pr_ninput &&
                     82:                    bitset(PR_RADJCT, Cm.cm_proc[0].pr_stat))
                     83:                        setbit(PB_FRFR, ppb->pb_stat);
                     84: 
                     85:                /* handle RESET blocks before anything else */
                     86:                if (type == PB_RESET)
                     87:                {
                     88:                        cm_reset();
                     89:                        continue;
                     90:                }
                     91: 
                     92:                /* do sync block processing */
                     93:                if (type == PB_SYNC)
                     94:                {
                     95: /*
                     96:                        if (Syncs[from] <= 0)
                     97:                                lprintf("pb_read: bad SYNC block from %d", from);
                     98:                        else
                     99: */
                    100:                                Syncs[from]--;
                    101:                        continue;
                    102:                }
                    103: 
                    104:                /* see if we are ignoring from this process */
                    105:                if (Syncs[from] > 0)
                    106:                        continue;
                    107: 
                    108:                /* check for re-routing */
                    109:                if (ppb->pb_proc != Cm.cm_myproc)
                    110:                {
                    111:                        pb_write(ppb);
                    112:                        if (ppb->pb_proc != PB_WILD)
                    113:                                continue;
                    114:                }
                    115: 
                    116:                /*
                    117:                **  Block type dispatching.
                    118:                **      Regular, response, and error blocks return.
                    119:                **      Meta blocks are handled by calling other
                    120:                **              routines.
                    121:                */
                    122: 
                    123:                switch (type)
                    124:                {
                    125:                  case PB_REG:
                    126:                  case PB_RESP:
                    127:                  case PB_ERR:
                    128:                        /* handled by readinput() */
                    129:                        return;
                    130: 
                    131:                  case PB_TRACE:
                    132:                        pb_trace(ppb);
                    133:                        break;
                    134: 
                    135:                  /* insert more meta handling before this line */
                    136: 
                    137:                  default:
                    138:                        syserr("pb_read: type %d", type);
                    139:                }
                    140:        }
                    141: }
                    142: /*
                    143: **  PB_TRACE -- handle dynamic trace information
                    144: **
                    145: **     Parameters:
                    146: **             ppb -- a pipe block from which to get information.
                    147: **
                    148: **     Returns:
                    149: **             none.
                    150: **
                    151: **     Side Effects:
                    152: **             trace vectors will be changed.
                    153: */
                    154: 
                    155: pb_trace(ppb)
                    156: pb_t   *ppb;
                    157: {
                    158:        register int            i;
                    159:        register struct fn_def  *f;
                    160: 
                    161:        for (i = 0; i < NumFunc; i++)
                    162:        {
                    163:                f = FuncVect[i];
                    164:                if (f->fn_tflag != '\0')
                    165:                        tTamper(ppb->pb_data, f->fn_tflag, f->fn_tvect, f->fn_tsize);
                    166:        }
                    167: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.