---

/opentcp/arp.c

Go to the documentation of this file.

/*
 *Copyright (c) 2000-2002 Viola Systems Ltd.
 *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 end-user documentation included with the redistribution, if 
 *any, must include the following acknowledgment:
 *      "This product includes software developed by Viola 
 *      Systems (http://www.violasystems.com/)."
 *
 *Alternately, this acknowledgment may appear in the software itself, 
 *if and wherever such third-party acknowledgments normally appear.
 *
 *4. The names "OpenTCP" and "Viola Systems" must not be used to 
 *endorse or promote products derived from this software without prior 
 *written permission. For written permission, please contact 
 *opentcp@opentcp.org.
 *
 *5. Products derived from this software may not be called "OpenTCP", 
 *nor may "OpenTCP" appear in their name, without prior written 
 *permission of the Viola Systems Ltd.
 *
 *THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED 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 VIOLA SYSTEMS LTD. OR ITS CONTRIBUTORS 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.
 *====================================================================
 *
 *OpenTCP is the unified open source TCP/IP stack available on a series 
 *of 8/16-bit microcontrollers, please see <http://www.opentcp.org>.
 *
 *For more information on how to network-enable your devices, or how to 
 *obtain commercial technical support for OpenTCP, please see 
 *<http://www.violasystems.com/>.
 */

#include <inet/debug.h>
#include <inet/ethernet.h>
#include <inet/arp.h>
#include <inet/timers.h>
#include <inet/system.h>
#include <inet/globalvariables.h>

struct arp_entry        arp_table[ARP_TSIZE]; 

UINT8 arp_timer; 

UINT8 process_arp (struct ethernet_frame* frame) {
        
        UINT8 temp;             
        
        /* Check if ARP packet*/
        
        if( frame->protocol == ARP_ETHCODE ) {
                /* Yep, ARP */
                
                NETWORK_RECEIVE_INITIALIZE(frame->buf_index);
                
                /* Is it long enough?   */
                
                if( frame->frame_size < (2*MAXHWALEN + 2*MAXPRALEN + 2 + 6) ) {
                        /* Somehow corrupted ARP packet */
                        ARP_DEBUGOUT("Corrupted ARP packet\n\r");
                        NETWORK_RECEIVE_END();
                        return(TRUE);
                }
                         
                
                /* Ignore next 6 bytes: <HW type>, <Protocol type> */
                /* <HW address len> and <Protocol address len>     */
                
                for(temp=0; temp<6; temp++)
                        RECEIVE_NETWORK_B();
                
                ARP_DEBUGOUT("Incoming ARP..\n\r");
                
                /* Check if request or response */
                
                if( RECEIVE_NETWORK_B() == 0x00) {
                
                        temp = RECEIVE_NETWORK_B();     /* get opcode */
                
                        if( temp == ARP_REQUEST ) {
                                ARP_DEBUGOUT(" ARP REQUEST Received..\n\r");
                                arp_send_response();
                        } else if( temp == ARP_REPLY ) {
                                ARP_DEBUGOUT("ARP Response Received..\n\r");
                                arp_get_response();     
                        }
                        
                /* Wasn't request or response or all done, dump it */
                
                }
                
                NETWORK_RECEIVE_END();
                return(TRUE);
                
        }
        
        /* Wasn't ARP, don't touch the packet */
        
        return(FALSE);                                                          
}

void arp_send_response(void)
{
        struct arp_entry *qstruct;
        UINT8 rem_hwadr[MAXHWALEN];
        LWORD rem_ip;
        LWORD ltemp;
        INT8 i;
        BYTE j;

        /* Record Sender's HW address           */
        
        for( i=MAXHWALEN-1; i >= 0; i-- )
                rem_hwadr[i] = RECEIVE_NETWORK_B();             
        
        /* Read Sender's IP Address     */
        
        for( i=0; i<MAXPRALEN; i++) {
                rem_ip <<= 8;
                rem_ip |= RECEIVE_NETWORK_B();
        } 
        
        
        /* Skip Target HW address               */
        
        RECEIVE_NETWORK_B();
        RECEIVE_NETWORK_B();
        RECEIVE_NETWORK_B();
        RECEIVE_NETWORK_B();
        RECEIVE_NETWORK_B();
        RECEIVE_NETWORK_B();    
        
        /* Is The Packet For Us?        */
        
        for( i=0; i<MAXPRALEN; i++) {
                ltemp <<= 8;
                ltemp |= RECEIVE_NETWORK_B();
        }
                
        
        if( ltemp != localmachine.localip ) 
                return;                                                         /* No   */

        ARP_DEBUGOUT("Preparing for ARP Reply\n\r");
        
        /* OK. Now send reply           */
        
        NETWORK_SEND_INITIALIZE(ARP_BUFFER);
        
        /* Add datalink (Ethernet addresses) information        */
        
        for( i=0; i<MAXHWALEN; i++)     {
                send_frame.destination[i] = rem_hwadr[i];
                send_frame.source[i] = localmachine.localHW[i];
        }
        
        send_frame.protocol = PROTOCOL_ARP;
        
        NETWORK_ADD_DATALINK(&send_frame);
        
        /* PUT ARP Data */
        
        SEND_NETWORK_B( (BYTE)(AR_HARDWARE>>8) );                               /* Hardware Type        */
        SEND_NETWORK_B( (BYTE)AR_HARDWARE );
        SEND_NETWORK_B(0x08);                                                                   /* Protocol Type        */
        SEND_NETWORK_B(0x00);
        SEND_NETWORK_B(MAXHWALEN);                                                              /* HW Adr Len           */
        SEND_NETWORK_B(MAXPRALEN);                                                              /* Protocol Adr. Len*/
        SEND_NETWORK_B( 0x00 );                                                                 /* ARP Opcode           */      
        SEND_NETWORK_B( 0x02 );                                 
        SEND_NETWORK_B((UINT8)(localmachine.localHW[5]));               /* Address fields       */
        SEND_NETWORK_B((UINT8)(localmachine.localHW[4]));
        SEND_NETWORK_B((UINT8)(localmachine.localHW[3]));
        SEND_NETWORK_B((UINT8)(localmachine.localHW[2]));
        SEND_NETWORK_B((UINT8)(localmachine.localHW[1]));
        SEND_NETWORK_B((UINT8)(localmachine.localHW[0]));
        SEND_NETWORK_B((UINT8)(localmachine.localip>>24));
        SEND_NETWORK_B((UINT8)(localmachine.localip>>16));
        SEND_NETWORK_B((UINT8)(localmachine.localip>>8));
        SEND_NETWORK_B((UINT8)(localmachine.localip));
        SEND_NETWORK_B((UINT8)rem_hwadr[5]);
        SEND_NETWORK_B((UINT8)rem_hwadr[4]);
        SEND_NETWORK_B((UINT8)rem_hwadr[3]);
        SEND_NETWORK_B((UINT8)rem_hwadr[2]);
        SEND_NETWORK_B((UINT8)rem_hwadr[1]);
        SEND_NETWORK_B((UINT8)rem_hwadr[0]);                                            
        SEND_NETWORK_B((UINT8)(rem_ip>>24));
        SEND_NETWORK_B((UINT8)(rem_ip>>16));
        SEND_NETWORK_B((UINT8)(rem_ip>>8));
        SEND_NETWORK_B((UINT8)rem_ip);
        
        NETWORK_COMPLETE_SEND(0x0040);          /* Send the packet      */
        
        ARP_DEBUGOUT("ARP Reply Sent..\n\r");
        
        /* Add the Sender's info to cache because we can        */
        
        arp_add(rem_ip, &send_frame.destination[0], ARP_TEMP_IP);
        
        return;
                
}


void arp_get_response(void)
{
        struct arp_entry *qstruct;
        UINT8 rem_hwadr[MAXHWALEN];
        UINT32  rem_ip;
        UINT32  ltemp;
        INT8 i;
        UINT8 j;
        
        /* Read Sender's HW address     */
        
        for( i=MAXHWALEN-1; i >= 0; i-- )
                rem_hwadr[i] = RECEIVE_NETWORK_B();
                
        /* Read Sender's IP Address     */
        
        for( i=0; i<MAXPRALEN; i++) {
                rem_ip <<= 8;
                rem_ip |= RECEIVE_NETWORK_B();
        }
        
        
        /* Skip our HW Address  */
        
        for(i=0; i<MAXHWALEN; i++)
                RECEIVE_NETWORK_B();
        
        
        /* Is The Packet For Us?        */
        
        for( i=0; i<MAXPRALEN; i++)     {
                ltemp <<= 8;
                ltemp |= RECEIVE_NETWORK_B();
        }
                
        
        if( ltemp != localmachine.localip ) 
                return;                                                         /* No   */

        ARP_DEBUGOUT("Now entering to process ARP Reply..\n\r");
        
        /* Are we waiting for that reply?       */
        
        for( i=1; i<ARP_TSIZE; i++ ) {
                qstruct = &arp_table[i];
                
                if( qstruct->state == ARP_FREE )
                        continue;
                
                if( qstruct->state == ARP_RESERVED )
                        continue;                               
                
                if( rem_ip == qstruct->pradr ) {
                        /* We are caching that IP, refresh it   */
                        
                        ARP_DEBUGOUT("Refreshing ARP cache from Reply..\n\r");
                        
                        for( j=0; j<MAXHWALEN; j++ )            
                                qstruct->hwadr[j] = rem_hwadr[j];
                                
                        qstruct->ttl = ARP_TIMEOUT;
                        qstruct->retries = ARP_MAXRETRY;                                /* No need for Retry    */
                        qstruct->state = ARP_RESOLVED;
                
                        /* Done */
                        
                        break;
                }       
        
        }

}

void arp_send_req (UINT8 entry)
{

        struct arp_entry *qstruct;
        UINT8 i;
        
        qstruct = &arp_table[entry];
        
        NETWORK_SEND_INITIALIZE(ARP_BUFFER);
        
        /* Add datalink (Ethernet addresses) information        */
        
        for( i=0; i<MAXHWALEN; i++) {
                send_frame.destination[i] = 0xFF;
                send_frame.source[i] = localmachine.localHW[i];
        }
        
        send_frame.protocol = PROTOCOL_ARP;
        
        NETWORK_ADD_DATALINK(&send_frame);
        
        /* PUT ARP Data */

        SEND_NETWORK_B( (BYTE) (AR_HARDWARE>>8) );                      /* Hardware Type        */
        SEND_NETWORK_B( (BYTE) AR_HARDWARE );
        SEND_NETWORK_B(0x08);                                                           /* Protocol Type        */
        SEND_NETWORK_B(0x00);
        SEND_NETWORK_B(MAXHWALEN);                                                      /* HW Adr Len           */
        SEND_NETWORK_B(MAXPRALEN);                                                      /* Protocol Adr. Len*/
        SEND_NETWORK_B( (BYTE)(ARP_REQUEST>>8));                        /* ARP Opcode           */
        SEND_NETWORK_B( (BYTE) ARP_REQUEST );
        SEND_NETWORK_B((UINT8)localmachine.localHW[5]);         /* Address fields       */
        SEND_NETWORK_B((UINT8)localmachine.localHW[4]);
        SEND_NETWORK_B((UINT8)localmachine.localHW[3]);
        SEND_NETWORK_B((UINT8)localmachine.localHW[2]);
        SEND_NETWORK_B((UINT8)localmachine.localHW[1]);
        SEND_NETWORK_B((UINT8)localmachine.localHW[0]);
        SEND_NETWORK_B((UINT8)(localmachine.localip>>24));
        SEND_NETWORK_B((UINT8)(localmachine.localip>>16));
        SEND_NETWORK_B((UINT8)(localmachine.localip>>8));
        SEND_NETWORK_B((UINT8)localmachine.localip);
        SEND_NETWORK_B((UINT8)0xFF);
        SEND_NETWORK_B((UINT8)0xFF);
        SEND_NETWORK_B((UINT8)0xFF);
        SEND_NETWORK_B((UINT8)0xFF);
        SEND_NETWORK_B((UINT8)0xFF);
        SEND_NETWORK_B((UINT8)0xFF);                                            
        SEND_NETWORK_B((UINT8)(qstruct->pradr>>24));
        SEND_NETWORK_B((UINT8)(qstruct->pradr>>16));
        SEND_NETWORK_B((UINT8)(qstruct->pradr>>8));
        SEND_NETWORK_B((UINT8)qstruct->pradr);
        
        
        /* Packet assembled now, just send it ... */
        
        NETWORK_COMPLETE_SEND(0x0040);                                          /* Min packet size      */
 
        ARP_DEBUGOUT("ARP Request Sent\n\r");
        
}


INT8 arp_alloc (UINT8 type)
{
        struct arp_entry *qstruct;
        char i;
        static BYTE aenext = 0;         /* Cache Manager        */
        
        
        for( i=0; i<ARP_TSIZE; i++ ) {
        
                if( arp_table[aenext].state == ARP_FREE ) {
                        i = aenext;
                        break;
                }
                
                /* Move to next entry */
                        
                aenext = (aenext + 1);
                if( aenext >= ARP_TSIZE )
                        aenext = 1;
                
        }
#if     DEBUG == 1
        ARP_DEBUGOUT("Found an entry - ");      
                        if(aenext==0){
                                ARP_DEBUGOUT("Allocated Entry 0\n\r");
                        }
                        if(aenext==1){
                                ARP_DEBUGOUT("Allocated Entry 1\n\r");
                        }
                        
                        if(aenext==2){
                                ARP_DEBUGOUT("Allocated Entry 2\n\r");  
                        }
                        
#endif

        qstruct = &arp_table[aenext];
        
        aenext = (aenext + 1);  
        if( aenext >= ARP_TSIZE )
                aenext = 1;
        
        /* Set ARP initial parameters   */
        
        qstruct->state = ARP_RESERVED;
        qstruct->type = type;
        
        return(i);

}
INT8 arp_add (UINT32 pra, UINT8* hwadr, UINT8 type)
{
        struct arp_entry *qstruct;
        UINT8 i;
        UINT8 j;

        for( i=0; i<ARP_TSIZE; i++ ) {
                qstruct = &arp_table[i];
                
                if( qstruct->state == ARP_FREE )
                        continue;
                        
                if( qstruct->pradr == pra) {
                        /* The address is in cache, refresh it   */
                        
                        ARP_DEBUGOUT(" Refreshing Existing ARP Entry..\n\r");
                
                        for( j=0; j<MAXHWALEN; j++ )            
                                qstruct->hwadr[j] = *hwadr++;
                                
                        qstruct->ttl = ARP_TIMEOUT;
                        qstruct->retries = ARP_MAXRETRY;
                        qstruct->state = ARP_RESOLVED;
        
                        /* All OK       */
                
                        return (0);     
                }
        
        }
        
        if(is_subnet(pra,&localmachine) == FALSE){
                return (-1);
        }
        
        if( localmachine.defgw == pra ) {
                if(localmachine.defgw != 0) {
                        type = ARP_FIXED_IP;
                }
        }

        
        /* Address was'nt on cache. Need to allocate new one    */
        
        ARP_DEBUGOUT("Allocating New ARP Entry..\n\r");
        
        i = arp_alloc(type);
        
        if( i < 0 )                             /* No Entries Left?     */
                return(-1);
                        
        /* Fill the fields              */
                
        qstruct = &arp_table[i];
                
        qstruct->pradr = pra;                                                                           /* Fill IP                              */
        
        for(i=0; i<MAXHWALEN; i++)
                qstruct->hwadr[i] = *hwadr++;                                                   /* Fill HW address              */

        qstruct->retries = ARP_MAXRETRY;
        qstruct->ttl = ARP_TIMEOUT;
        qstruct->state = ARP_RESOLVED;                          
        
        ARP_DEBUGOUT("ARP Entry Created!..\n\r");

        return(1);

} 
struct arp_entry* arp_find (LWORD pra, struct netif *machine, UINT8 type)
{
        struct arp_entry *qstruct;
        char i;
        
        ARP_DEBUGOUT("Trying to find MAC address from ARP Cache\n\r");
        
        /* Is the address in the cache  */
        
        for( i=0; i<ARP_TSIZE; i++ ) {
                qstruct = &arp_table[i];
                
                if( qstruct->state == ARP_FREE )
                        continue;
                if( qstruct->pradr == pra) {
                        /* The address is in cache, is it valid? */
                        
                        ARP_DEBUGOUT("Address In Cache\n\r");
                        
                        if( qstruct->state < ARP_RESOLVED ) {
                                ARP_DEBUGOUT("Address in cache but unresolved :(\n\r");
                                return(0);
                        }
                        /* All OK       */
                
                        return(qstruct);        
                }
        
        }
        
        /* The address wasn't on the cache. Is it in our Subnet?        */
        
        if( is_subnet(pra, machine) ) {
                /* Yep, we need to send ARP REQUEST     */
                
                ARP_DEBUGOUT("Need to send ARP Request to local network..\n\r");
                
                i = arp_alloc(type);
                
                if( i < 0 )                             /* No Entries Left?     */
                        return(0);
                        
                /* Send Request after filling the fields        */
                
                qstruct = &arp_table[i];
                
                qstruct->pradr = pra;                                           /* Fill IP                              */
                qstruct->hwadr[0] = 0xFF;                                       /* Fill Broadcast IP    */
                qstruct->hwadr[1] = 0xFF;
                qstruct->hwadr[2] = 0xFF;
                qstruct->hwadr[3] = 0xFF;
                qstruct->hwadr[4] = 0xFF;
                qstruct->hwadr[5] = 0xFF;
                qstruct->retries = ARP_MAXRETRY;
                qstruct->ttl = ARP_RESEND;
                arp_send_req( i );
                qstruct->state = ARP_PENDING;                           /* Waiting for Reply    */
                
                return(0);
        
        } 
        
        /* Check for Broadcast                                                                                                  */
        
        if(machine->defgw == 0)                         /* It's not specified   */
                return(0);
        
        /* The Address belongst to the outern world, need to use MAC of                 */
        /* Default Gateway                                                                                                              */
        

        ARP_DEBUGOUT("Need to use MAC of Default GW\n\r");
        
        for( i=0; i<ARP_TSIZE; i++ ) {
                qstruct = &arp_table[i];
                
                if( qstruct->state == ARP_FREE )
                        continue;
                        
                if( qstruct->pradr == machine->defgw ) {
                        /* The address is in cache, is it valid? */
                 
                        
                        if( qstruct->state < ARP_RESOLVED ) {
                                ARP_DEBUGOUT("The Address of Def. GW is not Solved!\n\r");
                                return(0);
                        }
                
                        /* All OK       */
                        
                        ARP_DEBUGOUT(" >> Default Gateway MAC found!\n\r");
                
                        return(qstruct);
                                
                }
        
        }
        
        ARP_DEBUGOUT("Need to send ARP Request to default gateway..\n\r");
                
        i = arp_alloc(ARP_FIXED_IP);
                
        if( i < 0 )                             /* No Entries Left?     */
                return(0);
                        
        /* Send Request after filling the fields        */
                
        qstruct = &arp_table[i];
                
        qstruct->pradr = machine->defgw;                                                /* Fill IP                              */
        qstruct->hwadr[0] = 0xFF;                                       /* Fill Broadcast IP    */
        qstruct->hwadr[1] = 0xFF;
        qstruct->hwadr[2] = 0xFF;
        qstruct->hwadr[3] = 0xFF;
        qstruct->hwadr[4] = 0xFF;
        qstruct->hwadr[5] = 0xFF;
        qstruct->retries = ARP_MAXRETRY;
        qstruct->ttl = ARP_RESEND;
        arp_send_req( i );
        qstruct->state = ARP_PENDING;                           /* Waiting for Reply    */
        
        return(0);

        
}

void arp_manage (void)
{
        struct arp_entry *qstruct;
        UINT8 i;
        
        /* Check Timer before entering  */
        
        if( check_timer(arp_timer) )
                return;
                
        init_timer( arp_timer, ARP_MANG_TOUT*TIMERTIC);
        
        /* ARP_DEBUGOUT("Managing ARP Cache\n\r"); */
        
        for( i=0; i<ARP_TSIZE; i++ ) {
                /* ARP_DEBUGOUT("."); */
        
                qstruct = &arp_table[i];
        
                if( qstruct->state == ARP_FREE )
                        continue;
                        
                /* TODO: How about ARP_RESERVED?        */
                        
                if( qstruct->ttl > 0 )                          /* Aging                */
                        qstruct->ttl --;

                /* Timed Out?   */
                if( qstruct->ttl == 0 ) {
                        /* Do it for temporay entries   */
                        
                        ARP_DEBUGOUT("Found Timed out Entry..\n\r");
                
                        if( qstruct->type == ARP_TEMP_IP ) {
                                /* Release it?  */
                                if( qstruct->state == ARP_RESOLVED ) {  
                                        ARP_DEBUGOUT("Releasing ARP Entry..\n\r");
                                        qstruct->state = ARP_FREE;
                                        continue;
                                }
                                
                                /* Decrease retries left        */
                                
                                if( qstruct->retries > 0 )      
                                        qstruct->retries--;
                                
                                if( qstruct->retries == 0 )     {
                                        ARP_DEBUGOUT("ARP Replies Used up, releasing entry..\n\r");
                                        qstruct->state = ARP_FREE;
                                        continue;
                                }
                                
                                /* So we need to resend ARP request     */
                                
                                ARP_DEBUGOUT("Trying to Resolve dynamic ARP Entry..\n\r");
                        
                                qstruct->ttl = ARP_RESEND;
                                arp_send_req( i );
                                qstruct->state = ARP_PENDING;                           /* Waiting for Reply    */
                                
                                continue;
                        
                        }
                
                        /* Do it for Static Entries                     */
                
                        if( qstruct->type == ARP_FIXED_IP ) {
                                
                                /* So we need to resend ARP request     */
                                
                                /* Do not try to refresh broadcast      */
                                
                                if(qstruct->pradr == IP_BROADCAST_ADDRESS)
                                {
                                        qstruct->ttl = ARP_TIMEOUT;
                                        continue;
                                }
                                
                                ARP_DEBUGOUT("Refreshing Static ARP Entry..\n\r");
                        
                                if( qstruct->retries > 0 )      
                                        qstruct->retries--;
                                
                                if( qstruct->retries == 0 )
                                        qstruct->state = ARP_PENDING;
                                else
                                        qstruct->state = ARP_REFRESHING;
                        
                                qstruct->ttl = ARP_RESEND;
                                arp_send_req( i );
                                
                                continue;
                        
                        }
                
                }
        
        }


}



void arp_init (void)
{
        struct arp_entry *qstruct;
        INT8 i;
        
        ARP_DEBUGOUT("Initializing ARP");
        
        for( i=0; i<ARP_TSIZE; i++ ) {
                qstruct = &arp_table[i];
                
                qstruct->state = ARP_FREE;
                qstruct->type = ARP_TEMP_IP;
                
                ARP_DEBUGOUT(".");
        }
        
        arp_timer = get_timer();
        init_timer(arp_timer, ARP_MANG_TOUT*TIMERTIC);

        /* set broadcast entry  */
        
        qstruct = &arp_table[0];
        qstruct->pradr = IP_BROADCAST_ADDRESS;
        qstruct->state = ARP_RESOLVED;
        qstruct->type = ARP_FIXED_IP;
        qstruct->ttl = ARP_TIMEOUT;
        qstruct->retries = ARP_MAXRETRY;        
        
        for(i=0; i<MAXHWALEN; i++)
                qstruct->hwadr[i] = 0xFF;                                                       
        
        ARP_DEBUGOUT("\n\r");
        
}
BYTE is_subnet (LWORD ipadr, struct netif* machine)
{

        UINT32 ltemp;

        ltemp = ipadr & machine->netmask;                                               /* Get Subnet part      */
        
        ltemp ^= (machine->localip & machine->netmask);                 /* Compare to my IP     */
        
        if( ltemp )
                return(FALSE);
        
        return(TRUE);

}

---