arp.i

cs8900 c51应用

#line 1 "..\arp.c" /0



















































 
 














 
 
#error *** WARNING C318 IN LINE 69 OF ..\arp.c: can't open file 'inet/datatypes.h'
 
#error *** WARNING C318 IN LINE 70 OF ..\arp.c: can't open file 'inet/debug.h'
 
#error *** WARNING C318 IN LINE 71 OF ..\arp.c: can't open file 'inet/ethernet.h'
 
#error *** WARNING C318 IN LINE 72 OF ..\arp.c: can't open file 'inet/arp.h'
 
#error *** WARNING C318 IN LINE 73 OF ..\arp.c: can't open file 'inet/timers.h'
 
#error *** WARNING C318 IN LINE 74 OF ..\arp.c: can't open file 'inet/system.h'
 
#error *** WARNING C318 IN LINE 75 OF ..\arp.c: can't open file 'inet/globalvariables.h'
 








 
 struct arp_entry	arp_table[ARP_TSIZE]; 
 





 
 UINT8 arp_timer; 
 



















 
 UINT8 process_arp (struct ethernet_frame* frame) {
 
 UINT8 temp;		
 
 
 
 if( frame->protocol == ARP_ETHCODE ) {
 
 
 NETWORK_RECEIVE_INITIALIZE(frame->buf_index);
 
 
 
 if( frame->frame_size < (2*MAXHWALEN + 2*MAXPRALEN + 2 + 6) ) {
 
 ARP_DEBUGOUT("Corrupted ARP packet\n\r");
 
 return(TRUE);
 }
 
 
 
 
 
 for(temp=0; temp<6; temp++)
 RECEIVE_NETWORK_B();
 
 ARP_DEBUGOUT("Incoming ARP..\n\r");
 
 
 
 if( RECEIVE_NETWORK_B() == 0x00) {
 
 temp = RECEIVE_NETWORK_B();	 
 
 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();	
 }
 
 
 
 }
 
 
 return(TRUE);
 
 }
 
 
 
 return(FALSE);								
 }
 














 
 void arp_send_response(void)
 {
 struct arp_entry *qstruct;
 UINT8 rem_hwadr[MAXHWALEN];
 UINT32 rem_ip;
 UINT32 ltemp;
 INT8 i;
 BYTE j;
 
 
 
 for( i=MAXHWALEN-1; i >= 0; i-- )
 rem_hwadr[i] = RECEIVE_NETWORK_B();		
 
 
 
 for( i=0; i<MAXPRALEN; i++) {
 rem_ip <<= 8;
 rem_ip |= RECEIVE_NETWORK_B();
 } 
 
 
 
 
 RECEIVE_NETWORK_B();
 RECEIVE_NETWORK_B();
 RECEIVE_NETWORK_B();
 RECEIVE_NETWORK_B();
 RECEIVE_NETWORK_B();
 RECEIVE_NETWORK_B();	
 
 
 
 for( i=0; i<MAXPRALEN; i++) {
 ltemp <<= 8;
 ltemp |= RECEIVE_NETWORK_B();
 }
 
 
 if( ltemp != localmachine.localip ) 
 return;								 
 
 ARP_DEBUGOUT("Preparing for ARP Reply\n\r");
 
 
 
 NETWORK_SEND_INITIALIZE(ARP_BUFFER);
 
 
 
 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);
 
 
 
 SEND_NETWORK_B( (BYTE)(AR_HARDWARE>>8) );				 
 SEND_NETWORK_B( (BYTE)AR_HARDWARE );
 SEND_NETWORK_B(0x08);									 
 SEND_NETWORK_B(0x00);
 SEND_NETWORK_B(MAXHWALEN);								 
 SEND_NETWORK_B(MAXPRALEN);								 
 SEND_NETWORK_B( 0x00 );									 
 SEND_NETWORK_B( 0x02 );					
 SEND_NETWORK_B((UINT8)(localmachine.localHW[5]));		 
 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);		 
 
 ARP_DEBUGOUT("ARP Reply Sent..\n\r");
 
 
 
 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;
 
 
 
 for( i=MAXHWALEN-1; i >= 0; i-- )
 rem_hwadr[i] = RECEIVE_NETWORK_B();
 
 
 
 for( i=0; i<MAXPRALEN; i++) {
 rem_ip <<= 8;
 rem_ip |= RECEIVE_NETWORK_B();
 }
 
 
 
 
 for(i=0; i<MAXHWALEN; i++)
 RECEIVE_NETWORK_B();
 
 
 
 
 for( i=0; i<MAXPRALEN; i++)	{
 ltemp <<= 8;
 ltemp |= RECEIVE_NETWORK_B();
 }
 
 
 if( ltemp != localmachine.localip ) 
 return;								 
 
 ARP_DEBUGOUT("Now entering to process ARP Reply..\n\r");
 
 
 
 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 ) {
 
 
 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;				 
 qstruct->state = ARP_RESOLVED;
 
 
 
 break;
 }	
 
 }
 
 }
 









 
 void arp_send_req (UINT8 entry)
 {
 
 struct arp_entry *qstruct;
 UINT8 i;
 
 qstruct = &arp_table[entry];
 
 NETWORK_SEND_INITIALIZE(ARP_BUFFER);
 
 
 
 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);
 
 
 
 SEND_NETWORK_B( (BYTE) (AR_HARDWARE>>8) );			 
 SEND_NETWORK_B( (BYTE) AR_HARDWARE );
 SEND_NETWORK_B(0x08);								 
 SEND_NETWORK_B(0x00);
 SEND_NETWORK_B(MAXHWALEN);							 
 SEND_NETWORK_B(MAXPRALEN);							 
 SEND_NETWORK_B( (BYTE)(ARP_REQUEST>>8));			 
 SEND_NETWORK_B( (BYTE) ARP_REQUEST );
 SEND_NETWORK_B((UINT8)localmachine.localHW[5]);		 
 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);
 
 
 
 
 NETWORK_COMPLETE_SEND(0x0040);						 
 
 ARP_DEBUGOUT("ARP Request Sent\n\r");
 
 }
 
 













 
 INT8 arp_alloc (UINT8 type)
 {
 struct arp_entry *qstruct;
 INT8 i;
 static BYTE aenext = 1;		 
 INT16 found;
 
 
 found=-1;
 
 for( i=0; i<ARP_TSIZE; i++ ) {
 
 if( arp_table[aenext].state == ARP_FREE ) {
 found=i;
 break;
 }
 }
 
 if(found != (-1) ) {
 qstruct = &arp_table[found];
 qstruct->state = ARP_RESERVED;
 qstruct->type = type;	
 return( (UINT8)found );
 }
 
 
 
 
 
 
 for( i=0; i<ARP_TSIZE; i++ ) {	
 if( arp_table[aenext].type == ARP_TEMP_IP) {
 found = aenext;			
 break;
 }
 
 
 
 aenext = (aenext + 1);
 if( aenext >= ARP_TSIZE )
 aenext = 1;
 
 }
 
 
 
 
 if( found == (-1) )
 return(-1);
 
 
 
 aenext = (aenext + 1);	
 if( aenext >= ARP_TSIZE )
 aenext = 1;		
 
 qstruct = &arp_table[found];
 
 
 
 qstruct->state = ARP_RESERVED;
 qstruct->type = type;
 
 
 
 return((UINT8)found);
 
 
 }
















 
 INT8 arp_add (UINT32 pra, UINT8* hwadr, UINT8 type)
 {
 struct arp_entry *qstruct;
 INT8 i;
 INT8 j;
 
 for( i=0; i<ARP_TSIZE; i++ ) {
 qstruct = &arp_table[i];
 
 if( qstruct->state == ARP_FREE )
 continue;
 
 if((qstruct->pradr == pra)&&(pra != IP_BROADCAST_ADDRESS)) {
 
 
 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;
 
 
 
 return (0);	
 }
 
 }
 
 if(is_subnet(pra,&localmachine) == FALSE){
 return (-1);
 }
 
 if( localmachine.defgw == pra )	{
 if(localmachine.defgw != 0) {
 type = ARP_FIXED_IP;
 }
 }
 
 
 
 
 ARP_DEBUGOUT("Allocating New ARP Entry..\n\r");
 
 i = arp_alloc(type);
 
 if( i < 0 )				 
 return(-1);
 
 
 
 qstruct = &arp_table[i];
 
 qstruct->pradr = pra;										 
 
 for(i=0; i<MAXHWALEN; i++)
 qstruct->hwadr[i] = *hwadr++;							 
 
 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;
 INT8 i;
 
 ARP_DEBUGOUT("Trying to find MAC address from ARP Cache\n\r");
 
 
 
 for( i=0; i<ARP_TSIZE; i++ ) {
 qstruct = &arp_table[i];
 
 if( qstruct->state == ARP_FREE )
 continue;
 if( qstruct->pradr == pra) {
 
 
 ARP_DEBUGOUT("Address In Cache\n\r");
 
 if( qstruct->state < ARP_RESOLVED ) {
 ARP_DEBUGOUT("Address in cache but unresolved :(\n\r");
 return(0);
 }
 
 
 return(qstruct);	
 }
 
 }
 
 
 
 if( is_subnet(pra, machine) ) {
 
 
 ARP_DEBUGOUT("Need to send ARP Request to local network..\n\r");
 
 if( machine->defgw == pra ) {
 if(machine->defgw != 0) {
 type = ARP_FIXED_IP;
 }
 }
 i = arp_alloc(type);
 
 if( i < 0 )				 
 return(0);
 
 
 
 qstruct = &arp_table[i];
 
 qstruct->pradr = pra;						 
 qstruct->hwadr[0] = 0xFF;					 
 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;				 
 
 return(0);
 
 } 
 
 
 
 
 ARP_DEBUGOUT("Need to use MAC of Default GW\n\r");
 
 
 
 if(machine->defgw == 0)				 
 return(0);
 
 
 for( i=0; i<ARP_TSIZE; i++ ) {
 qstruct = &arp_table[i];
 
 if( qstruct->state == ARP_FREE )
 continue;
 
 if( qstruct->pradr == machine->defgw ) {
 
 
 
 if( qstruct->state < ARP_RESOLVED ) {
 ARP_DEBUGOUT("The Address of Def. GW is not Solved!\n\r");
 return(0);
 }
 
 
 
 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 )				 
 return(0);
 
 
 
 qstruct = &arp_table[i];
 
 qstruct->pradr = machine->defgw;						 
 qstruct->hwadr[0] = 0xFF;					 
 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;				 
 
 return(0);
 
 
 }
 













 
 void arp_manage (void)
 {
 struct arp_entry *qstruct;
 UINT8 i,j;
 static UINT8 aenext=0;
 
 
 
 if( check_timer(arp_timer) )
 return;
 
 init_timer( arp_timer, ARP_MANG_TOUT*TIMERTIC);
 
 
 
 for( i=0; i<ARP_TSIZE; i++ ) {
 
 
 qstruct = &arp_table[aenext];
 
 j = aenext;
 
 
 
 aenext++;
 if(aenext >= ARP_TSIZE)
 aenext = 0;	
 
 if( qstruct->state == ARP_FREE )
 continue;
 
 
 
 if( qstruct->ttl > 0 )				 
 qstruct->ttl --;
 
 if( qstruct->ttl == 0 )	{			 
 
 
 ARP_DEBUGOUT("Found Timed out Entry..\n\r");
 
 if( qstruct->type == ARP_TEMP_IP ) {
 
 
 if( qstruct->state == ARP_RESOLVED ) {	
 ARP_DEBUGOUT("Releasing ARP Entry..\n\r");
 qstruct->state = ARP_FREE;
 continue;
 }
 
 
 
 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;
 }
 
 
 
 ARP_DEBUGOUT("Trying to Resolve dynamic ARP Entry..\n\r");
 
 qstruct->ttl = ARP_RESEND;
 arp_send_req( j );
 qstruct->state = ARP_PENDING;				 
 
 return;
 
 }
 
 
 
 if( qstruct->type == ARP_FIXED_IP ) {
 
 
 
 
 
 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( j );
 
 return;
 
 }
 
 }
 
 }
 
 
 }
 
 
 











 
 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);
 
 
 
 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;						 
 
 ltemp ^= (machine->localip & machine->netmask);			 
 
 if( ltemp )
 return(FALSE);
 
 return(TRUE);
 
 }