Return to ip_arp.c CVS log

Up to [Research Unix] / researchv10no / sys / inet

Annotation of researchv10no/sys/inet/ip_arp.c, revision 1.1

1.1     ! root        1: #include "sys/param.h"
        !             2: #include "sys/systm.h"
        !             3: #include "sys/ethernet.h"
        !             4: #include "sys/stream.h"
        !             5: #include "sys/inet/in.h"
        !             6: #include "sys/inet/ip_var.h"
        !             7: 
        !             8: /*
        !             9:  * Address resolution code. ip_ldout() calls arp_resolve if IFF_ARP
        !            10:  * is set to map an internet address into a 48 bit ethernet address.
        !            11:  * If arp_resolve finds the address in its tables, it prepends an
        !            12:  * ethernet header to the packet and returns it. Otherwise, it sends
        !            13:  * a message to the ipconfig waiting on the specified queue asking
        !            14:  * it to do all the hard work. The user process at some point will use
        !            15:  * the IPIORESOLVE ioctl to update the tabes.
        !            16:  *
        !            17:  * N.B. If we ever get a medium other than ethernet that needs arping,
        !            18:  *      this code will need to be made a bit more general.
        !            19:  */
        !            20: 
        !            21: /*
        !            22:  * Hash table for arp entries.  Collision resolution is linear search until
        !            23:  * encountering a hole.  Replacement is LRU.
        !            24:  */
        !            25: /* #define NARP 128                    /* number of arp entries */
        !            26: extern int arpcnt;                     /* number of arp entries */
        !            27: extern struct ip_arp ip_arps[];                /* arping table */
        !            28: #define HASH(x) ((x)%arpcnt)
        !            29: 
        !            30: arp_install(in, en)
        !            31:        register unsigned long in;
        !            32:        unsigned char *en;
        !            33: {
        !            34:        register struct ip_arp *ap, *rp, *op;
        !            35: 
        !            36:        /* find matching entry, empty entry, or oldest entry */
        !            37:        op = ap = rp = &ip_arps[HASH(in)];
        !            38:        do {
        !            39:                if (ap->inaddr==0 || ap->inaddr==in) {
        !            40:                        op = ap;
        !            41:                        break;
        !            42:                }
        !            43:                if (ap->time < op->time)
        !            44:                        op = ap;
        !            45:                if(++ap==&ip_arps[arpcnt])
        !            46:                        ap = ip_arps;
        !            47:        } while(ap!=rp);
        !            48: 
        !            49:        /* fill in new entry */
        !            50:        op->time = time;
        !            51:        op->inaddr = in;
        !            52:        bcopy((caddr_t)en, (caddr_t)op->enaddr, sizeof(op->enaddr));
        !            53:        return(0);
        !            54: }
        !            55: 
        !            56: struct block *
        !            57: arp_resolve(q, bp, dst)
        !            58:        struct queue *q;
        !            59:        register struct block *bp;
        !            60:        unsigned long dst;
        !            61: {
        !            62:        register struct block *bp1;
        !            63:        struct etherpup *hp;
        !            64:        register struct ip_arp *ap, *rp;
        !            65: 
        !            66:        /* find matching entry */
        !            67:        ap = rp = &ip_arps[HASH(dst)];
        !            68:        do {
        !            69:                if (ap->inaddr==0 || ap->inaddr==dst)
        !            70:                        break;
        !            71:                if(++ap==&ip_arps[arpcnt])
        !            72:                        ap = ip_arps;
        !            73:        } while(ap!=rp);
        !            74:        if (ap->inaddr!=dst) {
        !            75:                arp_request(q, dst);    /* request an address resolution */
        !            76:                bp_free(bp);            /* free the packet */
        !            77:                return(0);
        !            78:        }
        !            79: 
        !            80:        /* make a block with the ether info */
        !            81:        bp1 = allocb(sizeof(struct etherpup));
        !            82:        if(bp1 == 0){
        !            83:                printf("no bp for arp_resolve\n");
        !            84:                bp_free(bp);
        !            85:                return(0);
        !            86:        }
        !            87:        ap->time = time;
        !            88:        bp1->type = M_DATA;
        !            89:        bp1->wptr = bp1->rptr + sizeof(struct etherpup);
        !            90:        bp1->next = bp;
        !            91:        hp = (struct etherpup *)(bp1->rptr);
        !            92:        hp->type = htons(ETHERPUP_IPTYPE);
        !            93:        bcopy((caddr_t)(ap->enaddr), (caddr_t)(hp->dhost), 6);
        !            94:        return(bp1);
        !            95: }
        !            96: 
        !            97: arp_request(q, dst)
        !            98: register struct queue *q;
        !            99: unsigned long dst;
        !           100: {
        !           101:        struct block *bp;
        !           102: 
        !           103:        if(q->next->flag & QFULL){
        !           104:                printf("arp q full\n");
        !           105:                return;
        !           106:        }
        !           107:        bp = allocb(4);
        !           108:        if(bp == 0)
        !           109:                return;
        !           110:        bp->type = M_DATA;
        !           111:        bp->wptr = bp->rptr + 4;
        !           112:        bp->class |= S_DELIM;
        !           113:        *((u_long *)(bp->rptr)) = dst;
        !           114:        (*q->next->qinfo->putp)(q->next, bp);
        !           115: }

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