Return to if_imphost.c CVS log

Up to [Net/2] / Net2 / netimp

Annotation of Net2/netimp/if_imphost.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     @(#)if_imphost.c        7.10 (Berkeley) 6/28/90
        !            34:  */
        !            35: 
        !            36: #include "imp.h"
        !            37: #if NIMP > 0
        !            38: /*
        !            39:  * Host table manipulation routines.
        !            40:  * Only needed when shipping stuff through an IMP.
        !            41:  *
        !            42:  * Everything in here is called at splimp from
        !            43:  * from the IMP protocol code (if_imp.c), or
        !            44:  * interlocks with the code at splimp.
        !            45:  */
        !            46: #include "param.h"
        !            47: #include "mbuf.h"
        !            48: #include "socket.h"
        !            49: #include "syslog.h"
        !            50: 
        !            51: #include "../net/if.h"
        !            52: 
        !            53: #include "../netinet/in.h"
        !            54: #include "../netinet/in_systm.h"
        !            55: 
        !            56: #include "if_imp.h"
        !            57: #include "if_imphost.h"
        !            58: 
        !            59: extern struct imp_softc imp_softc[];
        !            60: 
        !            61: /*
        !            62:  * Given an internet address
        !            63:  * return a host structure (if it exists).
        !            64:  */
        !            65: struct host *
        !            66: hostlookup(imp, host, unit)
        !            67:        int imp, host, unit;
        !            68: {
        !            69:        register struct host *hp;
        !            70:        register struct mbuf *m;
        !            71:        register int hash = HOSTHASH(imp, host);
        !            72: 
        !            73:        for (m = imp_softc[unit].imp_hosts; m; m = m->m_next) {
        !            74:                hp = &mtod(m, struct hmbuf *)->hm_hosts[hash];
        !            75:                if (hp->h_imp == imp && hp->h_host == host) {
        !            76:                        if ((hp->h_flags & HF_INUSE) == 0)
        !            77:                                mtod(dtom(hp), struct hmbuf *)->hm_count++;
        !            78:                        hp->h_flags |= HF_INUSE;
        !            79:                        return (hp);
        !            80:                }
        !            81:        }
        !            82:        return ((struct host *)0);
        !            83: }
        !            84: 
        !            85: /*
        !            86:  * Enter a reference to this host's internet
        !            87:  * address.  If no host structure exists, create
        !            88:  * one and hook it into the host database.
        !            89:  */
        !            90: struct host *
        !            91: hostenter(imp, host, unit)
        !            92:        int imp, host, unit;
        !            93: {
        !            94:        register struct mbuf *m, **mprev;
        !            95:        register struct host *hp, *hp0 = 0;
        !            96:        register int hash = HOSTHASH(imp, host);
        !            97: 
        !            98:        mprev = &imp_softc[unit].imp_hosts;
        !            99:        while (m = *mprev) {
        !           100:                mprev = &m->m_next;
        !           101:                hp = &mtod(m, struct hmbuf *)->hm_hosts[hash];
        !           102:                if (hp->h_imp == imp && hp->h_host == host) {
        !           103:                        if ((hp->h_flags & HF_INUSE) == 0)
        !           104:                                mtod(dtom(hp), struct hmbuf *)->hm_count++;
        !           105:                        goto foundhost;
        !           106:                }
        !           107:                if ((hp->h_flags & HF_INUSE) == 0) {
        !           108:                        if (hp0 == 0)
        !           109:                                hp0 = hp;
        !           110:                        continue;
        !           111:                }
        !           112:        }
        !           113: 
        !           114:        /*
        !           115:         * No current host structure, make one.
        !           116:         * If our search ran off the end of the
        !           117:         * chain of mbuf's, allocate another.
        !           118:         */
        !           119:        if (hp0 == 0) {
        !           120:                m = m_getclr(M_DONTWAIT, MT_HTABLE);
        !           121:                if (m == NULL)
        !           122:                        return ((struct host *)0);
        !           123:                *mprev = m;
        !           124:                hp0 = &mtod(m, struct hmbuf *)->hm_hosts[hash];
        !           125:        }
        !           126:        hp = hp0;
        !           127:        mtod(dtom(hp), struct hmbuf *)->hm_count++;
        !           128:        hp->h_imp = imp;
        !           129:        hp->h_host = host;
        !           130:        hp->h_timer = 0;
        !           131:        hp->h_flags = 0;
        !           132: 
        !           133: foundhost:
        !           134:        hp->h_flags |= HF_INUSE;
        !           135:        return (hp);
        !           136: }
        !           137: 
        !           138: /*
        !           139:  * Reset a given imp unit's host entries.
        !           140:  * Must be called at splimp.
        !           141:  */
        !           142: hostreset(unit)
        !           143:        int unit;
        !           144: {
        !           145:        register struct mbuf *m;
        !           146:        register struct host *hp, *lp;
        !           147:        struct hmbuf *hm;
        !           148: 
        !           149:        for (m = imp_softc[unit].imp_hosts; m; m = m->m_next) {
        !           150:                hm = mtod(m, struct hmbuf *);
        !           151:                hp = hm->hm_hosts; 
        !           152:                lp = hp + HPMBUF;
        !           153:                while (hm->hm_count > 0 && hp < lp) {
        !           154:                        hostrelease(hp);
        !           155:                        hp++;
        !           156:                }
        !           157:        }
        !           158:        hostcompress(unit);
        !           159: }
        !           160: 
        !           161: /*
        !           162:  * Remove a host structure and release
        !           163:  * any resources it's accumulated.
        !           164:  */
        !           165: hostrelease(hp)
        !           166:        register struct host *hp;
        !           167: {
        !           168: 
        !           169:        if (hp->h_q)
        !           170:                hostflush(hp);
        !           171:        hp->h_rfnm = 0;
        !           172:        if (hp->h_flags & HF_INUSE)
        !           173:                --mtod(dtom(hp), struct hmbuf *)->hm_count;
        !           174:        hp->h_flags = 0;
        !           175: }
        !           176: 
        !           177: /*
        !           178:  * Flush the message queue for a host.
        !           179:  */
        !           180: hostflush(hp)
        !           181:        register struct host *hp;
        !           182: {
        !           183:        register struct mbuf *m;
        !           184: 
        !           185:        /*
        !           186:         * Discard any packets left on the waiting q
        !           187:         */
        !           188:        if (m = hp->h_q) {
        !           189:                register struct mbuf *n;
        !           190: 
        !           191:                do {
        !           192:                        n = m->m_act;
        !           193:                        m_freem(m);
        !           194:                        m = n;
        !           195:                } while (m != hp->h_q);
        !           196:                hp->h_q = 0;
        !           197:                hp->h_qcnt = 0;
        !           198:        }
        !           199: }
        !           200: 
        !           201: /*
        !           202:  * Release mbufs in host table that contain no entries
        !           203:  * currently in use.  Must be called at splimp.
        !           204:  */
        !           205: hostcompress(unit)
        !           206:        int unit;
        !           207: {
        !           208:        register struct mbuf *m, **mprev;
        !           209:        struct imp_softc *sc = &imp_softc[unit];
        !           210: 
        !           211:        mprev = &sc->imp_hosts;
        !           212:        sc->imp_hostq = 0;
        !           213:        while (m = *mprev) {
        !           214:                if (mtod(m, struct hmbuf *)->hm_count == 0)
        !           215:                        *mprev = m_free(m);
        !           216:                else
        !           217:                        mprev = &m->m_next;
        !           218:        }
        !           219: }
        !           220: 
        !           221: /*
        !           222:  * Host data base timer routine.
        !           223:  * Decrement timers on structures which are
        !           224:  * waiting to be deallocated.  On expiration
        !           225:  * release resources, possibly deallocating
        !           226:  * mbuf associated with structure.
        !           227:  */
        !           228: hostslowtimo()
        !           229: {
        !           230:        register struct mbuf *m;
        !           231:        register struct host *hp, *lp;
        !           232:        struct imp_softc *sc;
        !           233:        struct hmbuf *hm;
        !           234:        int s = splimp(), unit, any;
        !           235: 
        !           236:        for (unit = 0; unit < NIMP; unit++) {
        !           237:            any = 0;
        !           238:            sc = &imp_softc[unit];
        !           239:            for (m = sc->imp_hosts; m; m = m->m_next) {
        !           240:                hm = mtod(m, struct hmbuf *);
        !           241:                hp = hm->hm_hosts; 
        !           242:                lp = hp + HPMBUF;
        !           243:                for (; hm->hm_count > 0 && hp < lp; hp++) {
        !           244:                    if (hp->h_timer && --hp->h_timer == 0) {
        !           245:                        if (hp->h_rfnm) {
        !           246:                                log(LOG_INFO,                   /* XXX */
        !           247:                                    "imp%d: host %d/imp %d, lost rfnm\n",
        !           248:                                    unit, hp->h_host, ntohs(hp->h_imp));
        !           249:                                sc->imp_lostrfnm++;
        !           250:                                imprestarthost(sc, hp);
        !           251:                        } else {
        !           252:                                any = 1;
        !           253:                                hostrelease(hp);
        !           254:                                if (sc->imp_hostq == m)
        !           255:                                        sc->imp_hostq = 0;
        !           256:                        }
        !           257:                    }
        !           258:                }
        !           259:            }
        !           260:            if (any)
        !           261:                hostcompress(unit);
        !           262:        }
        !           263:        splx(s);
        !           264: }
        !           265: #endif

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