Warning, cross-references for /kernel/lwip/netif/etharp.c need to be fixed.
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046 #include "lwip/opt.h"
0047
0048 #if LWIP_ARP
0049
0050 #include "lwip/inet.h"
0051 #include "lwip/ip.h"
0052 #include "lwip/stats.h"
0053 #include "lwip/snmp.h"
0054 #include "lwip/dhcp.h"
0055 #include "lwip/autoip.h"
0056 #include "netif/etharp.h"
0057
0058 #if PPPOE_SUPPORT
0059 #include "netif/ppp_oe.h"
0060 #endif
0061
0062 #include <string.h>
0063
0064
0065
0066
0067
0068 #define ARP_MAXAGE 240
0069
0070
0071
0072
0073
0074
0075
0076 #define ARP_MAXPENDING 2
0077
0078 #define HWTYPE_ETHERNET 1
0079
0080 #define ARPH_HWLEN(hdr) (ntohs((hdr)->_hwlen_protolen) >> 8)
0081 #define ARPH_PROTOLEN(hdr) (ntohs((hdr)->_hwlen_protolen) & 0xff)
0082
0083 #define ARPH_HWLEN_SET(hdr, len) (hdr)->_hwlen_protolen = htons(ARPH_PROTOLEN(hdr) | ((len) << 8))
0084 #define ARPH_PROTOLEN_SET(hdr, len) (hdr)->_hwlen_protolen = htons((len) | (ARPH_HWLEN(hdr) << 8))
0085
0086 enum etharp_state {
0087 ETHARP_STATE_EMPTY = 0,
0088 ETHARP_STATE_PENDING,
0089 ETHARP_STATE_STABLE
0090 };
0091
0092 struct etharp_entry {
0093 #if ARP_QUEUEING
0094
0095
0096
0097 struct etharp_q_entry *q;
0098 #endif
0099 struct ip_addr ipaddr;
0100 struct eth_addr ethaddr;
0101 enum etharp_state state;
0102 u8_t ctime;
0103 struct netif *netif;
0104 };
0105
0106 const struct eth_addr ethbroadcast = {{0xff,0xff,0xff,0xff,0xff,0xff}};
0107 const struct eth_addr ethzero = {{0,0,0,0,0,0}};
0108 static struct etharp_entry arp_table[ARP_TABLE_SIZE];
0109 #if !LWIP_NETIF_HWADDRHINT
0110 static u8_t etharp_cached_entry;
0111 #endif
0112
0113
0114
0115
0116 #define ETHARP_TRY_HARD 1
0117 #define ETHARP_FIND_ONLY 2
0118
0119 #if LWIP_NETIF_HWADDRHINT
0120 #define NETIF_SET_HINT(netif, hint) if (((netif) != NULL) && ((netif)->addr_hint != NULL)) \
0121 *((netif)->addr_hint) = (hint);
0122 static s8_t find_entry(struct ip_addr *ipaddr, u8_t flags, struct netif *netif);
0123 #else
0124 static s8_t find_entry(struct ip_addr *ipaddr, u8_t flags);
0125 #endif
0126
0127 static err_t update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *ethaddr, u8_t flags);
0128
0129
0130
0131 #if (LWIP_ARP && (ARP_TABLE_SIZE > 0x7f))
0132 #error "If you want to use ARP, ARP_TABLE_SIZE must fit in an s8_t, so, you have to reduce it in your lwipopts.h"
0133 #endif
0134
0135
0136 #if ARP_QUEUEING
0137
0138
0139
0140
0141
0142 static void
0143 free_etharp_q(struct etharp_q_entry *q)
0144 {
0145 struct etharp_q_entry *r;
0146 LWIP_ASSERT("q != NULL", q != NULL);
0147 LWIP_ASSERT("q->p != NULL", q->p != NULL);
0148 while (q) {
0149 r = q;
0150 q = q->next;
0151 LWIP_ASSERT("r->p != NULL", (r->p != NULL));
0152 pbuf_free(r->p);
0153 memp_free(MEMP_ARP_QUEUE, r);
0154 }
0155 }
0156 #endif
0157
0158
0159
0160
0161
0162
0163
0164 void
0165 etharp_tmr(void)
0166 {
0167 u8_t i;
0168
0169 LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer\n"));
0170
0171 for (i = 0; i < ARP_TABLE_SIZE; ++i) {
0172 arp_table[i].ctime++;
0173 if (((arp_table[i].state == ETHARP_STATE_STABLE) &&
0174 (arp_table[i].ctime >= ARP_MAXAGE)) ||
0175 ((arp_table[i].state == ETHARP_STATE_PENDING) &&
0176 (arp_table[i].ctime >= ARP_MAXPENDING))) {
0177
0178 LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired %s entry %"U16_F".\n",
0179 arp_table[i].state == ETHARP_STATE_STABLE ? "stable" : "pending", (u16_t)i));
0180
0181
0182 snmp_delete_arpidx_tree(arp_table[i].netif, &arp_table[i].ipaddr);
0183 #if ARP_QUEUEING
0184
0185 if (arp_table[i].q != NULL) {
0186
0187 LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: freeing entry %"U16_F", packet queue %p.\n", (u16_t)i, (void *)(arp_table[i].q)));
0188 free_etharp_q(arp_table[i].q);
0189 arp_table[i].q = NULL;
0190 }
0191 #endif
0192
0193 arp_table[i].state = ETHARP_STATE_EMPTY;
0194 }
0195 #if ARP_QUEUEING
0196
0197 if (arp_table[i].state == ETHARP_STATE_PENDING) {
0198
0199 }
0200 #endif
0201 }
0202 }
0203
0204
0205
0206
0207
0208
0209
0210
0211
0212
0213
0214
0215
0216
0217
0218
0219
0220
0221
0222
0223
0224
0225
0226 static s8_t
0227 #if LWIP_NETIF_HWADDRHINT
0228 find_entry(struct ip_addr *ipaddr, u8_t flags, struct netif *netif)
0229 #else
0230 find_entry(struct ip_addr *ipaddr, u8_t flags)
0231 #endif
0232 {
0233 s8_t old_pending = ARP_TABLE_SIZE, old_stable = ARP_TABLE_SIZE;
0234 s8_t empty = ARP_TABLE_SIZE;
0235 u8_t i = 0, age_pending = 0, age_stable = 0;
0236 #if ARP_QUEUEING
0237
0238 s8_t old_queue = ARP_TABLE_SIZE;
0239
0240 u8_t age_queue = 0;
0241 #endif
0242
0243
0244
0245 if (ipaddr) {
0246
0247 #if LWIP_NETIF_HWADDRHINT
0248 if ((netif != NULL) && (netif->addr_hint != NULL)) {
0249
0250 u8_t per_pcb_cache = *(netif->addr_hint);
0251 if ((per_pcb_cache < ARP_TABLE_SIZE) && arp_table[per_pcb_cache].state == ETHARP_STATE_STABLE) {
0252
0253 if (ip_addr_cmp(ipaddr, &arp_table[per_pcb_cache].ipaddr)) {
0254
0255 ETHARP_STATS_INC(etharp.cachehit);
0256 return per_pcb_cache;
0257 }
0258 }
0259 }
0260 #else
0261 if (arp_table[etharp_cached_entry].state == ETHARP_STATE_STABLE) {
0262
0263 if (ip_addr_cmp(ipaddr, &arp_table[etharp_cached_entry].ipaddr)) {
0264
0265 ETHARP_STATS_INC(etharp.cachehit);
0266 return etharp_cached_entry;
0267 }
0268 }
0269 #endif
0270 }
0271
0272
0273
0274
0275
0276
0277
0278
0279
0280
0281
0282
0283
0284
0285
0286
0287 for (i = 0; i < ARP_TABLE_SIZE; ++i) {
0288
0289 if ((empty == ARP_TABLE_SIZE) && (arp_table[i].state == ETHARP_STATE_EMPTY)) {
0290 LWIP_DEBUGF(ETHARP_DEBUG, ("find_entry: found empty entry %"U16_F"\n", (u16_t)i));
0291
0292 empty = i;
0293 }
0294
0295 else if (arp_table[i].state == ETHARP_STATE_PENDING) {
0296
0297 if (ipaddr && ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
0298 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: found matching pending entry %"U16_F"\n", (u16_t)i));
0299
0300 #if LWIP_NETIF_HWADDRHINT
0301 NETIF_SET_HINT(netif, i);
0302 #else
0303 etharp_cached_entry = i;
0304 #endif
0305 return i;
0306 #if ARP_QUEUEING
0307
0308 } else if (arp_table[i].q != NULL) {
0309 if (arp_table[i].ctime >= age_queue) {
0310 old_queue = i;
0311 age_queue = arp_table[i].ctime;
0312 }
0313 #endif
0314
0315 } else {
0316 if (arp_table[i].ctime >= age_pending) {
0317 old_pending = i;
0318 age_pending = arp_table[i].ctime;
0319 }
0320 }
0321 }
0322
0323 else if (arp_table[i].state == ETHARP_STATE_STABLE) {
0324
0325 if (ipaddr && ip_addr_cmp(ipaddr, &arp_table[i].ipaddr)) {
0326 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: found matching stable entry %"U16_F"\n", (u16_t)i));
0327
0328 #if LWIP_NETIF_HWADDRHINT
0329 NETIF_SET_HINT(netif, i);
0330 #else
0331 etharp_cached_entry = i;
0332 #endif
0333 return i;
0334
0335 } else if (arp_table[i].ctime >= age_stable) {
0336 old_stable = i;
0337 age_stable = arp_table[i].ctime;
0338 }
0339 }
0340 }
0341
0342
0343
0344 if (((empty == ARP_TABLE_SIZE) && ((flags & ETHARP_TRY_HARD) == 0))
0345
0346 || ((flags & ETHARP_FIND_ONLY) != 0)) {
0347 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: no empty entry found and not allowed to recycle\n"));
0348 return (s8_t)ERR_MEM;
0349 }
0350
0351
0352
0353
0354
0355
0356
0357
0358
0359
0360
0361 if (empty < ARP_TABLE_SIZE) {
0362 i = empty;
0363 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: selecting empty entry %"U16_F"\n", (u16_t)i));
0364 }
0365
0366 else if (old_stable < ARP_TABLE_SIZE) {
0367
0368 i = old_stable;
0369 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: selecting oldest stable entry %"U16_F"\n", (u16_t)i));
0370 #if ARP_QUEUEING
0371
0372 LWIP_ASSERT("arp_table[i].q == NULL", arp_table[i].q == NULL);
0373 #endif
0374
0375 } else if (old_pending < ARP_TABLE_SIZE) {
0376
0377 i = old_pending;
0378 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: selecting oldest pending entry %"U16_F" (without queue)\n", (u16_t)i));
0379 #if ARP_QUEUEING
0380
0381 } else if (old_queue < ARP_TABLE_SIZE) {
0382
0383 i = old_queue;
0384 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("find_entry: selecting oldest pending entry %"U16_F", freeing packet queue %p\n", (u16_t)i, (void *)(arp_table[i].q)));
0385 free_etharp_q(arp_table[i].q);
0386 arp_table[i].q = NULL;
0387 #endif
0388
0389 } else {
0390 return (s8_t)ERR_MEM;
0391 }
0392
0393
0394 LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE);
0395
0396 if (arp_table[i].state != ETHARP_STATE_EMPTY)
0397 {
0398 snmp_delete_arpidx_tree(arp_table[i].netif, &arp_table[i].ipaddr);
0399 }
0400
0401 arp_table[i].state = ETHARP_STATE_EMPTY;
0402
0403
0404 if (ipaddr != NULL) {
0405
0406 ip_addr_set(&arp_table[i].ipaddr, ipaddr);
0407 }
0408 arp_table[i].ctime = 0;
0409 #if LWIP_NETIF_HWADDRHINT
0410 NETIF_SET_HINT(netif, i);
0411 #else
0412 etharp_cached_entry = i;
0413 #endif
0414 return (err_t)i;
0415 }
0416
0417
0418
0419
0420
0421
0422
0423
0424
0425
0426
0427 static err_t
0428 etharp_send_ip(struct netif *netif, struct pbuf *p, struct eth_addr *src, struct eth_addr *dst)
0429 {
0430 struct eth_hdr *ethhdr = p->payload;
0431 u8_t k;
0432
0433 LWIP_ASSERT("netif->hwaddr_len must be the same as ETHARP_HWADDR_LEN for etharp!",
0434 (netif->hwaddr_len == ETHARP_HWADDR_LEN));
0435 k = ETHARP_HWADDR_LEN;
0436 while(k > 0) {
0437 k--;
0438 ethhdr->dest.addr[k] = dst->addr[k];
0439 ethhdr->src.addr[k] = src->addr[k];
0440 }
0441 ethhdr->type = htons(ETHTYPE_IP);
0442 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_send_ip: sending packet %p\n", (void *)p));
0443
0444 return netif->linkoutput(netif, p);
0445 }
0446
0447
0448
0449
0450
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461
0462
0463
0464
0465
0466 static err_t
0467 update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *ethaddr, u8_t flags)
0468 {
0469 s8_t i;
0470 u8_t k;
0471 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry()\n"));
0472 LWIP_ASSERT("netif->hwaddr_len == ETHARP_HWADDR_LEN", netif->hwaddr_len == ETHARP_HWADDR_LEN);
0473 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n",
0474 ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr), ip4_addr4(ipaddr),
0475 ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
0476 ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
0477
0478 if (ip_addr_isany(ipaddr) ||
0479 ip_addr_isbroadcast(ipaddr, netif) ||
0480 ip_addr_ismulticast(ipaddr)) {
0481 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: will not add non-unicast IP address to ARP cache\n"));
0482 return ERR_ARG;
0483 }
0484
0485 #if LWIP_NETIF_HWADDRHINT
0486 i = find_entry(ipaddr, flags, netif);
0487 #else
0488 i = find_entry(ipaddr, flags);
0489 #endif
0490
0491 if (i < 0)
0492 return (err_t)i;
0493
0494
0495 arp_table[i].state = ETHARP_STATE_STABLE;
0496
0497 arp_table[i].netif = netif;
0498
0499
0500 snmp_insert_arpidx_tree(netif, &arp_table[i].ipaddr);
0501
0502 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: updating stable entry %"S16_F"\n", (s16_t)i));
0503
0504 k = ETHARP_HWADDR_LEN;
0505 while (k > 0) {
0506 k--;
0507 arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
0508 }
0509
0510 arp_table[i].ctime = 0;
0511 #if ARP_QUEUEING
0512
0513 while (arp_table[i].q != NULL) {
0514 struct pbuf *p;
0515
0516 struct etharp_q_entry *q = arp_table[i].q;
0517
0518 arp_table[i].q = q->next;
0519
0520 p = q->p;
0521
0522 memp_free(MEMP_ARP_QUEUE, q);
0523
0524 etharp_send_ip(netif, p, (struct eth_addr*)(netif->hwaddr), ethaddr);
0525
0526 pbuf_free(p);
0527 }
0528 #endif
0529 return ERR_OK;
0530 }
0531
0532
0533
0534
0535
0536
0537
0538
0539
0540
0541
0542
0543 s8_t
0544 etharp_find_addr(struct netif *netif, struct ip_addr *ipaddr,
0545 struct eth_addr **eth_ret, struct ip_addr **ip_ret)
0546 {
0547 s8_t i;
0548
0549 LWIP_UNUSED_ARG(netif);
0550
0551 #if LWIP_NETIF_HWADDRHINT
0552 i = find_entry(ipaddr, ETHARP_FIND_ONLY, NULL);
0553 #else
0554 i = find_entry(ipaddr, ETHARP_FIND_ONLY);
0555 #endif
0556 if((i >= 0) && arp_table[i].state == ETHARP_STATE_STABLE) {
0557 *eth_ret = &arp_table[i].ethaddr;
0558 *ip_ret = &arp_table[i].ipaddr;
0559 return i;
0560 }
0561 return -1;
0562 }
0563
0564
0565
0566
0567
0568
0569
0570
0571
0572
0573
0574
0575
0576
0577
0578
0579 void
0580 etharp_ip_input(struct netif *netif, struct pbuf *p)
0581 {
0582 struct eth_hdr *ethhdr;
0583 struct ip_hdr *iphdr;
0584 LWIP_ERROR("netif != NULL", (netif != NULL), return;);
0585
0586
0587 ethhdr = p->payload;
0588 iphdr = (struct ip_hdr *)((u8_t*)ethhdr + SIZEOF_ETH_HDR);
0589 #if ETHARP_SUPPORT_VLAN
0590 if (ethhdr->type == ETHTYPE_VLAN) {
0591 iphdr = (struct ip_hdr *)((u8_t*)ethhdr + SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR);
0592 }
0593 #endif
0594
0595
0596 if (!ip_addr_netcmp(&(iphdr->src), &(netif->ip_addr), &(netif->netmask))) {
0597
0598 return;
0599 }
0600
0601 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_ip_input: updating ETHARP table.\n"));
0602
0603
0604
0605 update_arp_entry(netif, &(iphdr->src), &(ethhdr->src), 0);
0606 }
0607
0608
0609
0610
0611
0612
0613
0614
0615
0616
0617
0618
0619
0620
0621
0622
0623
0624 void
0625 etharp_arp_input(struct netif *netif, struct eth_addr *ethaddr, struct pbuf *p)
0626 {
0627 struct etharp_hdr *hdr;
0628 struct eth_hdr *ethhdr;
0629
0630 struct ip_addr sipaddr, dipaddr;
0631 u8_t i;
0632 u8_t for_us;
0633 #if LWIP_AUTOIP
0634 const u8_t * ethdst_hwaddr;
0635 #endif
0636
0637 LWIP_ERROR("netif != NULL", (netif != NULL), return;);
0638
0639
0640
0641 if (p->len < SIZEOF_ETHARP_PACKET) {
0642 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
0643 ("etharp_arp_input: packet dropped, too short (%"S16_F"/%"S16_F")\n", p->tot_len,
0644 (s16_t)SIZEOF_ETHARP_PACKET));
0645 ETHARP_STATS_INC(etharp.lenerr);
0646 ETHARP_STATS_INC(etharp.drop);
0647 pbuf_free(p);
0648 return;
0649 }
0650
0651 ethhdr = p->payload;
0652 hdr = (struct etharp_hdr *)((u8_t*)ethhdr + SIZEOF_ETH_HDR);
0653 #if ETHARP_SUPPORT_VLAN
0654 if (ethhdr->type == ETHTYPE_VLAN) {
0655 hdr = (struct etharp_hdr *)(((u8_t*)ethhdr) + SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR);
0656 }
0657 #endif
0658
0659
0660 if ((hdr->hwtype != htons(HWTYPE_ETHERNET)) ||
0661 (hdr->_hwlen_protolen != htons((ETHARP_HWADDR_LEN << 8) | sizeof(struct ip_addr))) ||
0662 (hdr->proto != htons(ETHTYPE_IP)) ||
0663 (ethhdr->type != htons(ETHTYPE_ARP))) {
0664 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
0665 ("etharp_arp_input: packet dropped, wrong hw type, hwlen, proto, protolen or ethernet type (%"U16_F"/%"U16_F"/%"U16_F"/%"U16_F"/%"U16_F")\n",
0666 hdr->hwtype, ARPH_HWLEN(hdr), hdr->proto, ARPH_PROTOLEN(hdr), ethhdr->type));
0667 ETHARP_STATS_INC(etharp.proterr);
0668 ETHARP_STATS_INC(etharp.drop);
0669 pbuf_free(p);
0670 return;
0671 }
0672 ETHARP_STATS_INC(etharp.recv);
0673
0674 #if LWIP_AUTOIP
0675
0676
0677
0678 autoip_arp_reply(netif, hdr);
0679 #endif
0680
0681
0682
0683 SMEMCPY(&sipaddr, &hdr->sipaddr, sizeof(sipaddr));
0684 SMEMCPY(&dipaddr, &hdr->dipaddr, sizeof(dipaddr));
0685
0686
0687 if (netif->ip_addr.addr == 0) {
0688 for_us = 0;
0689 } else {
0690
0691 for_us = ip_addr_cmp(&dipaddr, &(netif->ip_addr));
0692 }
0693
0694
0695 if (for_us) {
0696
0697
0698 update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), ETHARP_TRY_HARD);
0699
0700 } else {
0701
0702 update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), 0);
0703 }
0704
0705
0706 switch (htons(hdr->opcode)) {
0707
0708 case ARP_REQUEST:
0709
0710
0711
0712
0713 LWIP_DEBUGF (ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_arp_input: incoming ARP request\n"));
0714
0715 if (for_us) {
0716
0717 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_arp_input: replying to ARP request for our IP address\n"));
0718
0719
0720
0721 hdr->opcode = htons(ARP_REPLY);
0722
0723 hdr->dipaddr = hdr->sipaddr;
0724 SMEMCPY(&hdr->sipaddr, &netif->ip_addr, sizeof(hdr->sipaddr));
0725
0726 LWIP_ASSERT("netif->hwaddr_len must be the same as ETHARP_HWADDR_LEN for etharp!",
0727 (netif->hwaddr_len == ETHARP_HWADDR_LEN));
0728 i = ETHARP_HWADDR_LEN;
0729 #if LWIP_AUTOIP
0730
0731
0732 ethdst_hwaddr = ((netif->autoip != NULL) && (netif->autoip->state != AUTOIP_STATE_OFF)) ? (u8_t*)(ethbroadcast.addr) : hdr->shwaddr.addr;
0733 #endif
0734
0735 while(i > 0) {
0736 i--;
0737 hdr->dhwaddr.addr[i] = hdr->shwaddr.addr[i];
0738 #if LWIP_AUTOIP
0739 ethhdr->dest.addr[i] = ethdst_hwaddr[i];
0740 #else
0741 ethhdr->dest.addr[i] = hdr->shwaddr.addr[i];
0742 #endif
0743 hdr->shwaddr.addr[i] = ethaddr->addr[i];
0744 ethhdr->src.addr[i] = ethaddr->addr[i];
0745 }
0746
0747
0748
0749
0750
0751 netif->linkoutput(netif, p);
0752
0753 } else if (netif->ip_addr.addr == 0) {
0754
0755 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_arp_input: we are unconfigured, ARP request ignored.\n"));
0756
0757 } else {
0758
0759 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_arp_input: ARP request was not for us.\n"));
0760 }
0761 break;
0762 case ARP_REPLY:
0763
0764 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_arp_input: incoming ARP reply\n"));
0765 #if (LWIP_DHCP && DHCP_DOES_ARP_CHECK)
0766
0767
0768
0769
0770 dhcp_arp_reply(netif, &sipaddr);
0771 #endif
0772 break;
0773 default:
0774 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_arp_input: ARP unknown opcode type %"S16_F"\n", htons(hdr->opcode)));
0775 ETHARP_STATS_INC(etharp.err);
0776 break;
0777 }
0778
0779 pbuf_free(p);
0780 }
0781
0782
0783
0784
0785
0786
0787
0788
0789
0790
0791
0792
0793
0794
0795
0796
0797
0798
0799
0800 err_t
0801 etharp_output(struct netif *netif, struct pbuf *q, struct ip_addr *ipaddr)
0802 {
0803 struct eth_addr *dest, mcastaddr;
0804
0805
0806 if (pbuf_header(q, sizeof(struct eth_hdr)) != 0) {
0807
0808 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
0809 ("etharp_output: could not allocate room for header.\n"));
0810 LINK_STATS_INC(link.lenerr);
0811 return ERR_BUF;
0812 }
0813
0814
0815 dest = NULL;
0816
0817
0818
0819
0820 if (ip_addr_isbroadcast(ipaddr, netif)) {
0821
0822 dest = (struct eth_addr *)ðbroadcast;
0823
0824 } else if (ip_addr_ismulticast(ipaddr)) {
0825
0826 mcastaddr.addr[0] = 0x01;
0827 mcastaddr.addr[1] = 0x00;
0828 mcastaddr.addr[2] = 0x5e;
0829 mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f;
0830 mcastaddr.addr[4] = ip4_addr3(ipaddr);
0831 mcastaddr.addr[5] = ip4_addr4(ipaddr);
0832
0833 dest = &mcastaddr;
0834
0835 } else {
0836
0837 if (!ip_addr_netcmp(ipaddr, &(netif->ip_addr), &(netif->netmask))) {
0838
0839 if (netif->gw.addr != 0) {
0840
0841 ipaddr = &(netif->gw);
0842
0843 } else {
0844
0845 return ERR_RTE;
0846 }
0847 }
0848
0849 return etharp_query(netif, ipaddr, q);
0850 }
0851
0852
0853
0854
0855 return etharp_send_ip(netif, q, (struct eth_addr*)(netif->hwaddr), dest);
0856 }
0857
0858
0859
0860
0861
0862
0863
0864
0865
0866
0867
0868
0869
0870
0871
0872
0873
0874
0875
0876
0877
0878
0879
0880
0881
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891 err_t
0892 etharp_query(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
0893 {
0894 struct eth_addr * srcaddr = (struct eth_addr *)netif->hwaddr;
0895 err_t result = ERR_MEM;
0896 s8_t i;
0897
0898
0899 if (ip_addr_isbroadcast(ipaddr, netif) ||
0900 ip_addr_ismulticast(ipaddr) ||
0901 ip_addr_isany(ipaddr)) {
0902 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: will not add non-unicast IP address to ARP cache\n"));
0903 return ERR_ARG;
0904 }
0905
0906
0907 #if LWIP_NETIF_HWADDRHINT
0908 i = find_entry(ipaddr, ETHARP_TRY_HARD, netif);
0909 #else
0910 i = find_entry(ipaddr, ETHARP_TRY_HARD);
0911 #endif
0912
0913
0914 if (i < 0) {
0915 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not create ARP entry\n"));
0916 if (q) {
0917 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: packet dropped\n"));
0918 ETHARP_STATS_INC(etharp.memerr);
0919 }
0920 return (err_t)i;
0921 }
0922
0923
0924 if (arp_table[i].state == ETHARP_STATE_EMPTY) {
0925 arp_table[i].state = ETHARP_STATE_PENDING;
0926 }
0927
0928
0929 LWIP_ASSERT("arp_table[i].state == PENDING or STABLE",
0930 ((arp_table[i].state == ETHARP_STATE_PENDING) ||
0931 (arp_table[i].state == ETHARP_STATE_STABLE)));
0932
0933
0934 if ((arp_table[i].state == ETHARP_STATE_PENDING) || (q == NULL)) {
0935
0936 result = etharp_request(netif, ipaddr);
0937 if (result != ERR_OK) {
0938
0939
0940
0941
0942 }
0943 }
0944
0945
0946 if (q != NULL) {
0947
0948 if (arp_table[i].state == ETHARP_STATE_STABLE) {
0949
0950
0951 result = etharp_send_ip(netif, q, srcaddr, &(arp_table[i].ethaddr));
0952
0953 } else if (arp_table[i].state == ETHARP_STATE_PENDING) {
0954 #if ARP_QUEUEING
0955 struct pbuf *p;
0956 int copy_needed = 0;
0957
0958
0959
0960 p = q;
0961 while (p) {
0962 LWIP_ASSERT("no packet queues allowed!", (p->len != p->tot_len) || (p->next == 0));
0963 if(p->type != PBUF_ROM) {
0964 copy_needed = 1;
0965 break;
0966 }
0967 p = p->next;
0968 }
0969 if(copy_needed) {
0970
0971 p = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
0972 if(p != NULL) {
0973 if (pbuf_copy(p, q) != ERR_OK) {
0974 pbuf_free(p);
0975 p = NULL;
0976 }
0977 }
0978 } else {
0979
0980 p = q;
0981 pbuf_ref(p);
0982 }
0983
0984 if (p != NULL) {
0985
0986 struct etharp_q_entry *new_entry;
0987
0988 new_entry = memp_malloc(MEMP_ARP_QUEUE);
0989 if (new_entry != NULL) {
0990 new_entry->next = 0;
0991 new_entry->p = p;
0992 if(arp_table[i].q != NULL) {
0993
0994 struct etharp_q_entry *r;
0995 r = arp_table[i].q;
0996 while (r->next != NULL) {
0997 r = r->next;
0998 }
0999 r->next = new_entry;
1000 } else {
1001
1002 arp_table[i].q = new_entry;
1003 }
1004 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"S16_F"\n", (void *)q, (s16_t)i));
1005 result = ERR_OK;
1006 } else {
1007
1008 pbuf_free(p);
1009 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q));
1010
1011 }
1012 } else {
1013 ETHARP_STATS_INC(etharp.memerr);
1014 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q));
1015
1016 }
1017 #else
1018
1019
1020 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: Ethernet destination address unknown, queueing disabled, packet %p dropped\n", (void *)q));
1021 #endif
1022 }
1023 }
1024 return result;
1025 }
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042 #if !LWIP_AUTOIP
1043 static
1044 #endif
1045 err_t
1046 etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
1047 const struct eth_addr *ethdst_addr,
1048 const struct eth_addr *hwsrc_addr, const struct ip_addr *ipsrc_addr,
1049 const struct eth_addr *hwdst_addr, const struct ip_addr *ipdst_addr,
1050 const u16_t opcode)
1051 {
1052 struct pbuf *p;
1053 err_t result = ERR_OK;
1054 u8_t k;
1055 struct eth_hdr *ethhdr;
1056 struct etharp_hdr *hdr;
1057 #if LWIP_AUTOIP
1058 const u8_t * ethdst_hwaddr;
1059 #endif
1060
1061
1062 p = pbuf_alloc(PBUF_RAW, SIZEOF_ETHARP_PACKET, PBUF_RAM);
1063
1064 if (p == NULL) {
1065 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
1066 ("etharp_raw: could not allocate pbuf for ARP request.\n"));
1067 ETHARP_STATS_INC(etharp.memerr);
1068 return ERR_MEM;
1069 }
1070 LWIP_ASSERT("check that first pbuf can hold struct etharp_hdr",
1071 (p->len >= SIZEOF_ETHARP_PACKET));
1072
1073 ethhdr = p->payload;
1074 hdr = (struct etharp_hdr *)((u8_t*)ethhdr + SIZEOF_ETH_HDR);
1075 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_raw: sending raw ARP packet.\n"));
1076 hdr->opcode = htons(opcode);
1077
1078 LWIP_ASSERT("netif->hwaddr_len must be the same as ETHARP_HWADDR_LEN for etharp!",
1079 (netif->hwaddr_len == ETHARP_HWADDR_LEN));
1080 k = ETHARP_HWADDR_LEN;
1081 #if LWIP_AUTOIP
1082
1083
1084 ethdst_hwaddr = ((netif->autoip != NULL) && (netif->autoip->state != AUTOIP_STATE_OFF)) ? (u8_t*)(ethbroadcast.addr) : ethdst_addr->addr;
1085 #endif
1086
1087 while(k > 0) {
1088 k--;
1089
1090 hdr->shwaddr.addr[k] = hwsrc_addr->addr[k];
1091 hdr->dhwaddr.addr[k] = hwdst_addr->addr[k];
1092
1093 #if LWIP_AUTOIP
1094 ethhdr->dest.addr[k] = ethdst_hwaddr[k];
1095 #else
1096 ethhdr->dest.addr[k] = ethdst_addr->addr[k];
1097 #endif
1098 ethhdr->src.addr[k] = ethsrc_addr->addr[k];
1099 }
1100 hdr->sipaddr = *(struct ip_addr2 *)ipsrc_addr;
1101 hdr->dipaddr = *(struct ip_addr2 *)ipdst_addr;
1102
1103 hdr->hwtype = htons(HWTYPE_ETHERNET);
1104 hdr->proto = htons(ETHTYPE_IP);
1105
1106 hdr->_hwlen_protolen = htons((ETHARP_HWADDR_LEN << 8) | sizeof(struct ip_addr));
1107
1108 ethhdr->type = htons(ETHTYPE_ARP);
1109
1110 result = netif->linkoutput(netif, p);
1111 ETHARP_STATS_INC(etharp.xmit);
1112
1113 pbuf_free(p);
1114 p = NULL;
1115
1116
1117 return result;
1118 }
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129 err_t
1130 etharp_request(struct netif *netif, struct ip_addr *ipaddr)
1131 {
1132 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_request: sending ARP request.\n"));
1133 return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, ðbroadcast,
1134 (struct eth_addr *)netif->hwaddr, &netif->ip_addr, ðzero,
1135 ipaddr, ARP_REQUEST);
1136 }
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146 err_t
1147 ethernet_input(struct pbuf *p, struct netif *netif)
1148 {
1149 struct eth_hdr* ethhdr;
1150 u16_t type;
1151
1152
1153 ethhdr = p->payload;
1154 LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
1155 ("ethernet_input: dest:%02x:%02x:%02x:%02x:%02x:%02x, src:%02x:%02x:%02x:%02x:%02x:%02x, type:%2hx\n",
1156 (unsigned)ethhdr->dest.addr[0], (unsigned)ethhdr->dest.addr[1], (unsigned)ethhdr->dest.addr[2],
1157 (unsigned)ethhdr->dest.addr[3], (unsigned)ethhdr->dest.addr[4], (unsigned)ethhdr->dest.addr[5],
1158 (unsigned)ethhdr->src.addr[0], (unsigned)ethhdr->src.addr[1], (unsigned)ethhdr->src.addr[2],
1159 (unsigned)ethhdr->src.addr[3], (unsigned)ethhdr->src.addr[4], (unsigned)ethhdr->src.addr[5],
1160 (unsigned)htons(ethhdr->type)));
1161
1162 type = htons(ethhdr->type);
1163 #if ETHARP_SUPPORT_VLAN
1164 if (type == ETHTYPE_VLAN) {
1165 struct eth_vlan_hdr *vlan = (struct eth_vlan_hdr*)(((char*)ethhdr) + SIZEOF_ETH_HDR);
1166 #ifdef ETHARP_VLAN_CHECK
1167 if (VLAN_ID(vlan) != ETHARP_VLAN_CHECK) {
1168
1169 pbuf_free(p);
1170 return ERR_OK;
1171 }
1172 #endif
1173 type = htons(vlan->tpid);
1174 }
1175 #endif
1176
1177 switch (type) {
1178
1179 case ETHTYPE_IP:
1180 #if ETHARP_TRUST_IP_MAC
1181
1182 etharp_ip_input(netif, p);
1183 #endif
1184
1185 if(pbuf_header(p, -(s16_t)SIZEOF_ETH_HDR)) {
1186 LWIP_ASSERT("Can't move over header in packet", 0);
1187 pbuf_free(p);
1188 p = NULL;
1189 } else {
1190
1191 ip_input(p, netif);
1192 }
1193 break;
1194
1195 case ETHTYPE_ARP:
1196
1197 etharp_arp_input(netif, (struct eth_addr*)(netif->hwaddr), p);
1198 break;
1199
1200 #if PPPOE_SUPPORT
1201 case ETHTYPE_PPPOEDISC:
1202 pppoe_disc_input(netif, p);
1203 break;
1204
1205 case ETHTYPE_PPPOE:
1206 pppoe_data_input(netif, p);
1207 break;
1208 #endif
1209
1210 default:
1211 ETHARP_STATS_INC(etharp.proterr);
1212 ETHARP_STATS_INC(etharp.drop);
1213 pbuf_free(p);
1214 p = NULL;
1215 break;
1216 }
1217
1218
1219
1220 return ERR_OK;
1221 }
1222 #endif