Return to ip_arp.c CVS log

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

Annotation of researchv8dc/sys/inet/ip_arp.c, revision 1.1.1.1

1.1       root        1: #include "inet.h"
                      2: #include "uarp.h"
                      3: #if NUARP > 0 && NINET > 0
                      4: 
                      5: #include "../h/param.h"
                      6: #include "../h/systm.h"
                      7: #include "../h/stream.h"
                      8: #include "../h/conf.h"
                      9: #include "../h/ioctl.h"
                     10: #include "../h/ethernet.h"
                     11: #include "../h/inet/in.h"
                     12: #include "../h/inet/ip_var.h"
                     13: 
                     14: /*
                     15:  * Address resolution code. ip_ldout() calls arp_resolve if IFF_ARP
                     16:  * is set to map an internet address into a 48 bit ethernet address.
                     17:  * If arp_resolve finds the address in its tables, it prepends an
                     18:  * ethernet header to the packet and returns it. Otherwise, it sends
                     19:  * a message to the ipconfig waiting on the specified queue asking
                     20:  * it to do all the hard work. The user process at some point will use
                     21:  * the IPIORESOLVE ioctl to update the tabes.
                     22:  */
                     23: 
                     24: /* temporary. soon to be hashed. */
                     25: #define NARP 50
                     26: struct ip_arp ip_arps[NARP];   /* this table should never have holes in it */
                     27: 
                     28: int Nip_arp = NARP;    /* number of address translations for netstat */
                     29: 
                     30: arp_install(in, en)
                     31: unsigned long in;
                     32: unsigned char *en;
                     33: {
                     34:        register struct ip_arp *ap;
                     35: 
                     36:        for(ap = &ip_arps[0]; ap < &ip_arps[NARP]; ap++){
                     37:                if(ap->inaddr == in)
                     38:                        break;
                     39:                if(ap->inaddr == 0)
                     40:                        break;
                     41:        }
                     42:        if(ap >= &ip_arps[NARP])
                     43:                return(1);
                     44:        ap->inaddr = in;
                     45:        bcopy((caddr_t)en, (caddr_t)(ap->enaddr), 6);
                     46:        return(0);
                     47: }
                     48: 
                     49: struct block *
                     50: arp_resolve(q, bp, dst)
                     51: struct queue *q;
                     52: register struct block *bp;
                     53: unsigned long dst;
                     54: {
                     55:        register struct ip_arp *ap;
                     56:        register struct block *bp1;
                     57:        struct ether_in *hp;
                     58: 
                     59:        for(ap = &ip_arps[0]; ap < &ip_arps[NARP]; ap++)
                     60:                if(ap->inaddr == dst || ap->inaddr == 0)
                     61:                        break;
                     62:        if(ap->inaddr == 0 || ap >= &ip_arps[NARP]){
                     63:                arp_request(q, dst);
                     64:                bp_free(bp);
                     65:                return(0);
                     66:        }
                     67:        bp1 = allocb(sizeof(struct ether_in));
                     68:        if(bp1 == 0){
                     69:                printf("no bp for arp_resolve\n");
                     70:                bp_free(bp);
                     71:                return(0);
                     72:        }
                     73:        bp1->type = M_DATA;
                     74:        bp1->wptr = bp1->rptr + sizeof(struct ether_in);
                     75:        bp1->next = bp;
                     76:        hp = (struct ether_in *)(bp1->rptr);
                     77:        hp->type = htons(ETHERPUP_IPTYPE);
                     78:        bcopy((caddr_t)(ap->enaddr), (caddr_t)(hp->dhost), 6);
                     79:        return(bp1);
                     80: }
                     81: 
                     82: arp_request(q, dst)
                     83: register struct queue *q;
                     84: unsigned long dst;
                     85: {
                     86:        struct block *bp;
                     87: 
                     88:        if(q->next->flag & QFULL){
                     89:                printf("arp q full\n");
                     90:                return;
                     91:        }
                     92:        bp = allocb(4);
                     93:        if(bp == 0)
                     94:                return;
                     95:        bp->type = M_DATA;
                     96:        bp->wptr = bp->rptr + 4;
                     97:        *((u_long *)(bp->rptr)) = dst;
                     98:        (*q->next->qinfo->putp)(q->next, bp);
                     99:        bp = allocb(1);
                    100:        if(bp == 0)
                    101:                return;
                    102:        bp->type = M_DELIM;
                    103:        (*q->next->qinfo->putp)(q->next, bp);
                    104: }
                    105: #endif NUARP

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