Return to if_imphost.h CVS log

Up to [CSRG BSD Unix] / 43BSD / sys / netimp

Annotation of 43BSD/sys/netimp/if_imphost.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1982, 1986 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  *
                      6:  *     @(#)if_imphost.h        7.1 (Berkeley) 6/4/86
                      7:  */
                      8: 
                      9: /*
                     10:  * Host structure used with IMP's.
                     11:  * Used to hold outgoing packets which
                     12:  * would exceed allowed RFNM count.
                     13:  *
                     14:  * These structures are packed into
                     15:  * mbuf's and kept as small as possible.
                     16:  */
                     17: struct host {
                     18:        struct  mbuf *h_q;              /* holding queue */
                     19:        struct  in_addr h_addr;         /* host's address */
                     20:        u_char  h_qcnt;                 /* size of holding q */
                     21:        u_char  h_timer;                /* used to stay off deletion */
                     22:        u_char  h_rfnm;                 /* # outstanding rfnm's */
                     23:        u_char  h_flags;                /* see below */
                     24: };
                     25: 
                     26: /*
                     27:  * A host structure is kept around (even when there are no
                     28:  * references to it) for a spell to avoid constant reallocation
                     29:  * and also to reflect IMP status back to sites which aren't
                     30:  * directly connected to the IMP.  When structures are marked
                     31:  * free, a timer is started; when the timer expires the structure
                     32:  * is scavenged.
                     33:  */
                     34: #define        HF_INUSE        0x1
                     35: #define        HF_DEAD         (1<<IMPTYPE_HOSTDEAD)
                     36: #define        HF_UNREACH      (1<<IMPTYPE_HOSTUNREACH)
                     37: 
                     38: #define        HOSTTIMER       128             /* keep structure around awhile */
                     39: 
                     40: /*
                     41:  * Host structures, as seen inside an mbuf.
                     42:  * Hashing on the host address is used to
                     43:  * select an index into the first mbuf.  Collisions
                     44:  * are then resolved by searching successive
                     45:  * mbuf's at the same index.  Reclamation is done
                     46:  * automatically at the time a structure is free'd.
                     47:  */
                     48: #define        HPMBUF  ((MLEN - sizeof(int)) / sizeof(struct host))
                     49: #if vax
                     50: #define        HOSTHASH(a)     ((((a).s_addr>>24)+(a).s_addr) % HPMBUF)
                     51: #endif
                     52: 
                     53: /*
                     54:  * In-line expansions for queuing operations on
                     55:  * host message holding queue.  Queue is maintained
                     56:  * as circular list with the head pointing to the
                     57:  * last message in the queue.
                     58:  */
                     59: #define        HOST_ENQUE(hp, m) { \
                     60:        register struct mbuf *n; \
                     61:        (hp)->h_qcnt++; \
                     62:        if ((n = (hp)->h_q) == 0) \
                     63:                (hp)->h_q = (m)->m_act = (m); \
                     64:        else { \
                     65:                (m)->m_act = n->m_act; \
                     66:                (hp)->h_q = n->m_act = (m); \
                     67:        } \
                     68: }
                     69: #define        HOST_DEQUE(hp, m) { \
                     70:        if ((m) = (hp)->h_q) { \
                     71:                if ((m)->m_act == (m)) \
                     72:                        (hp)->h_q = 0; \
                     73:                else { \
                     74:                        (m) = (m)->m_act; \
                     75:                        (hp)->h_q->m_act = (m)->m_act; \
                     76:                } \
                     77:                (hp)->h_qcnt--; \
                     78:                (m)->m_act = 0; \
                     79:        } \
                     80: }
                     81: 
                     82: struct hmbuf {
                     83:        int     hm_count;               /* # of struct's in use */
                     84:        struct  host hm_hosts[HPMBUF];  /* data structures proper */
                     85: };
                     86: 
                     87: #ifdef KERNEL
                     88: struct host *hostlookup();
                     89: struct host *hostenter();
                     90: struct mbuf *hostdeque();
                     91: #endif

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