#include <xinu.h>

Include dependency graph for arp.c:

Functions
int32	arp_alloc ()

void	arp_hton (struct arppacket *pktptr)

void	arp_in (struct arppacket *pktptr)

void	arp_init (void)

void	arp_ntoh (struct arppacket *pktptr)

status	arp_resolve (uint32 nxthop, byte mac[ETH_ADDR_LEN])

Variables
struct arpentry	arpcache [ARP_SIZ]
	ARPキャッシュエントリテーブル More...

Function Documentation

◆ arp_alloc()

int32 arp_alloc ( void )

Definition at line 298 of file arp.c.

References AR_FREE, AR_RESOLVED, ARP_SIZ, arpcache, arpentry::arstate, kprintf(), memset(), NULLCH, and SYSERR.

Referenced by arp_in(), and arp_resolve().

 {
     int32   slot;           /* Slot in ARP cache        */
 
     /* Search for a free slot */
 
     for (slot=0; slot < ARP_SIZ; slot++) {
         if (arpcache[slot].arstate == AR_FREE) {
             memset((char *)&arpcache[slot],
                     NULLCH, sizeof(struct arpentry));
             return slot;
         }
     }
 
     /* Search for a resolved entry */
 
     for (slot=0; slot < ARP_SIZ; slot++) {
         if (arpcache[slot].arstate == AR_RESOLVED) {
             memset((char *)&arpcache[slot],
                     NULLCH, sizeof(struct arpentry));
             return slot;
         }
     }
 
     /* At this point, all slots are pending (should not happen) */
 
     kprintf("ARP cache size exceeded\n");
 
     return SYSERR;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ arp_hton()

void arp_hton ( struct arppacket * pktptr )

Definition at line 348 of file arp.c.

References arppacket::arp_htype, arppacket::arp_op, arppacket::arp_ptype, arppacket::arp_sndpa, arppacket::arp_tarpa, htonl, and htons.

Referenced by arp_in(), and arp_resolve().

 {
     pktptr->arp_htype = htons(pktptr->arp_htype);
     pktptr->arp_ptype = htons(pktptr->arp_ptype);
     pktptr->arp_op    = htons(pktptr->arp_op);
     pktptr->arp_sndpa = htonl(pktptr->arp_sndpa);
     pktptr->arp_tarpa = htonl(pktptr->arp_tarpa);
 }

Here is the caller graph for this function:

◆ arp_in()

void arp_in ( struct arppacket * pktptr )

Definition at line 158 of file arp.c.

References AR_FREE, AR_PENDING, AR_RESOLVED, arpentry::arhaddr, arp_alloc(), arppacket::arp_ethdst, arppacket::arp_ethsrc, arppacket::arp_ethtype, ARP_HALEN, arppacket::arp_hlen, arp_hton(), ARP_HTYPE, arppacket::arp_htype, arp_ntoh(), arppacket::arp_op, ARP_OP_RPLY, ARP_PALEN, arppacket::arp_plen, ARP_PTYPE, arppacket::arp_ptype, ARP_SIZ, arppacket::arp_sndha, arppacket::arp_sndpa, arppacket::arp_tarha, arppacket::arp_tarpa, arpentry::arpaddr, arpcache, arpentry::arpid, arpentry::arstate, disable(), ETH_ARP, eth_hton(), ETHER0, network::ethucast, FALSE, freebuf(), network::ipucast, network::ipvalid, kprintf(), memcpy(), NetData, OK, restore(), send(), SYSERR, TRUE, and write().

Referenced by netin().

 {
     intmask mask;           /* Saved interrupt mask     */
     struct  arppacket apkt;     /* Local packet buffer      */
     int32   slot;           /* Slot in cache        */
     struct  arpentry  *arptr;   /* Ptr to ARP cache entry   */
     bool8   found;          /* Is the sender's address in   */
                     /*   the cache?         */
 
     /* Convert packet from network order to host order */
 
     arp_ntoh(pktptr);
 
     /* Verify ARP is for IPv4 and Ethernet */
 
     if ( (pktptr->arp_htype != ARP_HTYPE) ||
          (pktptr->arp_ptype != ARP_PTYPE) ) {
         freebuf((char *)pktptr);
         return;
     }
 
     /* Ensure only one process uses ARP at a time */
 
     mask = disable();
 
     /* Search cache for sender's IP address */
 
     found = FALSE;
 
     for (slot=0; slot < ARP_SIZ; slot++) {
         arptr = &arpcache[slot];
 
         /* Skip table entries that are unused */
 
         if (arptr->arstate == AR_FREE) {
             continue;
         }
 
         /* If sender's address matches, we've found it */
 
         if (arptr->arpaddr == pktptr->arp_sndpa) {
             found = TRUE;
             break;
         }
     }
 
     if (found) {
 
         /* Update sender's hardware address */
 
         memcpy(arptr->arhaddr, pktptr->arp_sndha, ARP_HALEN);
 
         /* If a process was waiting, inform the process */
 
         if (arptr->arstate == AR_PENDING) {
             /* Mark resolved and notify waiting process */
             arptr->arstate = AR_RESOLVED;
             send(arptr->arpid, OK);
         }
     }
 
     /* For an ARP reply, processing is complete */
 
     if (pktptr->arp_op == ARP_OP_RPLY) {
         freebuf((char *)pktptr);
         restore(mask);
         return;
     }
 
     /* The following is for an ARP request packet: if the local */
     /*  machine is not the target or the local IP address is not    */
     /*  yet known, ignore the request (i.e., processing is complete)*/
 
     if ((!NetData.ipvalid) ||
             (pktptr->arp_tarpa != NetData.ipucast)) {
         freebuf((char *)pktptr);
         restore(mask);
         return;
     }
 
     /* Request has been sent to the local machine's address.  So,   */
     /*   add sender's info to cache, if not already present     */
 
     if (!found) {
         slot = arp_alloc();
         if (slot == SYSERR) {   /* Cache is full */
             kprintf("ARP cache overflow on interface\n");
             freebuf((char *)pktptr);
             restore(mask);
             return;
         }
         arptr = &arpcache[slot];
         arptr->arpaddr = pktptr->arp_sndpa;
         memcpy(arptr->arhaddr, pktptr->arp_sndha, ARP_HALEN);
         arptr->arstate = AR_RESOLVED;
     }
 
     /* Hand-craft an ARP reply packet and send back to requester    */
 
     memcpy(apkt.arp_ethdst, pktptr->arp_sndha, ARP_HALEN);
     memcpy(apkt.arp_ethsrc, NetData.ethucast, ARP_HALEN);
     apkt.arp_ethtype= ETH_ARP;      /* Frame carries ARP    */
     apkt.arp_htype  = ARP_HTYPE;        /* Hardware is Ethernet */
     apkt.arp_ptype  = ARP_PTYPE;        /* Protocol is IP   */
     apkt.arp_hlen   = ARP_HALEN;        /* Ethernet address size*/
     apkt.arp_plen   = ARP_PALEN;        /* IP address size  */
     apkt.arp_op = ARP_OP_RPLY;      /* Type is Reply    */
 
     /* Insert local Ethernet and IP address in sender fields    */
 
     memcpy(apkt.arp_sndha, NetData.ethucast, ARP_HALEN);
     apkt.arp_sndpa = NetData.ipucast;
 
     /* Copy target Ethernet and IP addresses from request packet */
 
     memcpy(apkt.arp_tarha, pktptr->arp_sndha, ARP_HALEN);
     apkt.arp_tarpa = pktptr->arp_sndpa;
 
     /* Convert ARP packet from host to network byte order */
 
     arp_hton(&apkt);
 
     /* Convert the Ethernet header to network byte order */
 
     eth_hton((struct netpacket *)&apkt);
 
     /* Send the reply */
 
     write(ETHER0, (char *)&apkt, sizeof(struct arppacket));
     freebuf((char *)pktptr);
     restore(mask);
     return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ arp_init()

void arp_init ( void )

Definition at line 11 of file arp.c.

References AR_FREE, ARP_SIZ, arpcache, and arpentry::arstate.

Referenced by net_init().

 {
     int32   i;          /* ARP cache index      */
 
     for (i=1; i<ARP_SIZ; i++) { /* Initialize cache to empty    */
         arpcache[i].arstate = AR_FREE;
     }
 }

Here is the caller graph for this function:

◆ arp_ntoh()

void arp_ntoh ( struct arppacket * pktptr )

Definition at line 333 of file arp.c.

References arppacket::arp_htype, arppacket::arp_op, arppacket::arp_ptype, arppacket::arp_sndpa, arppacket::arp_tarpa, ntohl, and ntohs.

Referenced by arp_in().

 {
     pktptr->arp_htype = ntohs(pktptr->arp_htype);
     pktptr->arp_ptype = ntohs(pktptr->arp_ptype);
     pktptr->arp_op    = ntohs(pktptr->arp_op);
     pktptr->arp_sndpa = ntohl(pktptr->arp_sndpa);
     pktptr->arp_tarpa = ntohl(pktptr->arp_tarpa);
 }

Here is the caller graph for this function:

◆ arp_resolve()

status arp_resolve	(	uint32	nxthop,
		byte	mac[ETH_ADDR_LEN]
	)

Definition at line 24 of file arp.c.

References AR_FREE, AR_PENDING, AR_RESOLVED, arpentry::arhaddr, arp_alloc(), arppacket::arp_ethdst, arppacket::arp_ethsrc, arppacket::arp_ethtype, ARP_HALEN, arppacket::arp_hlen, arp_hton(), ARP_HTYPE, arppacket::arp_htype, arppacket::arp_op, ARP_OP_REQ, ARP_PALEN, arppacket::arp_plen, ARP_PTYPE, arppacket::arp_ptype, ARP_RETRY, ARP_SIZ, arppacket::arp_sndha, arppacket::arp_sndpa, arppacket::arp_tarha, arppacket::arp_tarpa, ARP_TIMEOUT, arpentry::arpaddr, arpcache, arpentry::arpid, arpentry::arstate, currpid, disable(), ETH_ARP, eth_hton(), network::ethbcast, ETHER0, network::ethucast, IP_BCAST, network::ipbcast, network::ipucast, memcpy(), memset(), NetData, OK, recvclr(), recvtime(), restore(), SYSERR, TIMEOUT, and write().

 {
     intmask mask;           /* Saved interrupt mask     */
     struct  arppacket apkt;     /* Local packet buffer      */
     int32   i;          /* Index into arpcache      */
     int32   slot;           /* ARP table slot to use    */
     struct  arpentry  *arptr;   /* Ptr to ARP cache entry   */
     int32   msg;            /* Message returned by recvtime */
 
     /* Use MAC broadcast address for IP limited broadcast */
 
     if (nxthop == IP_BCAST) {
         memcpy(mac, NetData.ethbcast, ETH_ADDR_LEN);
         return OK;
     }
 
     /* Use MAC broadcast address for IP network broadcast */
 
     if (nxthop == NetData.ipbcast) {
         memcpy(mac, NetData.ethbcast, ETH_ADDR_LEN);
         return OK;
     }
 
     /* Ensure only one process uses ARP at a time */
 
     mask = disable();
 
     /* See if next hop address is already present in ARP cache */
 
     for (i=0; i<ARP_SIZ; i++) {
         arptr = &arpcache[i];
         if (arptr->arstate == AR_FREE) {
             continue;
         }
         if (arptr->arpaddr == nxthop) { /* Adddress is in cache */
             break;
         }
     }
 
     if (i < ARP_SIZ) {  /* Entry was found */
 
         /* If entry is resolved - handle and return */
 
         if (arptr->arstate == AR_RESOLVED) {
             memcpy(mac, arptr->arhaddr, ARP_HALEN);
             restore(mask);
             return OK;
         }
 
         /* Entry is already pending -  return error because */
         /*  only one process can be waiting at a time   */
 
         if (arptr->arstate == AR_PENDING) {
             restore(mask);
             return SYSERR;
         }
     }
 
     /* IP address not in cache -  allocate a new cache entry and    */
     /*  send an ARP request to obtain the answer        */
 
     slot = arp_alloc();
     if (slot == SYSERR) {
         restore(mask);
         return SYSERR;
     }
 
     arptr = &arpcache[slot];
     arptr->arstate = AR_PENDING;
     arptr->arpaddr = nxthop;
     arptr->arpid = currpid;
 
     /* Hand-craft an ARP Request packet */
 
     memcpy(apkt.arp_ethdst, NetData.ethbcast, ETH_ADDR_LEN);
     memcpy(apkt.arp_ethsrc, NetData.ethucast, ETH_ADDR_LEN);
     apkt.arp_ethtype = ETH_ARP;   /* Packet type is ARP     */
     apkt.arp_htype = ARP_HTYPE;   /* Hardware type is Ethernet  */
     apkt.arp_ptype = ARP_PTYPE;   /* Protocol type is IP    */
     apkt.arp_hlen = 0xff & ARP_HALEN; /* Ethernet MAC size in bytes */
     apkt.arp_plen = 0xff & ARP_PALEN; /* IP address size in bytes   */
     apkt.arp_op = 0xffff & ARP_OP_REQ;/* ARP type is Request    */
     memcpy(apkt.arp_sndha, NetData.ethucast, ARP_HALEN);
     apkt.arp_sndpa = NetData.ipucast; /* IP address of interface    */
     memset(apkt.arp_tarha, '\0', ARP_HALEN); /* Target HA is unknown*/
     apkt.arp_tarpa = nxthop;      /* Target protocol address    */
 
     /* Convert ARP packet from host to net byte order */
 
     arp_hton(&apkt);
 
     /* Convert Ethernet header from host to net byte order */
 
     eth_hton((struct netpacket *)&apkt);
 
     /* Send the packet ARP_RETRY times and await response */
 
     msg = recvclr();
     for (i=0; i<ARP_RETRY; i++) {
         write(ETHER0, (char *)&apkt, sizeof(struct arppacket));
         msg = recvtime(ARP_TIMEOUT);
         if (msg == TIMEOUT) {
             continue;
         } else if (msg == SYSERR) {
             restore(mask);
             return SYSERR;
         } else {    /* entry is resolved */
             break;
         }
     }
 
     /* If no response, return TIMEOUT */
 
     if (msg == TIMEOUT) {
         arptr->arstate = AR_FREE;   /* Invalidate cache entry */
         restore(mask);
         return TIMEOUT;
     }
 
     /* Return hardware address */
 
     memcpy(mac, arptr->arhaddr, ARP_HALEN);
     restore(mask);
     return OK;
 }