Return to netutil.c CVS log

Up to [Research Unix] / researchv9 / sys / net

Annotation of researchv9/sys/net/netutil.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *            N E T  U T I L
        !             3:  *
        !             4:  * Utility routines used by various network kernel code.
        !             5:  *
        !             6:  *
        !             7:  * Written by Kurt Gollhardt  (Nirvonics, Inc.)
        !             8:  * Last update Fri Apr  5 16:36:40 1985
        !             9:  *
        !            10:  */
        !            11: 
        !            12: #include "../h/param.h"
        !            13: #include "../h/stream.h"
        !            14: 
        !            15: #define BLEN(bp)    ((bp)->wptr - (bp)->rptr)
        !            16: #define BSZ(bp)            ((bp)->lim - (bp)->base)
        !            17: #undef MIN
        !            18: #define MIN(a,b)    ((a) > (b) ? (b) : (a))
        !            19: 
        !            20: extern int bsize[];
        !            21: 
        !            22: 
        !            23: struct block *block_pullup(q, len)
        !            24:      register struct queue *q;
        !            25: {
        !            26:      register struct block *bp, *m;
        !            27:      int count, ps = spl6();
        !            28: 
        !            29:      if ((bp = q->first) == 0)
        !            30:           goto bad;
        !            31:      if (BLEN(bp) >= len) {
        !            32:           splx(ps);
        !            33:           return bp;
        !            34:      }
        !            35: 
        !            36:      m = allocb(len);
        !            37:      if (m == 0 || BSZ(m) < len)
        !            38:           goto bad;
        !            39:      m->next = bp;
        !            40:      q->first = m;
        !            41:      q->count += bsize[m->class];
        !            42: 
        !            43:      while (bp && bp->type == M_DATA) {
        !            44:          count = BSZ(m) - BLEN(m);
        !            45:           count = MIN(count, len);
        !            46:          count = MIN(count, BLEN(bp));
        !            47:           bcopy(bp->rptr, m->wptr, (unsigned)count);
        !            48:           len -= count;
        !            49:           m->wptr += count;
        !            50:           bp->rptr += count;
        !            51:           if (BLEN(bp) > 0)
        !            52:                break;
        !            53:          if (q->last == bp)
        !            54:               q->last = m;
        !            55:          q->count -= bsize[bp->class];
        !            56:           m->next = bp->next;
        !            57:           freeb(bp);
        !            58:          bp = m->next;
        !            59:      }
        !            60: 
        !            61:      if (len == 0) {
        !            62:           splx(ps);
        !            63:           return m;
        !            64:      }
        !            65: bad:
        !            66:      splx(ps);
        !            67:      printf("block_pullup bad\n");
        !            68:      return 0;
        !            69: }
        !            70: 
        !            71: 
        !            72:      /* Removes blocks through first delim; returns true if delim found */
        !            73: flush_packet(q)
        !            74:      register struct queue    *q;
        !            75: {
        !            76:      register struct block    *bp;
        !            77:      register int   isdelim;
        !            78: 
        !            79:      while (bp = getq(q)) {
        !            80:           isdelim = (bp->type == M_DELIM);
        !            81:          freeb(bp);
        !            82:          if (isdelim)
        !            83:               return 1;
        !            84:      }
        !            85:      return 0;
        !            86: }

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