middleware/netware/ethernetarp.c File Reference

Go to the source code of this file.

Functions

void F_EthernetArpInit (void)
INT8U F_EthernetArpInUseCheck (void)
INT8U F_EthernetArpAllocate (INT16U UserId)
INT8U F_EthernetArpRelease (INT16U UserId)
INT8U F_EthernetArpEntrySet (INT16U UserId, INT8U *pMacAddress, INT8U *pIpAddress)
INT8U F_EthernetArpCacheAdd (INT8U *pMacAddress, INT8U *pIpAddress)
INT8U F_EthernetArpAddressGet (INT8U *pIpAddress, INT8U *pMacAddress)
INT8U F_EthernetArpRequestSend (INT8U *pIpAddress)
INT8U F_EthernetArpResponseSend (ARP_HEAD *pArpHead)
INT8U F_EthernetArpResponseSend2 (ARP_HEAD *pArpHead)
INT8U F_EthernetArpPacketReceive (ETHBUFFER *pBuffer)
INT8U F_EthernetArpPacketReceive2 (ETHBUFFER *pBuffer)

Variables

ARP_CONTROL ArpCtrl
ARP_ENTRY ArpEntry
ARP_ENTRY ArpCache [ARP_CACHE_SIZE]

Function Documentation

INT8U F_EthernetArpAddressGet ( INT8U *  pIpAddress,
INT8U *  pMacAddress 
)

Definition at line 71 of file ethernetarp.c.

00071                                                                    {
00072     INT32U i;
00073     
00074     for(i=0;i<ARP_CACHE_SIZE;i++){
00075         if((pIpAddress[0]==ArpCache[i].IpAddress[0])&&
00076            (pIpAddress[1]==ArpCache[i].IpAddress[1])&&
00077            (pIpAddress[2]==ArpCache[i].IpAddress[2])&&
00078            (pIpAddress[3]==ArpCache[i].IpAddress[3]))
00079         {
00080             memcpy(pMacAddress,ArpCache[i].MacAddress,ETHERNET_MAC_LENGTH);
00081             break;
00082         }    
00083     }
00084     if(i==ARP_CACHE_SIZE){                    // not found in arp entry cache
00085         F_EthernetArpRequestSend(pIpAddress); // send a request to recogenize
00086         return FALSE;    
00087     }
00088     else return TRUE; 
00089 }

INT8U F_EthernetArpAllocate ( INT16U  UserId  ) 

Definition at line 29 of file ethernetarp.c.

00029                                           {
00030     if(ArpCtrl.InUse==FALSE){
00031         ArpCtrl.InUse=TRUE;        
00032         ArpCtrl.UserId=UserId;
00033         return TRUE;
00034     }
00035     else return FALSE; 
00036 }

INT8U F_EthernetArpCacheAdd ( INT8U *  pMacAddress,
INT8U *  pIpAddress 
)

Definition at line 52 of file ethernetarp.c.

00052                                                                  {
00053     INT32U i;
00054     
00055     for(i=0;i<ARP_CACHE_SIZE;i++){
00056         if((pIpAddress[0]==ArpCache[i].IpAddress[0])&&
00057            (pIpAddress[1]==ArpCache[i].IpAddress[1])&&
00058            (pIpAddress[2]==ArpCache[i].IpAddress[2])&&
00059            (pIpAddress[3]==ArpCache[i].IpAddress[3]))        
00060             break;
00061     }
00062     if(i==ARP_CACHE_SIZE){ // means this ip is a new one...add into arp cache
00063         i=ArpCtrl.CacheIndex;
00064         ArpCtrl.CacheIndex++;
00065         if(ArpCtrl.CacheIndex>=ARP_CACHE_SIZE) ArpCtrl.CacheIndex=0;    
00066     }
00067     memcpy(ArpCache[i].MacAddress,pMacAddress,ETHERNET_MAC_LENGTH);
00068     memcpy(ArpCache[i].IpAddress,pIpAddress,ETHERNET_IP_LENGTH);
00069     return TRUE;    
00070 }

INT8U F_EthernetArpEntrySet ( INT16U  UserId,
INT8U *  pMacAddress,
INT8U *  pIpAddress 
)

Definition at line 44 of file ethernetarp.c.

00044                                                                                {
00045     if((ArpCtrl.InUse==TRUE)&&(ArpCtrl.UserId==UserId)){
00046         memcpy(ArpEntry.MacAddress,pMacAddress,ETHERNET_MAC_LENGTH);
00047         memcpy(ArpEntry.IpAddress,pIpAddress,ETHERNET_IP_LENGTH);
00048         return TRUE;    
00049     }
00050     else return FALSE;    
00051 }

void F_EthernetArpInit ( void   ) 

Definition at line 17 of file ethernetarp.c.

00017                             {
00018     memset(&ArpEntry,0,sizeof(ARP_ENTRY));                 // clear memory of ArpEntry
00019     memset(ArpCache,0,(sizeof(ARP_ENTRY))*ARP_CACHE_SIZE); // clear memory of ArpCache
00020     ArpCtrl.CacheIndex=0;
00021     ArpCtrl.InUse=FALSE;
00022     //ArpCtrl.Id=ID_ETHERNET_ARP;
00023     ArpCtrl.State=EthernetArpIdleState;
00024 }

INT8U F_EthernetArpInUseCheck ( void   ) 

Definition at line 25 of file ethernetarp.c.

00025                                    {
00026     if(ArpCtrl.InUse==TRUE) return TRUE;
00027     else return FALSE; 
00028 }

INT8U F_EthernetArpPacketReceive ( ETHBUFFER *  pBuffer  ) 

Definition at line 234 of file ethernetarp.c.

00234                                                     {
00235     ARP_HEAD *pArpHead=(ARP_HEAD *)pBuffer->pData;
00236     
00237     if((pArpHead->TargetIpAddr[0]==ArpEntry.IpAddress[0])&&
00238        (pArpHead->TargetIpAddr[1]==ArpEntry.IpAddress[1])&&
00239        (pArpHead->TargetIpAddr[2]==ArpEntry.IpAddress[2])&&
00240        (pArpHead->TargetIpAddr[3]==ArpEntry.IpAddress[3])){                 
00241         if(pArpHead->Opcode==F_EthernetUnsignedShortH2N(ARP_OP_REQUEST))
00242             F_EthernetArpResponseSend(pArpHead);
00243         F_EthernetArpCacheAdd(pArpHead->SenderHardwareAddr,pArpHead->SenderIpAddr); // keep this host ip in cache 
00244         return TRUE;
00245     }
00246     else return FALSE; // IP not match  
00247 }

INT8U F_EthernetArpPacketReceive2 ( ETHBUFFER *  pBuffer  ) 

Definition at line 248 of file ethernetarp.c.

00248                                                      {
00249     ARP_HEAD *pArpHead=(ARP_HEAD *)pBuffer->pData;
00250     
00251     #if(DEBUG_ETHERNET_ARP)
00252         printf("\n ******** arp receive********"); 
00253         printf("\n HardwareType       %4x",F_EthernetUnsignedShortH2N(pArpHead->HardwareType));
00254         printf("\n ProtocolType       %4x",F_EthernetUnsignedShortH2N(pArpHead->ProtocolType));
00255         printf("\n HardwareAddrLength %4x",pArpHead->HardwareAddrLength);
00256         printf("\n IpAddrLength       %4x",pArpHead->IpAddrLength);
00257         printf("\n Opcode             %4x",F_EthernetUnsignedShortH2N(pArpHead->Opcode)); 
00258         printf("\n SenderHardwareAddr %2x %2x %2x %2x %2x %2x",pArpHead->SenderHardwareAddr[0]
00259                                                               ,pArpHead->SenderHardwareAddr[1]
00260                                                               ,pArpHead->SenderHardwareAddr[2]
00261                                                               ,pArpHead->SenderHardwareAddr[3]
00262                                                               ,pArpHead->SenderHardwareAddr[4]
00263                                                               ,pArpHead->SenderHardwareAddr[5]);  
00264         printf("\n SenderIpAddr       %2x %2x %2x %2x ",pArpHead->SenderIpAddr[0]
00265                                                        ,pArpHead->SenderIpAddr[1]
00266                                                        ,pArpHead->SenderIpAddr[2]
00267                                                        ,pArpHead->SenderIpAddr[3]);                               
00268         printf("\n TargetHardwareAddr %2x %2x %2x %2x %2x %2x",pArpHead->TargetHardwareAddr[0]
00269                                                               ,pArpHead->TargetHardwareAddr[1]
00270                                                               ,pArpHead->TargetHardwareAddr[2]
00271                                                               ,pArpHead->TargetHardwareAddr[3]
00272                                                               ,pArpHead->TargetHardwareAddr[4]
00273                                                               ,pArpHead->TargetHardwareAddr[5]);                         
00274         printf("\n TargetIpAddr       %2x %2x %2x %2x ",pArpHead->TargetIpAddr[0]
00275                                                        ,pArpHead->TargetIpAddr[1]
00276                                                        ,pArpHead->TargetIpAddr[2]
00277                                                        ,pArpHead->TargetIpAddr[3]);                
00278         printf("\n arp receive done \n");                                                                                            
00279     #endif    
00280     if((pArpHead->HardwareType==F_EthernetUnsignedShortH2N(ARP_HW_ETHER_10M))&&
00281        (pArpHead->ProtocolType==F_EthernetUnsignedShortH2N(ARP_PRTCL_IPV4))&&
00282        (pArpHead->HardwareAddrLength==0x06)&&               
00283        (pArpHead->IpAddrLength==0x04)&&
00284        (pArpHead->Opcode==F_EthernetUnsignedShortH2N(ARP_OP_REQUEST))){
00285            F_EthernetArpResponseSend2(pArpHead);    
00286            F_EthernetArpCacheAdd(pArpHead->SenderHardwareAddr,pArpHead->SenderIpAddr); // keep this host ip in cache                      
00287     }               
00288     return TRUE;
00289 }

INT8U F_EthernetArpRelease ( INT16U  UserId  ) 

Definition at line 37 of file ethernetarp.c.

00037                                          {
00038     if((ArpCtrl.InUse==TRUE)&&(ArpCtrl.UserId==UserId)){
00039         ArpCtrl.InUse=FALSE;  
00040         return TRUE;
00041     }
00042     else return FALSE; 
00043 }

INT8U F_EthernetArpRequestSend ( INT8U *  pIpAddress  ) 

Definition at line 90 of file ethernetarp.c.

00090                                                  {
00091     ETHBUFFER *pBuffer;
00092     ARP_HEAD  *pArpRequest;
00093     INT8U      Boardcast[ETHERNET_MAC_LENGTH]={0xff,0xff,0xff,0xff,0xff,0xff};
00094     
00095     pBuffer=F_EthernetBufferAllocate();
00096     F_EthernetBufferReserve(pBuffer,sizeof(ETHERNET_HEAD)); // 6+6+2=14bytes
00097     pArpRequest=(ARP_HEAD *)F_EthernetBufferPut(pBuffer,sizeof(ARP_HEAD)); // 2+2+1+1+2+1+4+1+4=18bytes      
00098     pArpRequest->HardwareType=F_EthernetUnsignedShortH2N(ARP_HW_ETHER_10M); // put hardware type in buffer
00099     pArpRequest->ProtocolType=F_EthernetUnsignedShortH2N(ETHERNET_P_IP);    // put protocol type in buffer
00100     pArpRequest->HardwareAddrLength=ETHERNET_MAC_LENGTH; // MAC[6]                         // put MAC address length in buffer
00101     pArpRequest->IpAddrLength=ETHERNET_IP_LENGTH;       // xx.xx.xx.xx                    // put IP address length in buffer
00102     pArpRequest->Opcode=F_EthernetUnsignedShortH2N(ARP_OP_REQUEST);         // put ARP opcode in buffer
00103     memcpy(pArpRequest->SenderHardwareAddr,ArpEntry.MacAddress,ETHERNET_MAC_LENGTH); // put my MAC address in buffer
00104     memcpy(pArpRequest->SenderIpAddr,ArpEntry.IpAddress,ETHERNET_IP_LENGTH); // put my MAC address in buffer
00105     memset(pArpRequest->TargetHardwareAddr,0x00,ETHERNET_MAC_LENGTH); // put 0x000000000000 in destination MAC address  
00106     memcpy(pArpRequest->TargetIpAddr,pIpAddress,ETHERNET_IP_LENGTH); // put my MAC address in buffer    
00107     #if(DEBUG_ETHERNET_ARP)
00108         printf("\n HardwareType       %4x",F_EthernetUnsignedShortH2N(pArpRequest->HardwareType));
00109         printf("\n ProtocolType       %4x",F_EthernetUnsignedShortH2N(pArpRequest->ProtocolType));
00110         printf("\n HardwareAddrLength %4x",pArpRequest->HardwareAddrLength);
00111         printf("\n IpAddrLength       %4x",pArpRequest->IpAddrLength);
00112         printf("\n Opcode             %4x",F_EthernetUnsignedShortH2N(pArpRequest->Opcode));  
00113         printf("\n SenderHardwareAddr %2x %2x %2x %2x %2x %2x",pArpRequest->SenderHardwareAddr[0]
00114                                                               ,pArpRequest->SenderHardwareAddr[1]
00115                                                               ,pArpRequest->SenderHardwareAddr[2]
00116                                                               ,pArpRequest->SenderHardwareAddr[3]
00117                                                               ,pArpRequest->SenderHardwareAddr[4]
00118                                                               ,pArpRequest->SenderHardwareAddr[5]);  
00119         printf("\n SenderIpAddr       %2x %2x %2x %2x ",pArpRequest->SenderIpAddr[0]
00120                                                        ,pArpRequest->SenderIpAddr[1]
00121                                                        ,pArpRequest->SenderIpAddr[2]
00122                                                        ,pArpRequest->SenderIpAddr[3]);
00123         printf("\n TargetHardwareAddr %2x %2x %2x %2x %2x %2x",pArpRequest->TargetHardwareAddr[0]
00124                                                               ,pArpRequest->TargetHardwareAddr[1]
00125                                                               ,pArpRequest->TargetHardwareAddr[2]
00126                                                               ,pArpRequest->TargetHardwareAddr[3]
00127                                                               ,pArpRequest->TargetHardwareAddr[4]
00128                                                               ,pArpRequest->TargetHardwareAddr[5]);                         
00129         printf("\n TargetIpAddr       %2x %2x %2x %2x ",pArpRequest->TargetIpAddr[0]
00130                                                        ,pArpRequest->TargetIpAddr[1]
00131                                                        ,pArpRequest->TargetIpAddr[2]
00132                                                        ,pArpRequest->TargetIpAddr[3]);                                                              
00133     #endif
00134     // put destination IP address in buffer
00135     F_EthernetSend(pBuffer,Boardcast,ETHERNET_P_ARP);
00136     return TRUE;
00137 }

INT8U F_EthernetArpResponseSend ( ARP_HEAD *  pArpHead  ) 

Definition at line 138 of file ethernetarp.c.

00138                                                    { 
00139     ETHBUFFER *pBuffer;
00140     ARP_HEAD *pArpResponse;
00141 
00142     pBuffer=F_EthernetBufferAllocate();
00143     F_EthernetBufferReserve(pBuffer,ETHERNET_HEAD_LENGTH);
00144     pArpResponse=(ARP_HEAD *)F_EthernetBufferPut(pBuffer,sizeof(ARP_HEAD));       
00145     pArpResponse->HardwareType=F_EthernetUnsignedShortH2N(ARP_HW_ETHER_10M);
00146     pArpResponse->ProtocolType=F_EthernetUnsignedShortH2N(ARP_PRTCL_IPV4);
00147     pArpResponse->HardwareAddrLength=0x06;
00148     pArpResponse->IpAddrLength=0x04;
00149     pArpResponse->Opcode=F_EthernetUnsignedShortH2N(ARP_OP_REPLY);
00150     memcpy((INT8U*)pArpResponse->SenderHardwareAddr,ArpEntry.MacAddress,ETHERNET_MAC_LENGTH);
00151     memcpy((INT8U*)pArpResponse->SenderIpAddr,pArpHead->TargetIpAddr,ETHERNET_IP_LENGTH); //?? ans...this TargetIpAddr is in previous buffer...no overlap
00152     memcpy((INT8U*)pArpResponse->TargetHardwareAddr,(INT8U*)pArpHead->SenderHardwareAddr,ETHERNET_MAC_LENGTH);
00153     memcpy((INT8U*)pArpResponse->TargetIpAddr,pArpHead->SenderIpAddr,ETHERNET_IP_LENGTH); //??  ans...this TargetIpAddr is in previous buffer...no overlap
00154     #if(DEBUG_ETHERNET_ARP)
00155         printf("\n HardwareType       %4x",F_EthernetUnsignedShortH2N(pArpResponse->HardwareType));
00156         printf("\n ProtocolType       %4x",F_EthernetUnsignedShortH2N(pArpResponse->ProtocolType));
00157         printf("\n HardwareAddrLength %4x",pArpResponse->HardwareAddrLength);
00158         printf("\n IpAddrLength       %4x",pArpResponse->IpAddrLength);
00159         printf("\n Opcode             %4x",F_EthernetUnsignedShortH2N(pArpResponse->Opcode));  
00160         printf("\n SenderHardwareAddr %2x %2x %2x %2x %2x %2x",pArpResponse->SenderHardwareAddr[0]
00161                                                               ,pArpResponse->SenderHardwareAddr[1]
00162                                                               ,pArpResponse->SenderHardwareAddr[2]
00163                                                               ,pArpResponse->SenderHardwareAddr[3]
00164                                                               ,pArpResponse->SenderHardwareAddr[4]
00165                                                               ,pArpResponse->SenderHardwareAddr[5]);  
00166         printf("\n SenderIpAddr       %2x %2x %2x %2x ",pArpResponse->SenderIpAddr[0]
00167                                                        ,pArpResponse->SenderIpAddr[1]
00168                                                        ,pArpResponse->SenderIpAddr[2]
00169                                                        ,pArpResponse->SenderIpAddr[3]);                
00170         printf("\n TargetHardwareAddr %2x %2x %2x %2x %2x %2x",pArpResponse->TargetHardwareAddr[0]
00171                                                               ,pArpResponse->TargetHardwareAddr[1]
00172                                                               ,pArpResponse->TargetHardwareAddr[2]
00173                                                               ,pArpResponse->TargetHardwareAddr[3]
00174                                                               ,pArpResponse->TargetHardwareAddr[4]
00175                                                               ,pArpResponse->TargetHardwareAddr[5]);                         
00176         printf("\n TargetIpAddr       %2x %2x %2x %2x ",pArpResponse->TargetIpAddr[0]
00177                                                        ,pArpResponse->TargetIpAddr[1]
00178                                                        ,pArpResponse->TargetIpAddr[2]
00179                                                        ,pArpResponse->TargetIpAddr[3]);                
00180         
00181     #endif
00182     F_EthernetSend(pBuffer,pArpHead->SenderHardwareAddr,ETHERNET_P_ARP);
00183     return TRUE;    
00184 }

INT8U F_EthernetArpResponseSend2 ( ARP_HEAD *  pArpHead  ) 

Definition at line 185 of file ethernetarp.c.

00185                                                     { 
00186     ETHBUFFER *pBuffer;
00187     ARP_HEAD *pArpResponse;
00188 
00189     pBuffer=F_EthernetBufferAllocate();
00190     F_EthernetBufferReserve(pBuffer,ETHERNET_HEAD_LENGTH);
00191     pArpResponse=(ARP_HEAD *)F_EthernetBufferPut(pBuffer,sizeof(ARP_HEAD));       
00192     pArpResponse->HardwareType=F_EthernetUnsignedShortH2N(ARP_HW_ETHER_10M);
00193     pArpResponse->ProtocolType=F_EthernetUnsignedShortH2N(ARP_PRTCL_IPV4);
00194     pArpResponse->HardwareAddrLength=0x06;
00195     pArpResponse->IpAddrLength=0x04;
00196     pArpResponse->Opcode=F_EthernetUnsignedShortH2N(ARP_OP_REPLY);
00197     memcpy((INT8U*)pArpResponse->SenderHardwareAddr,ArpEntry.MacAddress,ETHERNET_MAC_LENGTH);
00198     memcpy((INT8U*)pArpResponse->SenderIpAddr,ArpEntry.IpAddress,ETHERNET_IP_LENGTH); //?? ans...this TargetIpAddr is in previous buffer...no overlap    
00199     memcpy((INT8U*)pArpResponse->TargetHardwareAddr,(INT8U*)pArpHead->SenderHardwareAddr,ETHERNET_MAC_LENGTH);
00200     memcpy((INT8U*)pArpResponse->TargetIpAddr,pArpHead->SenderIpAddr,ETHERNET_IP_LENGTH); //?? ans...this TargetIpAddr is in previous buffer...no overlap        
00201     #if(DEBUG_ETHERNET_ARP)    
00202         printf("\n ******** arp response send 2********");
00203         printf("\n HardwareType       %4x",F_EthernetUnsignedShortH2N(pArpResponse->HardwareType));
00204         printf("\n ProtocolType       %4x",F_EthernetUnsignedShortH2N(pArpResponse->ProtocolType));
00205         printf("\n HardwareAddrLength %4x",pArpResponse->HardwareAddrLength);
00206         printf("\n IpAddrLength       %4x",pArpResponse->IpAddrLength);
00207         printf("\n Opcode             %4x",F_EthernetUnsignedShortH2N(pArpResponse->Opcode));  
00208         printf("\n SenderHardwareAddr %2x %2x %2x %2x %2x %2x",pArpResponse->SenderHardwareAddr[0]
00209                                                               ,pArpResponse->SenderHardwareAddr[1]
00210                                                               ,pArpResponse->SenderHardwareAddr[2]
00211                                                               ,pArpResponse->SenderHardwareAddr[3]
00212                                                               ,pArpResponse->SenderHardwareAddr[4]
00213                                                               ,pArpResponse->SenderHardwareAddr[5]);  
00214         printf("\n SenderIpAddr       %2x %2x %2x %2x ",pArpResponse->SenderIpAddr[0]
00215                                                        ,pArpResponse->SenderIpAddr[1]
00216                                                        ,pArpResponse->SenderIpAddr[2]
00217                                                        ,pArpResponse->SenderIpAddr[3]);                        
00218         printf("\n TargetHardwareAddr %2x %2x %2x %2x %2x %2x",pArpResponse->TargetHardwareAddr[0]
00219                                                               ,pArpResponse->TargetHardwareAddr[1]
00220                                                               ,pArpResponse->TargetHardwareAddr[2]
00221                                                               ,pArpResponse->TargetHardwareAddr[3]
00222                                                               ,pArpResponse->TargetHardwareAddr[4]
00223                                                               ,pArpResponse->TargetHardwareAddr[5]);                         
00224         printf("\n TargetIpAddr       %2x %2x %2x %2x ",pArpResponse->TargetIpAddr[0]
00225                                                        ,pArpResponse->TargetIpAddr[1]
00226                                                        ,pArpResponse->TargetIpAddr[2]
00227                                                        ,pArpResponse->TargetIpAddr[3]);                                                                      
00228         printf("\n arp transmition done \n");                                     
00229                                                                                                                                             
00230     #endif
00231     F_EthernetSend(pBuffer,pArpHead->SenderHardwareAddr,ETHERNET_P_ARP);
00232     return TRUE;    
00233 }

Variable Documentation

ARP_ENTRY ArpCache[ARP_CACHE_SIZE]

Definition at line 15 of file ethernetarp.c.

ARP_CONTROL ArpCtrl

Definition at line 13 of file ethernetarp.c.

ARP_ENTRY ArpEntry

Definition at line 14 of file ethernetarp.c.

Generated on Tue Sep 2 08:45:41 2008 for A Simple operation System using S3C2410 by  doxygen 1.5.6