git.sur5r.net Git - freertos/blob - Demo/Common/ethernet/FreeRTOS-uIP/uip_arp.c

   1 /**\r
   2  * \addtogroup uip\r
   3  * @{\r
   4  */\r
   5 \r
   6 /**\r
   7  * \defgroup uiparp uIP Address Resolution Protocol\r
   8  * @{\r
   9  *\r
  10  * The Address Resolution Protocol ARP is used for mapping between IP\r
  11  * addresses and link level addresses such as the Ethernet MAC\r
  12  * addresses. ARP uses broadcast queries to ask for the link level\r
  13  * address of a known IP address and the host which is configured with\r
  14  * the IP address for which the query was meant, will respond with its\r
  15  * link level address.\r
  16  *\r
  17  * \note This ARP implementation only supports Ethernet.\r
  18  */\r
  19 \r
  20 /**\r
  21  * \file\r
  22  * Implementation of the ARP Address Resolution Protocol.\r
  23  * \author Adam Dunkels <adam@dunkels.com>\r
  24  *\r
  25  */\r
  26 \r
  27 /*\r
  28  * Copyright (c) 2001-2003, Adam Dunkels.\r
  29  * All rights reserved.\r
  30  *\r
  31  * Redistribution and use in source and binary forms, with or without\r
  32  * modification, are permitted provided that the following conditions\r
  33  * are met:\r
  34  * 1. Redistributions of source code must retain the above copyright\r
  35  *    notice, this list of conditions and the following disclaimer.\r
  36  * 2. Redistributions in binary form must reproduce the above copyright\r
  37  *    notice, this list of conditions and the following disclaimer in the\r
  38  *    documentation and/or other materials provided with the distribution.\r
  39  * 3. The name of the author may not be used to endorse or promote\r
  40  *    products derived from this software without specific prior\r
  41  *    written permission.\r
  42  *\r
  43  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS\r
  44  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
  45  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\r
  47  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\r
  49  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
  50  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
  51  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\r
  52  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r
  53  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  54  *\r
  55  * This file is part of the uIP TCP/IP stack.\r
  56  *\r
  57  * $Id: uip_arp.c,v 1.8 2006/06/02 23:36:21 adam Exp $\r
  58  *\r
  59  */\r
  60 #include "uip_arp.h"\r
  61 \r
  62 #include <string.h>\r
  63 \r
  64 #ifdef __ICCARM__\r
  65         #pragma pack( 1 )\r
  66 #endif\r
  67 struct arp_hdr\r
  68 {\r
  69         struct uip_eth_hdr      ethhdr;\r
  70         u16_t                           hwtype;\r
  71         u16_t                           protocol;\r
  72         u8_t                            hwlen;\r
  73         u8_t                            protolen;\r
  74         u16_t                           opcode;\r
  75         struct uip_eth_addr shwaddr;\r
  76         u16_t                           sipaddr[2];\r
  77         struct uip_eth_addr dhwaddr;\r
  78         u16_t                           dipaddr[2];\r
  79 } PACK_STRUCT_END;\r
  80 \r
  81 #ifdef __ICCARM__\r
  82         #pragma pack()\r
  83 #endif\r
  84 #ifdef __ICCARM__\r
  85         #pragma pack( 1 )\r
  86 #endif\r
  87 struct ethip_hdr\r
  88 {\r
  89         struct uip_eth_hdr      ethhdr;\r
  90 \r
  91         /* IP header. */\r
  92         u8_t                            vhl, tos, len[2], ipid[2], ipoffset[2], ttl, proto;\r
  93         u16_t                           ipchksum;\r
  94         u16_t                           srcipaddr[2], destipaddr[2];\r
  95 } PACK_STRUCT_END;\r
  96 \r
  97 #ifdef __ICCARM__\r
  98         #pragma pack()\r
  99 #endif\r
 100 #define ARP_REQUEST             1\r
 101 #define ARP_REPLY               2\r
 102 \r
 103 #define ARP_HWTYPE_ETH  1\r
 104 \r
 105 struct arp_entry\r
 106 {\r
 107         u16_t                           ipaddr[2];\r
 108         struct uip_eth_addr ethaddr;\r
 109         u8_t                            time;\r
 110 };\r
 111 \r
 112 static const struct uip_eth_addr        broadcast_ethaddr = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };\r
 113 static const u16_t                                      broadcast_ipaddr[2] = { 0xffff, 0xffff };\r
 114 \r
 115 static struct arp_entry                         arp_table[UIP_ARPTAB_SIZE];\r
 116 static u16_t                                            ipaddr[2];\r
 117 static u8_t                                                     i, c;\r
 118 \r
 119 static u8_t                                                     arptime;\r
 120 static u8_t                                                     tmpage;\r
 121 \r
 122 #define BUF             ( ( struct arp_hdr * ) &uip_buf[0] )\r
 123 #define IPBUF   ( ( struct ethip_hdr * ) &uip_buf[0] )\r
 124 \r
 125 /*-----------------------------------------------------------------------------------*/\r
 126 \r
 127 /**\r
 128  * Initialize the ARP module.\r
 129  *\r
 130  */\r
 131 \r
 132 /*-----------------------------------------------------------------------------------*/\r
 133 void uip_arp_init( void )\r
 134 {\r
 135         for( i = 0; i < UIP_ARPTAB_SIZE; ++i )\r
 136         {\r
 137                 memset( arp_table[i].ipaddr, 0, 4 );\r
 138         }\r
 139 }\r
 140 \r
 141 /*-----------------------------------------------------------------------------------*/\r
 142 \r
 143 /**\r
 144  * Periodic ARP processing function.\r
 145  *\r
 146  * This function performs periodic timer processing in the ARP module\r
 147  * and should be called at regular intervals. The recommended interval\r
 148  * is 10 seconds between the calls.\r
 149  *\r
 150  */\r
 151 \r
 152 /*-----------------------------------------------------------------------------------*/\r
 153 void uip_arp_timer( void )\r
 154 {\r
 155         struct arp_entry        *tabptr;\r
 156 \r
 157         ++arptime;\r
 158         for( i = 0; i < UIP_ARPTAB_SIZE; ++i )\r
 159         {\r
 160                 tabptr = &arp_table[i];\r
 161                 if( (tabptr->ipaddr[0] | tabptr->ipaddr[1]) != 0 && arptime - tabptr->time >= UIP_ARP_MAXAGE )\r
 162                 {\r
 163                         memset( tabptr->ipaddr, 0, 4 );\r
 164                 }\r
 165         }\r
 166 }\r
 167 \r
 168 /*-----------------------------------------------------------------------------------*/\r
 169 static void uip_arp_update( u16_t *ipaddr, struct uip_eth_addr *ethaddr )\r
 170 {\r
 171         register struct arp_entry       *tabptr;\r
 172 \r
 173         /* Walk through the ARP mapping table and try to find an entry to\r
 174      update. If none is found, the IP -> MAC address mapping is\r
 175      inserted in the ARP table. */\r
 176         for( i = 0; i < UIP_ARPTAB_SIZE; ++i )\r
 177         {\r
 178                 tabptr = &arp_table[i];\r
 179 \r
 180                 /* Only check those entries that are actually in use. */\r
 181                 if( tabptr->ipaddr[0] != 0 && tabptr->ipaddr[1] != 0 )\r
 182                 {\r
 183                         /* Check if the source IP address of the incoming packet matches\r
 184          the IP address in this ARP table entry. */\r
 185                         if( ipaddr[0] == tabptr->ipaddr[0] && ipaddr[1] == tabptr->ipaddr[1] )\r
 186                         {\r
 187                                 /* An old entry found, update this and return. */\r
 188                                 memcpy( tabptr->ethaddr.addr, ethaddr->addr, 6 );\r
 189                                 tabptr->time = arptime;\r
 190 \r
 191                                 return;\r
 192                         }\r
 193                 }\r
 194         }\r
 195 \r
 196         /* If we get here, no existing ARP table entry was found, so we\r
 197      create one. */\r
 198 \r
 199         /* First, we try to find an unused entry in the ARP table. */\r
 200         for( i = 0; i < UIP_ARPTAB_SIZE; ++i )\r
 201         {\r
 202                 tabptr = &arp_table[i];\r
 203                 if( tabptr->ipaddr[0] == 0 && tabptr->ipaddr[1] == 0 )\r
 204                 {\r
 205                         break;\r
 206                 }\r
 207         }\r
 208 \r
 209         /* If no unused entry is found, we try to find the oldest entry and\r
 210      throw it away. */\r
 211         if( i == UIP_ARPTAB_SIZE )\r
 212         {\r
 213                 tmpage = 0;\r
 214                 c = 0;\r
 215                 for( i = 0; i < UIP_ARPTAB_SIZE; ++i )\r
 216                 {\r
 217                         tabptr = &arp_table[i];\r
 218                         if( arptime - tabptr->time > tmpage )\r
 219                         {\r
 220                                 tmpage = arptime - tabptr->time;\r
 221                                 c = i;\r
 222                         }\r
 223                 }\r
 224 \r
 225                 i = c;\r
 226                 tabptr = &arp_table[i];\r
 227         }\r
 228 \r
 229         /* Now, i is the ARP table entry which we will fill with the new\r
 230      information. */\r
 231         memcpy( tabptr->ipaddr, ipaddr, 4 );\r
 232         memcpy( tabptr->ethaddr.addr, ethaddr->addr, 6 );\r
 233         tabptr->time = arptime;\r
 234 }\r
 235 \r
 236 /*-----------------------------------------------------------------------------------*/\r
 237 \r
 238 /**\r
 239  * ARP processing for incoming IP packets\r
 240  *\r
 241  * This function should be called by the device driver when an IP\r
 242  * packet has been received. The function will check if the address is\r
 243  * in the ARP cache, and if so the ARP cache entry will be\r
 244  * refreshed. If no ARP cache entry was found, a new one is created.\r
 245  *\r
 246  * This function expects an IP packet with a prepended Ethernet header\r
 247  * in the uip_buf[] buffer, and the length of the packet in the global\r
 248  * variable uip_len.\r
 249  */\r
 250 \r
 251 /*-----------------------------------------------------------------------------------*/\r
 252 #if 1\r
 253 void uip_arp_ipin( void )\r
 254 {\r
 255         uip_len -= sizeof( struct uip_eth_hdr );\r
 256 \r
 257         /* Only insert/update an entry if the source IP address of the\r
 258      incoming IP packet comes from a host on the local network. */\r
 259         if( (IPBUF->srcipaddr[0] & uip_netmask[0]) != (uip_hostaddr[0] & uip_netmask[0]) )\r
 260         {\r
 261                 return;\r
 262         }\r
 263 \r
 264         if( (IPBUF->srcipaddr[1] & uip_netmask[1]) != (uip_hostaddr[1] & uip_netmask[1]) )\r
 265         {\r
 266                 return;\r
 267         }\r
 268 \r
 269         uip_arp_update( IPBUF->srcipaddr, &(IPBUF->ethhdr.src) );\r
 270 \r
 271         return;\r
 272 }\r
 273 \r
 274 #endif /* 0 */\r
 275 \r
 276 /*-----------------------------------------------------------------------------------*/\r
 277 \r
 278 /**\r
 279  * ARP processing for incoming ARP packets.\r
 280  *\r
 281  * This function should be called by the device driver when an ARP\r
 282  * packet has been received. The function will act differently\r
 283  * depending on the ARP packet type: if it is a reply for a request\r
 284  * that we previously sent out, the ARP cache will be filled in with\r
 285  * the values from the ARP reply. If the incoming ARP packet is an ARP\r
 286  * request for our IP address, an ARP reply packet is created and put\r
 287  * into the uip_buf[] buffer.\r
 288  *\r
 289  * When the function returns, the value of the global variable uip_len\r
 290  * indicates whether the device driver should send out a packet or\r
 291  * not. If uip_len is zero, no packet should be sent. If uip_len is\r
 292  * non-zero, it contains the length of the outbound packet that is\r
 293  * present in the uip_buf[] buffer.\r
 294  *\r
 295  * This function expects an ARP packet with a prepended Ethernet\r
 296  * header in the uip_buf[] buffer, and the length of the packet in the\r
 297  * global variable uip_len.\r
 298  */\r
 299 \r
 300 /*-----------------------------------------------------------------------------------*/\r
 301 void uip_arp_arpin( void )\r
 302 {\r
 303         if( uip_len < sizeof(struct arp_hdr) )\r
 304         {\r
 305                 uip_len = 0;\r
 306                 return;\r
 307         }\r
 308 \r
 309         uip_len = 0;\r
 310 \r
 311         switch( BUF->opcode )\r
 312         {\r
 313                 case HTONS( ARP_REQUEST ):\r
 314                         /* ARP request. If it asked for our address, we send out a\r
 315        reply. */\r
 316                         if( uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr) )\r
 317                         {\r
 318                                 /* First, we register the one who made the request in our ARP\r
 319          table, since it is likely that we will do more communication\r
 320          with this host in the future. */\r
 321                                 uip_arp_update( BUF->sipaddr, &BUF->shwaddr );\r
 322 \r
 323                                 /* The reply opcode is 2. */\r
 324                                 BUF->opcode = HTONS( 2 );\r
 325 \r
 326                                 memcpy( BUF->dhwaddr.addr, BUF->shwaddr.addr, 6 );\r
 327                                 memcpy( BUF->shwaddr.addr, uip_ethaddr.addr, 6 );\r
 328                                 memcpy( BUF->ethhdr.src.addr, uip_ethaddr.addr, 6 );\r
 329                                 memcpy( BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6 );\r
 330 \r
 331                                 BUF->dipaddr[0] = BUF->sipaddr[0];\r
 332                                 BUF->dipaddr[1] = BUF->sipaddr[1];\r
 333                                 BUF->sipaddr[0] = uip_hostaddr[0];\r
 334                                 BUF->sipaddr[1] = uip_hostaddr[1];\r
 335 \r
 336                                 BUF->ethhdr.type = HTONS( UIP_ETHTYPE_ARP );\r
 337                                 uip_len = sizeof( struct arp_hdr );\r
 338                         }\r
 339 \r
 340                         break;\r
 341 \r
 342                 case HTONS( ARP_REPLY ):\r
 343                         /* ARP reply. We insert or update the ARP table if it was meant\r
 344        for us. */\r
 345                         if( uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr) )\r
 346                         {\r
 347                                 uip_arp_update( BUF->sipaddr, &BUF->shwaddr );\r
 348                         }\r
 349 \r
 350                         break;\r
 351         }\r
 352 \r
 353         return;\r
 354 }\r
 355 \r
 356 /*-----------------------------------------------------------------------------------*/\r
 357 \r
 358 /**\r
 359  * Prepend Ethernet header to an outbound IP packet and see if we need\r
 360  * to send out an ARP request.\r
 361  *\r
 362  * This function should be called before sending out an IP packet. The\r
 363  * function checks the destination IP address of the IP packet to see\r
 364  * what Ethernet MAC address that should be used as a destination MAC\r
 365  * address on the Ethernet.\r
 366  *\r
 367  * If the destination IP address is in the local network (determined\r
 368  * by logical ANDing of netmask and our IP address), the function\r
 369  * checks the ARP cache to see if an entry for the destination IP\r
 370  * address is found. If so, an Ethernet header is prepended and the\r
 371  * function returns. If no ARP cache entry is found for the\r
 372  * destination IP address, the packet in the uip_buf[] is replaced by\r
 373  * an ARP request packet for the IP address. The IP packet is dropped\r
 374  * and it is assumed that they higher level protocols (e.g., TCP)\r
 375  * eventually will retransmit the dropped packet.\r
 376  *\r
 377  * If the destination IP address is not on the local network, the IP\r
 378  * address of the default router is used instead.\r
 379  *\r
 380  * When the function returns, a packet is present in the uip_buf[]\r
 381  * buffer, and the length of the packet is in the global variable\r
 382  * uip_len.\r
 383  */\r
 384 \r
 385 /*-----------------------------------------------------------------------------------*/\r
 386 void uip_arp_out( void )\r
 387 {\r
 388         struct arp_entry        *tabptr;\r
 389 \r
 390         /* Find the destination IP address in the ARP table and construct\r
 391      the Ethernet header. If the destination IP addres isn't on the\r
 392      local network, we use the default router's IP address instead.\r
 393 \r
 394      If not ARP table entry is found, we overwrite the original IP\r
 395      packet with an ARP request for the IP address. */\r
 396 \r
 397         /* First check if destination is a local broadcast. */\r
 398         if( uip_ipaddr_cmp(IPBUF->destipaddr, broadcast_ipaddr) )\r
 399         {\r
 400                 memcpy( IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6 );\r
 401         }\r
 402         else\r
 403         {\r
 404                 /* Check if the destination address is on the local network. */\r
 405                 if( !uip_ipaddr_maskcmp(IPBUF->destipaddr, uip_hostaddr, uip_netmask) )\r
 406                 {\r
 407                         /* Destination address was not on the local network, so we need to\r
 408          use the default router's IP address instead of the destination\r
 409          address when determining the MAC address. */\r
 410                         uip_ipaddr_copy( ipaddr, uip_draddr );\r
 411                 }\r
 412                 else\r
 413                 {\r
 414                         /* Else, we use the destination IP address. */\r
 415                         uip_ipaddr_copy( ipaddr, IPBUF->destipaddr );\r
 416                 }\r
 417 \r
 418                 for( i = 0; i < UIP_ARPTAB_SIZE; ++i )\r
 419                 {\r
 420                         tabptr = &arp_table[i];\r
 421                         if( uip_ipaddr_cmp(ipaddr, tabptr->ipaddr) )\r
 422                         {\r
 423                                 break;\r
 424                         }\r
 425                 }\r
 426 \r
 427                 if( i == UIP_ARPTAB_SIZE )\r
 428                 {\r
 429                         /* The destination address was not in our ARP table, so we\r
 430          overwrite the IP packet with an ARP request. */\r
 431                         memset( BUF->ethhdr.dest.addr, 0xff, 6 );\r
 432                         memset( BUF->dhwaddr.addr, 0x00, 6 );\r
 433                         memcpy( BUF->ethhdr.src.addr, uip_ethaddr.addr, 6 );\r
 434                         memcpy( BUF->shwaddr.addr, uip_ethaddr.addr, 6 );\r
 435 \r
 436                         uip_ipaddr_copy( BUF->dipaddr, ipaddr );\r
 437                         uip_ipaddr_copy( BUF->sipaddr, uip_hostaddr );\r
 438                         BUF->opcode = HTONS( ARP_REQUEST ); /* ARP request. */\r
 439                         BUF->hwtype = HTONS( ARP_HWTYPE_ETH );\r
 440                         BUF->protocol = HTONS( UIP_ETHTYPE_IP );\r
 441                         BUF->hwlen = 6;\r
 442                         BUF->protolen = 4;\r
 443                         BUF->ethhdr.type = HTONS( UIP_ETHTYPE_ARP );\r
 444 \r
 445                         uip_appdata = &uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN];\r
 446 \r
 447                         uip_len = sizeof( struct arp_hdr );\r
 448                         return;\r
 449                 }\r
 450 \r
 451                 /* Build an ethernet header. */\r
 452                 memcpy( IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6 );\r
 453         }\r
 454 \r
 455         memcpy( IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6 );\r
 456 \r
 457         IPBUF->ethhdr.type = HTONS( UIP_ETHTYPE_IP );\r
 458 \r
 459         uip_len += sizeof( struct uip_eth_hdr );\r
 460 }\r
 461 \r
 462 /*-----------------------------------------------------------------------------------*/\r
 463 \r
 464 /** @} */\r
 465 \r
 466 /** @} */\r