clean up old IOS handles on startup (dhewg)

[libogc.git] / libdb / uIP / uip_arp.c

/**
 * \addtogroup uip
 * @{
 */

/**
 * \defgroup uiparp uIP Address Resolution Protocol
 * @{
 * 
 * The Address Resolution Protocol ARP is used for mapping between IP
 * addresses and link level addresses such as the Ethernet MAC
 * addresses. ARP uses broadcast queries to ask for the link level
 * address of a known IP address and the host which is configured with
 * the IP address for which the query was meant, will respond with its
 * link level address.
 *
 * \note This ARP implementation only supports Ethernet.
 */
 
/**
 * \file
 * Implementation of the ARP Address Resolution Protocol.
 * \author Adam Dunkels <adam@dunkels.com>
 *
 */

/*
 * Copyright (c) 2001-2003, Adam Dunkels.
 * All rights reserved. 
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 * 1. Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer. 
 * 2. Redistributions in binary form must reproduce the above copyright 
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the distribution. 
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.  
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
 *
 * This file is part of the uIP TCP/IP stack.
 *
 *
 */


#include "uip_pbuf.h"
#include "uip_netif.h"
#include "uip_arp.h"

#include <string.h>

#if UIP_LOGGING == 1
#include <stdio.h>
#define UIP_LOG(m) uip_log(__FILE__,__LINE__,m)
#else
#define UIP_LOG(m)
#endif /* UIP_LOGGING == 1 */

#if UIP_STATISTICS == 1
struct uip_stats uip_stat;
#define UIP_STAT(s) s
#else
#define UIP_STAT(s)
#endif /* UIP_STATISTICS == 1 */


#define ARP_TRY_HARD 0x01

#define ARP_MAXAGE 240
#define ARP_MAXPENDING 2

#define ARP_REQUEST 1
#define ARP_REPLY   2

#define ARP_HWTYPE_ETH 1

#define ARPH_HWLEN(hdr) (ntohs((hdr)->_hwlen_protolen) >> 8)
#define ARPH_PROTOLEN(hdr) (ntohs((hdr)->_hwlen_protolen) & 0xff)

#define ARPH_HWLEN_SET(hdr, len) (hdr)->_hwlen_protolen = htons(ARPH_PROTOLEN(hdr) | ((len) << 8))
#define ARPH_PROTOLEN_SET(hdr, len) (hdr)->_hwlen_protolen = htons((len) | (ARPH_HWLEN(hdr) << 8))

enum arp_state {
        ARP_STATE_EMPTY,
        ARP_STATE_PENDING,
        ARP_STATE_STABLE,
        ARP_STATE_EXPIRED
};

struct arp_entry {
  struct uip_ip_addr ipaddr;
  struct uip_eth_addr ethaddr;
  enum arp_state state;
  u8_t time;
};

static const struct uip_eth_addr ethbroadcast = {{0xff,0xff,0xff,0xff,0xff,0xff}};
static struct arp_entry arp_table[UIP_ARPTAB_SIZE];
/*-----------------------------------------------------------------------------------*/
/**
 * Initialize the ARP module.
 *
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_init(void)
{
        s32_t i;
        for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
                arp_table[i].state = ARP_STATE_EMPTY;
                arp_table[i].time = 0;
        }
}
/*-----------------------------------------------------------------------------------*/
/**
 * Periodic ARP processing function.
 *
 * This function performs periodic timer processing in the ARP module
 * and should be called at regular intervals. The recommended interval
 * is 10 seconds between the calls.
 *
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_timer(void)
{
        u8_t i;

        for(i=0;i<UIP_ARPTAB_SIZE;i++) {
                arp_table[i].time++;
                if(arp_table[i].state==ARP_STATE_STABLE && arp_table[i].time>=ARP_MAXAGE) {
                        arp_table[i].state = ARP_STATE_EXPIRED;
                } else if(arp_table[i].state==ARP_STATE_PENDING) {
                        if(arp_table[i].time>=ARP_MAXPENDING) arp_table[i].state = ARP_STATE_EXPIRED;
                }

                if(arp_table[i].state==ARP_STATE_EXPIRED) arp_table[i].state = ARP_STATE_EMPTY;
        }
}

static s8_t uip_arp_findentry(struct uip_ip_addr *ipaddr,u8_t flags)
{
        s8_t old_pending = UIP_ARPTAB_SIZE, old_stable = UIP_ARPTAB_SIZE;
        s8_t empty = UIP_ARPTAB_SIZE;
        u8_t i = 0,age_pending = 0,age_stable = 0;

        /* Walk through the ARP mapping table and try to find an entry to
           update. If none is found, the IP -> MAC address mapping is
           inserted in the ARP table. */
        for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
                if(empty==UIP_ARPTAB_SIZE && arp_table[i].state==ARP_STATE_EMPTY) {
                        empty = i;
                } else if(arp_table[i].state==ARP_STATE_PENDING) {
                        if(ipaddr && ip_addr_cmp(ipaddr,&arp_table[i].ipaddr)) return i;
                        else if(arp_table[i].time>=age_pending) {
                                old_pending = i;
                                age_pending = arp_table[i].time;
                        }
                } else if(arp_table[i].state==ARP_STATE_STABLE) {
                        if(ipaddr && ip_addr_cmp(ipaddr,&arp_table[i].ipaddr)) return i;
                        else if(arp_table[i].time>=age_stable) {
                                old_stable = i;
                                age_stable = arp_table[i].time;
                        }
                }
        }
        if(empty==UIP_ARPTAB_SIZE && !(flags&ARP_TRY_HARD)) return UIP_ERR_MEM;
        
        if(empty<UIP_ARPTAB_SIZE) i = empty;
        else if(old_stable<UIP_ARPTAB_SIZE) i = old_stable;
        else if(old_pending<UIP_ARPTAB_SIZE) i = old_pending;
        else return UIP_ERR_MEM;

        arp_table[i].time = 0;
        arp_table[i].state = ARP_STATE_EMPTY;
        if(ipaddr!=NULL) ip_addr_set(&arp_table[i].ipaddr,ipaddr);
        
        return (s8_t)i;
}

/*-----------------------------------------------------------------------------------*/
static s8_t uip_arp_update(struct uip_netif *netif,struct uip_ip_addr *ipaddr, struct uip_eth_addr *ethaddr,u8_t flags)
{
        s8_t i,k;

        if(ip_addr_isany(ipaddr) ||
                ip_addr_isbroadcast(ipaddr,netif) ||
                ip_addr_ismulticast(ipaddr)) return UIP_ERR_ARG;

        i = uip_arp_findentry(ipaddr,flags);
        if(i<0) return i;

        arp_table[i].time = 0;
        arp_table[i].state = ARP_STATE_STABLE;
        for(k=0;k<netif->hwaddr_len;k++) arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];

        return UIP_ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
/**
 * ARP processing for incoming IP packets
 *
 * This function should be called by the device driver when an IP
 * packet has been received. The function will check if the address is
 * in the ARP cache, and if so the ARP cache entry will be
 * refreshed. If no ARP cache entry was found, a new one is created.
 *
 * This function expects an IP packet with a prepended Ethernet header
 * in the uip_buf[] buffer, and the length of the packet in the global
 * variable uip_len.
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_ipin(struct uip_netif *netif,struct uip_pbuf *p)
{
        struct uip_ethip_hdr *hdr;

        hdr = p->payload;
        if(!ip_addr_netcmp(&hdr->ip.src,&netif->ip_addr,&netif->netmask)) return;
        
        uip_arp_update(netif,&hdr->ip.src,&hdr->ethhdr.src,0);
 }

/*-----------------------------------------------------------------------------------*/
/**
 * ARP processing for incoming ARP packets.
 *
 * This function should be called by the device driver when an ARP
 * packet has been received. The function will act differently
 * depending on the ARP packet type: if it is a reply for a request
 * that we previously sent out, the ARP cache will be filled in with
 * the values from the ARP reply. If the incoming ARP packet is an ARP
 * request for our IP address, an ARP reply packet is created and put
 * into the uip_buf[] buffer.
 *
 * When the function returns, the value of the global variable uip_len
 * indicates whether the device driver should send out a packet or
 * not. If uip_len is zero, no packet should be sent. If uip_len is
 * non-zero, it contains the length of the outbound packet that is
 * present in the uip_buf[] buffer.
 *
 * This function expects an ARP packet with a prepended Ethernet
 * header in the uip_buf[] buffer, and the length of the packet in the
 * global variable uip_len.
 */
/*-----------------------------------------------------------------------------------*/
void
uip_arp_arpin(struct uip_netif *netif,struct uip_eth_addr *ethaddr,struct uip_pbuf *p)
{
        u8_t i,for_us;
        struct uip_ip_addr sipaddr,dipaddr;
        struct uip_arp_hdr *hdr;

        if(p->tot_len<sizeof(struct uip_arp_hdr)) {
                uip_pbuf_free(p);
                return;
        }
        
        hdr = p->payload;
        
        *(struct uip_ip_addr2*)((void*)&sipaddr) = hdr->sipaddr;
        *(struct uip_ip_addr2*)((void*)&dipaddr) = hdr->dipaddr;
        
        if(netif->ip_addr.addr==0) for_us = 0;
        else for_us = ip_addr_cmp(&dipaddr,&netif->ip_addr);

        if(for_us) uip_arp_update(netif,&sipaddr,&hdr->shwaddr,ARP_TRY_HARD);
        else uip_arp_update(netif,&sipaddr,&hdr->shwaddr,0);

        switch(htons(hdr->opcode)) {
                case ARP_REQUEST:
                        if(for_us) {
                                hdr->opcode = htons(ARP_REPLY);
                                hdr->dipaddr = hdr->sipaddr;
                                hdr->sipaddr = *(struct uip_ip_addr2*)((void*)&netif->ip_addr);
                                
                                for(i=0;i<netif->hwaddr_len;i++) {
                                        hdr->dhwaddr.addr[i] = hdr->shwaddr.addr[i];
                                        hdr->shwaddr.addr[i] = ethaddr->addr[i];
                                        hdr->ethhdr.dest.addr[i] = hdr->dhwaddr.addr[i];
                                        hdr->ethhdr.src.addr[i] = ethaddr->addr[i];
                                }
                                
                                hdr->hwtype = htons(ARP_HWTYPE_ETH);
                                ARPH_HWLEN_SET(hdr,netif->hwaddr_len);

                                hdr->protocol = htons(UIP_ETHTYPE_IP);
                                ARPH_PROTOLEN_SET(hdr,sizeof(struct uip_ip_addr));

                                netif->linkoutput(netif,p);
                        } else {
                                UIP_LOG("uip_arp_arpin: ip packet not for us.\n");
                        }
                        break;
                case ARP_REPLY:
                        break;
                default:
                        UIP_LOG("uip_arp_arpin: ARP unknown opcode type.\n");
                        break;
        }
        uip_pbuf_free(p);
}
/*-----------------------------------------------------------------------------------*/
/**
 * Prepend Ethernet header to an outbound IP packet and see if we need
 * to send out an ARP request.
 *
 * This function should be called before sending out an IP packet. The
 * function checks the destination IP address of the IP packet to see
 * what Ethernet MAC address that should be used as a destination MAC
 * address on the Ethernet.
 *
 * If the destination IP address is in the local network (determined
 * by logical ANDing of netmask and our IP address), the function
 * checks the ARP cache to see if an entry for the destination IP
 * address is found. If so, an Ethernet header is prepended and the
 * function returns. If no ARP cache entry is found for the
 * destination IP address, the packet in the uip_buf[] is replaced by
 * an ARP request packet for the IP address. The IP packet is dropped
 * and it is assumed that they higher level protocols (e.g., TCP)
 * eventually will retransmit the dropped packet.
 *
 * If the destination IP address is not on the local network, the IP
 * address of the default router is used instead.
 *
 * When the function returns, a packet is present in the uip_buf[]
 * buffer, and the length of the packet is in the global variable
 * uip_len.
 */
/*-----------------------------------------------------------------------------------*/
s8_t uip_arp_out(struct uip_netif *netif,struct uip_ip_addr *ipaddr,struct uip_pbuf *q)
{
        u8_t i;
        struct uip_eth_addr *dest,*srcaddr,mcastaddr;
        struct uip_eth_hdr *ethhdr;

        if(uip_pbuf_header(q,sizeof(struct uip_eth_hdr))!=0) {
                UIP_LOG("uip_arp_out: could not allocate room for header.\n");
                return UIP_ERR_BUF;
        }

        dest = NULL;
        if(ip_addr_isbroadcast(ipaddr,netif)) {
                dest = (struct uip_eth_addr*)&ethbroadcast;
        } else if(ip_addr_ismulticast(ipaddr)) {
                /* Hash IP multicast address to MAC address.*/
                mcastaddr.addr[0] = 0x01;
                mcastaddr.addr[1] = 0x00;
                mcastaddr.addr[2] = 0x5e;
                mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f;
                mcastaddr.addr[4] = ip4_addr3(ipaddr);
                mcastaddr.addr[5] = ip4_addr4(ipaddr);
                /* destination Ethernet address is multicast */
           dest = &mcastaddr;
        } else {
                if(!ip_addr_netcmp(ipaddr,&netif->ip_addr,&netif->netmask)) {
                        if(netif->gw.addr!=0) ipaddr = &netif->gw;
                        else return UIP_ERR_RTE;
                }
                return uip_arp_arpquery(netif,ipaddr,q);
        }

        srcaddr = (struct uip_eth_addr*)netif->hwaddr;
        ethhdr = q->payload;
        for(i=0;i<netif->hwaddr_len;i++) {
                ethhdr->dest.addr[i] = dest->addr[i];
                ethhdr->src.addr[i] = srcaddr->addr[i];
        }

        ethhdr->type = htons(UIP_ETHTYPE_IP);
        return netif->linkoutput(netif,q);
}
/*-----------------------------------------------------------------------------------*/

s8_t uip_arp_arpquery(struct uip_netif *netif,struct uip_ip_addr *ipaddr,struct uip_pbuf *q)
{
        s8_t i,k;
        s8_t err = UIP_ERR_MEM;
        struct uip_eth_addr *srcaddr = (struct uip_eth_addr*)netif->hwaddr;

        if(ip_addr_isbroadcast(ipaddr,netif) || 
                ip_addr_ismulticast(ipaddr) ||
                ip_addr_isany(ipaddr)) return UIP_ERR_ARG;

        i = uip_arp_findentry(ipaddr,ARP_TRY_HARD);
        if(i<0) return i;

        if(arp_table[i].state==ARP_STATE_EMPTY) arp_table[i].state = ARP_STATE_PENDING;
        if(arp_table[i].state==ARP_STATE_PENDING || q==NULL) err = uip_arp_arprequest(netif,ipaddr);

        if(q!=NULL) {
                if(arp_table[i].state==ARP_STATE_STABLE) {
                        
                        struct uip_eth_hdr *hdr = q->payload;
                        for(k=0;k<netif->hwaddr_len;k++) {
                                hdr->dest.addr[k] = arp_table[i].ethaddr.addr[k];
                                hdr->src.addr[k] = srcaddr->addr[k];
                        }

                        hdr->type = htons(UIP_ETHTYPE_IP);
                        err = netif->linkoutput(netif,q);
                } else if(arp_table[i].state==ARP_STATE_PENDING) {
                        UIP_LOG("uip_arp_query: Ethernet destination address unknown, queueing disabled, packet dropped.\n");
                }
        }
        return err;
}

s8_t uip_arp_arprequest(struct uip_netif *netif,struct uip_ip_addr *ipaddr)
{
        s8_t k;
        s8_t err = UIP_ERR_MEM;
        struct uip_arp_hdr *hdr;
        struct uip_pbuf *p;
        struct uip_eth_addr *srcaddr = (struct uip_eth_addr*)netif->hwaddr;

        p = uip_pbuf_alloc(UIP_PBUF_LINK,sizeof(struct uip_arp_hdr),UIP_PBUF_RAM);
        if(p==NULL) return err;

        hdr = p->payload;
        hdr->opcode = htons(ARP_REQUEST);
        
        for(k=0;k<netif->hwaddr_len;k++) {
                hdr->shwaddr.addr[k] = srcaddr->addr[k];
                hdr->dhwaddr.addr[k] = 0;
        }

        hdr->dipaddr = *(struct uip_ip_addr2*)((void*)ipaddr);
        hdr->sipaddr = *(struct uip_ip_addr2*)((void*)&netif->ip_addr);

        hdr->hwtype = htons(ARP_HWTYPE_ETH);
        ARPH_HWLEN_SET(hdr,netif->hwaddr_len);

        hdr->protocol = htons(UIP_ETHTYPE_IP);
        ARPH_PROTOLEN_SET(hdr,sizeof(struct uip_ip_addr));
        for(k=0;k<netif->hwaddr_len;k++) {
                hdr->ethhdr.dest.addr[k] = 0xff;
                hdr->ethhdr.src.addr[k] = srcaddr->addr[k];
        }
        hdr->ethhdr.type = htons(UIP_ETHTYPE_ARP);

        err = netif->linkoutput(netif,p);
        uip_pbuf_free(p);

        return err;
}

/** @} */
/** @} */