/************************************************************
 * File name	: Arp.c										*
 * By 			: hugang, hgx2000@mail.china.com			*
 ************************************************************/

#include "armnet.h"
#include "..\inc\44blib.h"
#include <string.h>

extern NODE locnode;

static ARP_ENTRY arp_entrys;
static ARP_ENTRY arp_cache[ARP_CACHE_SIZE];
static int arp_chche_cur = 0;


/*******************************************************************************************************/
int ArpInit(void)
{
	memset(&arp_entrys, 0, sizeof(ARP_ENTRY));
	memset(arp_cache, 0, sizeof(ARP_ENTRY) * ARP_CACHE_SIZE);

	return 0;
}


/*******************************************************************************************************/
int ArpAddEntry(unsigned int ip, unsigned char *mac)
{
	memcpy(arp_entrys.mac, mac, MACLEN);
	arp_entrys.ip = swapl(ip);

	return 0;
}


/*******************************************************************************************************/
int ArpAddCache( unsigned int ip, unsigned char *mac)
{
	int i;

	for (i = 0; i < ARP_CACHE_SIZE; i++) {
		if (ip == arp_cache[i].ip)
			break;
	}

	if (i == ARP_CACHE_SIZE) {
		i = arp_chche_cur;
		arp_chche_cur = (arp_chche_cur + 1) % ARP_CACHE_SIZE;
	}

	memcpy(arp_cache[i].mac, mac, MACLEN);
	arp_cache[i].ip = ip;

	return 0;
}


/*******************************************************************************************************/
int ArpFindCache(unsigned int ip, unsigned char *mac)
{
	int i;

	for (i = 0; i < ARP_CACHE_SIZE; i++) {
		if (ip == arp_cache[i].ip) {
			memcpy(mac, arp_cache[i].mac, MACLEN);
			break;
		}
	}

	if (i == ARP_CACHE_SIZE) {
		return -1;
	}

	return 0;
}


/*******************************************************************************************************/
int ArpSendReq(ETHERFRAME *efp, NODE *destp)
{
	NODE  tmpnode;
	short txlen;

	tmpnode.ip = destp->ip;
	memset(tmpnode.mac, 0xff, MACLEN);

	txlen = MakeArp(efp, &locnode, &tmpnode, ARPREQ);
	PutEthernet(efp, txlen); 

	return 0;
}


/********************************************************************************************************
 * Check ARP packet, swap bytes, return -1, 0 if not ARP												*
 ********************************************************************************************************/
short IsArp(ETHERFRAME *efp, short len)
{
    ARPKT *arp;
    short dlen=0;

    if (efp->e.ptype==PCOL_ARP && len>=sizeof(ARPKT))
    {                                   	/* If protocol OK.. */
    	SwapArp(efp);
        arp = (ARPKT *)(efp->edata);
        if (arp->hrd==HTYPE && arp->pro==ARPPRO)
            dlen = -1;                  	/* Return non-zero if OK */
        else
            dlen = 0;    
    }
    return(dlen);
}


/********************************************************************************************************
 * Make an ARP packet, return its total length 															*
 ********************************************************************************************************/
short MakeArp(ETHERFRAME *efp, NODE *srcep, NODE *destp, unsigned short codetype)
{
	unsigned char i;
	
    ARPKT *arp;
    arp = (ARPKT *)(efp->edata);
    for(i=0;i<MACLEN;i++)
    {
    	arp->smac[i] = srcep->mac[i];  				// Srce ARP ether addr
    	arp->dmac[i] = destp->mac[i];  				// Dest ARP ether addr
    }
    arp->hrd = HTYPE;  			          			// Hware & protocol types
    arp->pro = ARPPRO;	
    arp->hln = MACLEN;                  			// Hardware addr len
    arp->pln = sizeof(unsigned int);          		// IP addr len 
    arp->op  = codetype;	                    	// ARP opcode 
    arp->dip = GateIp(destp, srcep);		   		// Dest ip addr (maybe gateway) 
    arp->sip = srcep->ip; 		              		// Source IP addr 
    SwapArp(efp);

   	return(MakeFrame(efp,srcep->mac,destp->mac, PCOL_ARP, sizeof(ARPKT)));
}


/********************************************************************************************************
 * Swap byte order of ints in ARP header 																*
 ********************************************************************************************************/
void SwapArp(ETHERFRAME *efp)
{
    ARPKT *arp;
    unsigned char *p_dip, *p_sip;
	unsigned int i_dip, i_sip;
    
    arp = (ARPKT *)(efp->edata);
    p_sip = (unsigned char *)&arp->sip;
    p_dip = (unsigned char *)&arp->dip;
    i_sip = p_sip[3] + ((unsigned int)p_sip[2]<<8) + ((unsigned int)p_sip[1]<<16) + ((unsigned int)p_sip[0]<<24);
    i_dip = p_dip[3] + ((unsigned int)p_dip[2]<<8) + ((unsigned int)p_dip[1]<<16) + ((unsigned int)p_dip[0]<<24);

    arp->hrd = swapw(arp->hrd);
    arp->pro = swapw(arp->pro);
    arp->op  = swapw(arp->op);
    arp->sip = READ_PACKED(i_sip);
    arp->dip = READ_PACKED(i_dip);
}


/********************************************************************************************************
 * ARP handle							 																*
 ********************************************************************************************************/
void ArpRcvPacket(ETHERFRAME *efp)
{
    ARPKT *arp;
	NODE  tmpnode;
	short txlen;

	arp = (ARPKT *)(efp->edata);

	tmpnode.ip = READ_PACKED(arp->sip);                 /* Make ARP response */
    memcpy(tmpnode.mac, (unsigned char *)arp->smac, MACLEN);
	DEBUGF(ARP_DEBUG, ("add %x to arp cache\n", tmpnode.ip));
	ArpAddCache(tmpnode.ip, tmpnode.mac);

	if(arp->op==ARPREQ)
	{
	    txlen = MakeArp(efp, &locnode, &tmpnode, ARPRESP);
    	DEBUGF(ARP_DEBUG,("Put ARP REPLY\n"));
    	PutEthernet(efp, txlen);              /* Send packet */
	}
}