ARP.c

Go to the documentation of this file.

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
 /*
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     5/1/01  Original        (Rev 1.0)
 * Nilesh Rajbharti     2/9/02  Cleanup
 * Nilesh Rajbharti     5/22/02 Rev 2.0 (See version.log for detail)
 * Howard Schlunder     8/17/06 Combined ARP.c and ARPTsk.c into ARP.c; 
 *                              rewrote some of it to look more linear
 ********************************************************************/

#define __ARP_C

#include "TCPIP.h"


/****************************************************************************
  Section:
    Constants and Variables
  ***************************************************************************/

// ARP Operation codes.
#define ARP_OPERATION_REQ       0x01u
#define ARP_OPERATION_RESP      0x02u

// ETHERNET packet type as defined by IEEE 802.3
#define HW_ETHERNET             (0x0001u)
#define ARP_IP                  (0x0800u)



// This ARP task caches one ARP response.
static NODE_INFO Cache;


// ARP packet structure
typedef struct __attribute__((aligned(2), packed))
{
    WORD        HardwareType;
    WORD        Protocol;
    BYTE        MACAddrLen;
    BYTE        ProtocolLen;
    WORD        Operation;
    MAC_ADDR    SenderMACAddr;
    IP_ADDR     SenderIPAddr;
    MAC_ADDR    TargetMACAddr;
    IP_ADDR     TargetIPAddr;
} ARP_PACKET;


/****************************************************************************
  Section:
    Helper Function Prototypes
  ***************************************************************************/
static void SwapARPPacket(ARP_PACKET *p);
static BOOL ARPPut(ARP_PACKET *packet);



/****************************************************************************
  Section:
    Function Implementations
  ***************************************************************************/

/*****************************************************************************
  Function:
    static BOOL ARPPut(ARP_PACKET* packet)

  Description:
    Writes an ARP packet to the MAC.

  Precondition:
    None

  Parameters:
    packet - A pointer to an ARP_PACKET structure with correct operation
                and target preconfigured.

  Return Values:
    TRUE - The ARP packet was generated properly
    FALSE - Not a possible return value
  ***************************************************************************/
static BOOL ARPPut(ARP_PACKET *packet)
{
    while(!MACIsTxReady());
    MACSetWritePtr(BASE_TX_ADDR);
    

    packet->HardwareType  = HW_ETHERNET;
    packet->Protocol      = ARP_IP;
    packet->MACAddrLen    = sizeof(MAC_ADDR);
    packet->ProtocolLen   = sizeof(IP_ADDR);
    
    // MODIFIX: Copy the MAC adress from a flash location instead from a RAM 
    // location.
    memcpypgm2ram(&packet->SenderMACAddr, ( ROM void * ) pu8MAC, sizeof(packet->SenderMACAddr));
    // MODIFIX: Take IP from eWicht specific sIPConfig-Structure:
    packet->SenderIPAddr  = sIPConfig.MyIPAddr; 

    SwapARPPacket(packet);

    MACPutHeader(&packet->TargetMACAddr, MAC_ARP, sizeof(*packet));
    MACPutArray((BYTE*)packet, sizeof(*packet));
    MACFlush();
    
    return TRUE;
}


/*****************************************************************************
  Function:
    void ARPInit(void)

  Summary:
    Initializes the ARP module.
    
  Description:
    Initializes the ARP module.  Call this function once at boot to 
    invalidate the cached lookup.

  Precondition:
    None

  Parameters:
    None

  Returns:
    None
  
  Remarks:
    None
  ***************************************************************************/

void ARPInit(void)
{
    Cache.MACAddr.v[0] = 0xff;
    Cache.MACAddr.v[1] = 0xff;
    Cache.MACAddr.v[2] = 0xff;
    Cache.MACAddr.v[3] = 0xff;
    Cache.MACAddr.v[4] = 0xff;
    Cache.MACAddr.v[5] = 0xff;

    Cache.IPAddr.Val = 0x0;
}


/*****************************************************************************
  Function:
    BOOL ARPProcess(void)

  Summary:
    Processes an incoming ARP packet.
    
  Description:
    Retrieves an ARP packet from the MAC buffer and determines if it is a
    response to our request (in which case the ARP is resolved) or if it
    is a request requiring our response (in which case we transmit one.)

  Precondition:
    ARP packet is ready in the MAC buffer.

  Parameters:
    None

  Return Values:
    TRUE - All processing of this ARP packet is complete.  Do not call 
            again until a new ARP packet is waiting in the RX buffer.
    FALSE - This function must be called again.  More time is needed to 
            send an ARP response.
  ***************************************************************************/

BOOL ARPProcess(void)
{
    ARP_PACKET packet;
    static NODE_INFO Target;
    static enum
    {
        SM_ARP_IDLE = 0,
        SM_ARP_REPLY
    } smARP = SM_ARP_IDLE;

    switch(smARP)
    {
        case SM_ARP_IDLE:
            // Obtain the incoming ARP packet
            MACGetArray((BYTE*)&packet, sizeof(packet));        
            MACDiscardRx();
            SwapARPPacket(&packet);
        
            // Validate the ARP packet
            if ( packet.HardwareType != HW_ETHERNET     ||
                 packet.MACAddrLen != sizeof(MAC_ADDR)  ||
                 packet.ProtocolLen != sizeof(IP_ADDR) )
            {
                 return TRUE;
            }
        
            // Handle incoming ARP responses
            if(packet.Operation == ARP_OPERATION_RESP)
            {
                Cache.MACAddr = packet.SenderMACAddr;
                Cache.IPAddr = packet.SenderIPAddr;
                return TRUE;
            }

            // Handle incoming ARP requests for our MAC address
            if(packet.Operation == ARP_OPERATION_REQ)
            {
                // MODIFIX: Changed from the Microchip AppConfig structure 
                // to the more eWicht specific sIPConfig structure.
                if( packet.TargetIPAddr.Val != sIPConfig.MyIPAddr.Val )
                {
                    return TRUE;
                }
                Target.IPAddr = packet.SenderIPAddr;
                Target.MACAddr = packet.SenderMACAddr;

                smARP = SM_ARP_REPLY;
            }
            // Do not break.  If we get down here, we need to send a reply. 

        case SM_ARP_REPLY:
            packet.Operation        = ARP_OPERATION_RESP;
            packet.TargetMACAddr    = Target.MACAddr;
            packet.TargetIPAddr     = Target.IPAddr;

            // Send an ARP response to a previously received request
            if(!ARPPut(&packet))
            {
               return FALSE;
            }

            // Begin listening for ARP requests again
            smARP = SM_ARP_IDLE;
            break;
    }

    return TRUE;
}


/*****************************************************************************
  Function:
    void ARPResolve(IP_ADDR* IPAddr)

  Summary:
    Transmits an ARP request to resolve an IP address.
    
  Description:
    This function transmits and ARP request to determine the hardware
    address of a given IP address.

  Precondition:
    ARP packet is ready in the MAC buffer.

  Parameters:
    IPAddr - The IP address to be resolved

  Returns:
    None

  Remarks:
    None
  ***************************************************************************/

void ARPResolve(IP_ADDR *IPAddr)
{
    ARP_PACKET packet;

    packet.Operation            = ARP_OPERATION_REQ;
    packet.TargetMACAddr.v[0]   = 0xff;
    packet.TargetMACAddr.v[1]   = 0xff;
    packet.TargetMACAddr.v[2]   = 0xff;
    packet.TargetMACAddr.v[3]   = 0xff;
    packet.TargetMACAddr.v[4]   = 0xff;
    packet.TargetMACAddr.v[5]   = 0xff;


    // ARP query either the IP address directly (on our subnet), or do an ARP query for our Gateway if off of our subnet
    // MODIFIX: Changed from the Microchip AppConfig structure 
    // to the more eWicht specific sIPConfig structure.
    packet.TargetIPAddr         = ((sIPConfig.MyIPAddr.Val ^ IPAddr->Val) & sIPConfig.MyMask.Val) ? sIPConfig.MyGateway : *IPAddr;

    // MODIFIX: Only if TargetIPAddr is a valid address, put the ARP frame to
    // the ethernet.
    if (packet.TargetIPAddr.Val)
        ARPPut(&packet);
}


/*****************************************************************************
  Function:
    BOOL ARPIsResolved(IP_ADDR* IPAddr, MAC_ADDR* MACAddr)

  Summary:
    Determines if an ARP request has been resolved yet.
    
  Description:
    This function checks if an ARP request has been resolved yet, and if
    so, stores the resolved MAC address in the pointer provided.

  Precondition:
    ARP packet is ready in the MAC buffer.

  Parameters:
    IPAddr - The IP address to be resolved
    MACAddr - A buffer to store the corresponding MAC address

  Return Values:
    TRUE - The IP address has been resolved and MAC address indicates the
            response.
    FALSE - The IP address is not resolved.

  Remarks:
    None
  ***************************************************************************/

BOOL ARPIsResolved(IP_ADDR *IPAddr, MAC_ADDR *MACAddr)
{
    // MODIFIX: Changed from the Microchip AppConfig structure 
    // to the more eWicht specific sIPConfig structure.
    if((Cache.IPAddr.Val == IPAddr->Val) || 
      ((Cache.IPAddr.Val == sIPConfig.MyGateway.Val) && Cache.IPAddr.Val))
    {
        *MACAddr = Cache.MACAddr;
        return TRUE;
    }
    return FALSE;
}


/*****************************************************************************
  Function:
    static void SwapARPPacket(ARP_PACKET* p)

  Description:
    Swaps endian-ness of header information in an ARP packet.

  Precondition:
    None

  Parameters:
    p - The ARP packet to be swapped

  Returns:
    None
  ***************************************************************************/
static void SwapARPPacket(ARP_PACKET *p)
{
    p->HardwareType     = swaps(p->HardwareType);
    p->Protocol         = swaps(p->Protocol);
    p->Operation        = swaps(p->Operation);
}

/*****************************************************************************
// MODIFIX: Added the function for flushing the ARP cache.
  ***************************************************************************/
void ARPFlush(void)
{
    ARPInit();
}

---