mirror/lwip
1
0
Fork 0
mirror of https://github.com/lwip-tcpip/lwip.git synced 2024-10-05 22:29:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reformat IPv4 code using astylerc

Browse Source
This commit is contained in:
Dirk Ziegelmeier 2017-09-17 20:33:27 +02:00
parent 3ed24085fa
commit 8c59be74c1
8 changed files with 659 additions and 662 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
src/core/ipv4/autoip.c
View File

@ -22,7 +22,7 @@
* With DHCP: * With DHCP:
* - define @ref LWIP_DHCP_AUTOIP_COOP 1 in your lwipopts.h. * - define @ref LWIP_DHCP_AUTOIP_COOP 1 in your lwipopts.h.
* - Configure your DHCP Client. * - Configure your DHCP Client.
* *
* @see netifapi_autoip * @see netifapi_autoip
*/ */
@ -95,7 +95,7 @@ static err_t autoip_arp_announce(struct netif *netif);
static void autoip_start_probing(struct netif *netif); static void autoip_start_probing(struct netif *netif);
/** /**
* @ingroup autoip * @ingroup autoip
* Set a statically allocated struct autoip to work with. * Set a statically allocated struct autoip to work with.
* Using this prevents autoip_start to allocate it using mem_malloc. * Using this prevents autoip_start to allocate it using mem_malloc.
* *
@ -123,7 +123,7 @@ autoip_set_struct(struct netif *netif, struct autoip *autoip)
static void static void
autoip_restart(struct netif *netif) autoip_restart(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
autoip->tried_llipaddr++; autoip->tried_llipaddr++;
autoip_start(netif); autoip_start(netif);
} }
@ -134,7 +134,7 @@ autoip_restart(struct netif *netif)
static void static void
autoip_handle_arp_conflict(struct netif *netif) autoip_handle_arp_conflict(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
/* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where /* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where
a) means retreat on the first conflict and a) means retreat on the first conflict and
@ -146,13 +146,13 @@ autoip_handle_arp_conflict(struct netif *netif)
if (autoip->lastconflict > 0) { if (autoip->lastconflict > 0) {
/* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */ /* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n")); ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n"));
/* Active TCP sessions are aborted when removing the ip addresss */ /* Active TCP sessions are aborted when removing the ip addresss */
autoip_restart(netif); autoip_restart(netif);
} else { } else {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n")); ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n"));
autoip_arp_announce(netif); autoip_arp_announce(netif);
autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND; autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND;
} }
@ -167,7 +167,7 @@ autoip_handle_arp_conflict(struct netif *netif)
static void static void
autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr) autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
/* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255 /* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255
* compliant to RFC 3927 Section 2.1 * compliant to RFC 3927 Section 2.1
@ -185,13 +185,13 @@ autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
} }
LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) && LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) &&
(addr <= AUTOIP_RANGE_END)); (addr <= AUTOIP_RANGE_END));
ip4_addr_set_u32(ipaddr, lwip_htonl(addr)); ip4_addr_set_u32(ipaddr, lwip_htonl(addr));
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
(u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), (u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr),
ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr)));
} }
/** /**
@ -202,7 +202,7 @@ autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
static err_t static err_t
autoip_arp_probe(struct netif *netif) autoip_arp_probe(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
/* this works because netif->ip_addr is ANY */ /* this works because netif->ip_addr is ANY */
return etharp_request(netif, &autoip->llipaddr); return etharp_request(netif, &autoip->llipaddr);
} }
@ -226,14 +226,14 @@ autoip_arp_announce(struct netif *netif)
static err_t static err_t
autoip_bind(struct netif *netif) autoip_bind(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
ip4_addr_t sn_mask, gw_addr; ip4_addr_t sn_mask, gw_addr;
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", ("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
(void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num, (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num,
ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
IP4_ADDR(&sn_mask, 255, 255, 0, 0); IP4_ADDR(&sn_mask, 255, 255, 0, 0);
IP4_ADDR(&gw_addr, 0, 0, 0, 0); IP4_ADDR(&gw_addr, 0, 0, 0, 0);
@ -245,7 +245,7 @@ autoip_bind(struct netif *netif)
} }
/** /**
* @ingroup autoip * @ingroup autoip
* Start AutoIP client * Start AutoIP client
* *
* @param netif network interface on which start the AutoIP client * @param netif network interface on which start the AutoIP client
@ -253,7 +253,7 @@ autoip_bind(struct netif *netif)
err_t err_t
autoip_start(struct netif *netif) autoip_start(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
err_t result = ERR_OK; err_t result = ERR_OK;
LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;);
@ -264,16 +264,16 @@ autoip_start(struct netif *netif)
netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4);
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0],
netif->name[1], (u16_t)netif->num)); netif->name[1], (u16_t)netif->num));
if (autoip == NULL) { if (autoip == NULL) {
/* no AutoIP client attached yet? */ /* no AutoIP client attached yet? */
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
("autoip_start(): starting new AUTOIP client\n")); ("autoip_start(): starting new AUTOIP client\n"));
autoip = (struct autoip *)mem_calloc(1, sizeof(struct autoip)); autoip = (struct autoip *)mem_calloc(1, sizeof(struct autoip));
if (autoip == NULL) { if (autoip == NULL) {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
("autoip_start(): could not allocate autoip\n")); ("autoip_start(): could not allocate autoip\n"));
return ERR_MEM; return ERR_MEM;
} }
/* store this AutoIP client in the netif */ /* store this AutoIP client in the netif */
@ -296,14 +296,14 @@ autoip_start(struct netif *netif)
static void static void
autoip_start_probing(struct netif *netif) autoip_start_probing(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
autoip->state = AUTOIP_STATE_PROBING; autoip->state = AUTOIP_STATE_PROBING;
autoip->sent_num = 0; autoip->sent_num = 0;
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", ("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
/* time to wait to first probe, this is randomly /* time to wait to first probe, this is randomly
* chosen out of 0 to PROBE_WAIT seconds. * chosen out of 0 to PROBE_WAIT seconds.
@ -330,7 +330,7 @@ autoip_start_probing(struct netif *netif)
void void
autoip_network_changed(struct netif *netif) autoip_network_changed(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
if (autoip && (autoip->state != AUTOIP_STATE_OFF)) { if (autoip && (autoip->state != AUTOIP_STATE_OFF)) {
autoip_start_probing(netif); autoip_start_probing(netif);
@ -338,7 +338,7 @@ autoip_network_changed(struct netif *netif)
} }
/** /**
* @ingroup autoip * @ingroup autoip
* Stop AutoIP client * Stop AutoIP client
* *
* @param netif network interface on which stop the AutoIP client * @param netif network interface on which stop the AutoIP client
@ -346,7 +346,7 @@ autoip_network_changed(struct netif *netif)
err_t err_t
autoip_stop(struct netif *netif) autoip_stop(struct netif *netif)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
if (autoip != NULL) { if (autoip != NULL) {
autoip->state = AUTOIP_STATE_OFF; autoip->state = AUTOIP_STATE_OFF;
@ -366,7 +366,7 @@ autoip_tmr(void)
struct netif *netif; struct netif *netif;
/* loop through netif's */ /* loop through netif's */
NETIF_FOREACH(netif) { NETIF_FOREACH(netif) {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
/* only act on AutoIP configured interfaces */ /* only act on AutoIP configured interfaces */
if (autoip != NULL) { if (autoip != NULL) {
if (autoip->lastconflict > 0) { if (autoip->lastconflict > 0) {
@ -374,14 +374,14 @@ autoip_tmr(void)
} }
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n", ("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n",
(u16_t)(autoip->state), autoip->ttw)); (u16_t)(autoip->state), autoip->ttw));
if (autoip->ttw > 0) { if (autoip->ttw > 0) {
autoip->ttw--; autoip->ttw--;
} }
switch(autoip->state) { switch (autoip->state) {
case AUTOIP_STATE_PROBING: case AUTOIP_STATE_PROBING:
if (autoip->ttw == 0) { if (autoip->ttw == 0) {
if (autoip->sent_num >= PROBE_NUM) { if (autoip->sent_num >= PROBE_NUM) {
@ -393,9 +393,9 @@ autoip_tmr(void)
autoip->sent_num = 1; autoip->sent_num = 1;
autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND;
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_tmr(): changing state to ANNOUNCING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", ("autoip_tmr(): changing state to ANNOUNCING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
} else { } else {
autoip_arp_probe(netif); autoip_arp_probe(netif);
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() PROBING Sent Probe\n")); LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() PROBING Sent Probe\n"));
@ -406,8 +406,8 @@ autoip_tmr(void)
} else { } else {
/* calculate time to wait to next probe */ /* calculate time to wait to next probe */
autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) % autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) %
((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) + ((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) +
PROBE_MIN * AUTOIP_TICKS_PER_SECOND); PROBE_MIN * AUTOIP_TICKS_PER_SECOND);
} }
} }
} }
@ -421,13 +421,13 @@ autoip_tmr(void)
autoip->sent_num++; autoip->sent_num++;
if (autoip->sent_num >= ANNOUNCE_NUM) { if (autoip->sent_num >= ANNOUNCE_NUM) {
autoip->state = AUTOIP_STATE_BOUND; autoip->state = AUTOIP_STATE_BOUND;
autoip->sent_num = 0; autoip->sent_num = 0;
autoip->ttw = 0; autoip->ttw = 0;
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_tmr(): changing state to BOUND: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", ("autoip_tmr(): changing state to BOUND: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
} }
} }
break; break;
@ -449,15 +449,15 @@ autoip_tmr(void)
void void
autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr) autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n")); LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n"));
if ((autoip != NULL) && (autoip->state != AUTOIP_STATE_OFF)) { if ((autoip != NULL) && (autoip->state != AUTOIP_STATE_OFF)) {
/* when ip.src == llipaddr && hw.src != netif->hwaddr /* when ip.src == llipaddr && hw.src != netif->hwaddr
* *
* when probing ip.dst == llipaddr && hw.src != netif->hwaddr * when probing ip.dst == llipaddr && hw.src != netif->hwaddr
* we have a conflict and must solve it * we have a conflict and must solve it
*/ */
ip4_addr_t sipaddr, dipaddr; ip4_addr_t sipaddr, dipaddr;
struct eth_addr netifaddr; struct eth_addr netifaddr;
SMEMCPY(netifaddr.addr, netif->hwaddr, ETH_HWADDR_LEN); SMEMCPY(netifaddr.addr, netif->hwaddr, ETH_HWADDR_LEN);
@ -469,29 +469,29 @@ autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr)
IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr); IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr);
if (autoip->state == AUTOIP_STATE_PROBING) { if (autoip->state == AUTOIP_STATE_PROBING) {
/* RFC 3927 Section 2.2.1: /* RFC 3927 Section 2.2.1:
* from beginning to after ANNOUNCE_WAIT * from beginning to after ANNOUNCE_WAIT
* seconds we have a conflict if * seconds we have a conflict if
* ip.src == llipaddr OR * ip.src == llipaddr OR
* ip.dst == llipaddr && hw.src != own hwaddr * ip.dst == llipaddr && hw.src != own hwaddr
*/ */
if ((ip4_addr_cmp(&sipaddr, &autoip->llipaddr)) || if ((ip4_addr_cmp(&sipaddr, &autoip->llipaddr)) ||
(ip4_addr_isany_val(sipaddr) && (ip4_addr_isany_val(sipaddr) &&
ip4_addr_cmp(&dipaddr, &autoip->llipaddr) && ip4_addr_cmp(&dipaddr, &autoip->llipaddr) &&
!eth_addr_cmp(&netifaddr, &hdr->shwaddr))) { !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
("autoip_arp_reply(): Probe Conflict detected\n")); ("autoip_arp_reply(): Probe Conflict detected\n"));
autoip_restart(netif); autoip_restart(netif);
} }
} else { } else {
/* RFC 3927 Section 2.5: /* RFC 3927 Section 2.5:
* in any state we have a conflict if * in any state we have a conflict if
* ip.src == llipaddr && hw.src != own hwaddr * ip.src == llipaddr && hw.src != own hwaddr
*/ */
if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) && if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) &&
!eth_addr_cmp(&netifaddr, &hdr->shwaddr)) { !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
("autoip_arp_reply(): Conflicting ARP-Packet detected\n")); ("autoip_arp_reply(): Conflicting ARP-Packet detected\n"));
autoip_handle_arp_conflict(netif); autoip_handle_arp_conflict(netif);
} }
} }
@ -508,7 +508,7 @@ u8_t
autoip_supplied_address(const struct netif *netif) autoip_supplied_address(const struct netif *netif)
{ {
if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) { if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING); return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING);
} }
return 0; return 0;
@ -517,7 +517,7 @@ autoip_supplied_address(const struct netif *netif)
u8_t u8_t
autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr) autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr)
{ {
struct autoip* autoip = netif_autoip_data(netif); struct autoip *autoip = netif_autoip_data(netif);
return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr)); return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr));
} }

203
src/core/ipv4/dhcp.c
View File

@ -170,7 +170,7 @@ static u8_t dhcp_discover_request_options[] = {
#if LWIP_DHCP_GET_NTP_SRV #if LWIP_DHCP_GET_NTP_SRV
, DHCP_OPTION_NTP , DHCP_OPTION_NTP
#endif /* LWIP_DHCP_GET_NTP_SRV */ #endif /* LWIP_DHCP_GET_NTP_SRV */
}; };
#ifdef DHCP_GLOBAL_XID #ifdef DHCP_GLOBAL_XID
static u32_t xid; static u32_t xid;
@ -279,7 +279,7 @@ dhcp_handle_nak(struct netif *netif)
struct dhcp *dhcp = netif_dhcp_data(netif); struct dhcp *dhcp = netif_dhcp_data(netif);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_nak(netif=%p) %c%c%"U16_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_nak(netif=%p) %c%c%"U16_F"\n",
(void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
/* Change to a defined state - set this before assigning the address /* Change to a defined state - set this before assigning the address
to ensure the callback can use dhcp_supplied_address() */ to ensure the callback can use dhcp_supplied_address() */
dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF);
@ -306,7 +306,7 @@ dhcp_check(struct netif *netif)
err_t result; err_t result;
u16_t msecs; u16_t msecs;
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_check(netif=%p) %c%c\n", (void *)netif, (s16_t)netif->name[0], LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_check(netif=%p) %c%c\n", (void *)netif, (s16_t)netif->name[0],
(s16_t)netif->name[1])); (s16_t)netif->name[1]));
dhcp_set_state(dhcp, DHCP_STATE_CHECKING); dhcp_set_state(dhcp, DHCP_STATE_CHECKING);
/* create an ARP query for the offered IP address, expecting that no host /* create an ARP query for the offered IP address, expecting that no host
responds, as the IP address should not be in use. */ responds, as the IP address should not be in use. */
@ -334,21 +334,21 @@ dhcp_handle_offer(struct netif *netif, struct dhcp_msg *msg_in)
struct dhcp *dhcp = netif_dhcp_data(netif); struct dhcp *dhcp = netif_dhcp_data(netif);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_offer(netif=%p) %c%c%"U16_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_offer(netif=%p) %c%c%"U16_F"\n",
(void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
/* obtain the server address */ /* obtain the server address */
if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) { if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) {
ip_addr_set_ip4_u32(&dhcp->server_ip_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID))); ip_addr_set_ip4_u32(&dhcp->server_ip_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID)));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n",
ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr))));
/* remember offered address */ /* remember offered address */
ip4_addr_copy(dhcp->offered_ip_addr, msg_in->yiaddr); ip4_addr_copy(dhcp->offered_ip_addr, msg_in->yiaddr);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): offer for 0x%08"X32_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): offer for 0x%08"X32_F"\n",
ip4_addr_get_u32(&dhcp->offered_ip_addr))); ip4_addr_get_u32(&dhcp->offered_ip_addr)));
dhcp_select(netif); dhcp_select(netif);
} else { } else {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
("dhcp_handle_offer(netif=%p) did not get server ID!\n", (void*)netif)); ("dhcp_handle_offer(netif=%p) did not get server ID!\n", (void *)netif));
} }
} }
@ -373,7 +373,7 @@ dhcp_select(struct netif *netif)
LWIP_ERROR("dhcp_select: netif != NULL", (netif != NULL), return ERR_ARG;); LWIP_ERROR("dhcp_select: netif != NULL", (netif != NULL), return ERR_ARG;);
LWIP_ERROR("dhcp_select: dhcp != NULL", (dhcp != NULL), return ERR_VAL;); LWIP_ERROR("dhcp_select: dhcp != NULL", (dhcp != NULL), return ERR_VAL;);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_select(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_select(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
dhcp_set_state(dhcp, DHCP_STATE_REQUESTING); dhcp_set_state(dhcp, DHCP_STATE_REQUESTING);
/* create and initialize the DHCP message header */ /* create and initialize the DHCP message header */
@ -439,12 +439,12 @@ dhcp_coarse_tmr(void)
/* this clients' lease time has expired */ /* this clients' lease time has expired */
dhcp_release_and_stop(netif); dhcp_release_and_stop(netif);
dhcp_start(netif); dhcp_start(netif);
/* timer is active (non zero), and triggers (zeroes) now? */ /* timer is active (non zero), and triggers (zeroes) now? */
} else if (dhcp->t2_rebind_time && (dhcp->t2_rebind_time-- == 1)) { } else if (dhcp->t2_rebind_time && (dhcp->t2_rebind_time-- == 1)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t2 timeout\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t2 timeout\n"));
/* this clients' rebind timeout triggered */ /* this clients' rebind timeout triggered */
dhcp_t2_timeout(netif); dhcp_t2_timeout(netif);
/* timer is active (non zero), and triggers (zeroes) now */ /* timer is active (non zero), and triggers (zeroes) now */
} else if (dhcp->t1_renew_time && (dhcp->t1_renew_time-- == 1)) { } else if (dhcp->t1_renew_time && (dhcp->t1_renew_time-- == 1)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t1 timeout\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t1 timeout\n"));
/* this clients' renewal timeout triggered */ /* this clients' renewal timeout triggered */
@ -473,8 +473,7 @@ dhcp_fine_tmr(void)
/* timer is active (non zero), and is about to trigger now */ /* timer is active (non zero), and is about to trigger now */
if (dhcp->request_timeout > 1) { if (dhcp->request_timeout > 1) {
dhcp->request_timeout--; dhcp->request_timeout--;
} } else if (dhcp->request_timeout == 1) {
else if (dhcp->request_timeout == 1) {
dhcp->request_timeout--; dhcp->request_timeout--;
/* { netif->dhcp->request_timeout == 0 } */ /* { netif->dhcp->request_timeout == 0 } */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_fine_tmr(): request timeout\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_fine_tmr(): request timeout\n"));
@ -503,7 +502,7 @@ dhcp_timeout(struct netif *netif)
if ((dhcp->state == DHCP_STATE_BACKING_OFF) || (dhcp->state == DHCP_STATE_SELECTING)) { if ((dhcp->state == DHCP_STATE_BACKING_OFF) || (dhcp->state == DHCP_STATE_SELECTING)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout(): restarting discovery\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout(): restarting discovery\n"));
dhcp_discover(netif); dhcp_discover(netif);
/* receiving the requested lease timed out */ /* receiving the requested lease timed out */
} else if (dhcp->state == DHCP_STATE_REQUESTING) { } else if (dhcp->state == DHCP_STATE_REQUESTING) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, DHCP request timed out\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, DHCP request timed out\n"));
if (dhcp->tries <= 5) { if (dhcp->tries <= 5) {
@ -514,13 +513,13 @@ dhcp_timeout(struct netif *netif)
dhcp_start(netif); dhcp_start(netif);
} }
#if DHCP_DOES_ARP_CHECK #if DHCP_DOES_ARP_CHECK
/* received no ARP reply for the offered address (which is good) */ /* received no ARP reply for the offered address (which is good) */
} else if (dhcp->state == DHCP_STATE_CHECKING) { } else if (dhcp->state == DHCP_STATE_CHECKING) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): CHECKING, ARP request timed out\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): CHECKING, ARP request timed out\n"));
if (dhcp->tries <= 1) { if (dhcp->tries <= 1) {
dhcp_check(netif); dhcp_check(netif);
/* no ARP replies on the offered address, /* no ARP replies on the offered address,
looks like the IP address is indeed free */ looks like the IP address is indeed free */
} else { } else {
/* bind the interface to the offered address */ /* bind the interface to the offered address */
dhcp_bind(netif); dhcp_bind(netif);
@ -556,9 +555,8 @@ dhcp_t1_timeout(struct netif *netif)
DHCP_STATE_RENEWING, not DHCP_STATE_BOUND */ DHCP_STATE_RENEWING, not DHCP_STATE_BOUND */
dhcp_renew(netif); dhcp_renew(netif);
/* Calculate next timeout */ /* Calculate next timeout */
if (((dhcp->t2_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) if (((dhcp->t2_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) {
{ dhcp->t1_renew_time = (u16_t)((dhcp->t2_timeout - dhcp->lease_used) / 2);
dhcp->t1_renew_time = (u16_t)((dhcp->t2_timeout - dhcp->lease_used) / 2);
} }
} }
} }
@ -583,9 +581,8 @@ dhcp_t2_timeout(struct netif *netif)
DHCP_STATE_REBINDING, not DHCP_STATE_BOUND */ DHCP_STATE_REBINDING, not DHCP_STATE_BOUND */
dhcp_rebind(netif); dhcp_rebind(netif);
/* Calculate next timeout */ /* Calculate next timeout */
if (((dhcp->t0_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) if (((dhcp->t0_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) {
{ dhcp->t2_rebind_time = (u16_t)((dhcp->t0_timeout - dhcp->lease_used) / 2);
dhcp->t2_rebind_time = (u16_t)((dhcp->t0_timeout - dhcp->lease_used) / 2);
} }
} }
} }
@ -740,7 +737,7 @@ dhcp_start(struct netif *netif)
LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG;); LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG;);
LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;);
dhcp = netif_dhcp_data(netif); dhcp = netif_dhcp_data(netif);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
/* check MTU of the netif */ /* check MTU of the netif */
if (netif->mtu < DHCP_MAX_MSG_LEN_MIN_REQUIRED) { if (netif->mtu < DHCP_MAX_MSG_LEN_MIN_REQUIRED) {
@ -760,7 +757,7 @@ dhcp_start(struct netif *netif)
/* store this dhcp client in the netif */ /* store this dhcp client in the netif */
netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp); netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp"));
/* already has DHCP client attached */ /* already has DHCP client attached */
} else { } else {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(): restarting DHCP configuration\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(): restarting DHCP configuration\n"));
@ -862,31 +859,31 @@ dhcp_network_changed(struct netif *netif)
return; return;
} }
switch (dhcp->state) { switch (dhcp->state) {
case DHCP_STATE_REBINDING: case DHCP_STATE_REBINDING:
case DHCP_STATE_RENEWING: case DHCP_STATE_RENEWING:
case DHCP_STATE_BOUND: case DHCP_STATE_BOUND:
case DHCP_STATE_REBOOTING: case DHCP_STATE_REBOOTING:
dhcp->tries = 0; dhcp->tries = 0;
dhcp_reboot(netif); dhcp_reboot(netif);
break; break;
case DHCP_STATE_OFF: case DHCP_STATE_OFF:
/* stay off */ /* stay off */
break; break;
default: default:
LWIP_ASSERT("invalid dhcp->state", dhcp->state <= DHCP_STATE_BACKING_OFF); LWIP_ASSERT("invalid dhcp->state", dhcp->state <= DHCP_STATE_BACKING_OFF);
/* INIT/REQUESTING/CHECKING/BACKING_OFF restart with new 'rid' because the /* INIT/REQUESTING/CHECKING/BACKING_OFF restart with new 'rid' because the
state changes, SELECTING: continue with current 'rid' as we stay in the state changes, SELECTING: continue with current 'rid' as we stay in the
same state */ same state */
#if LWIP_DHCP_AUTOIP_COOP #if LWIP_DHCP_AUTOIP_COOP
if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
autoip_stop(netif); autoip_stop(netif);
dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
} }
#endif /* LWIP_DHCP_AUTOIP_COOP */ #endif /* LWIP_DHCP_AUTOIP_COOP */
/* ensure we start with short timeouts, even if already discovering */ /* ensure we start with short timeouts, even if already discovering */
dhcp->tries = 0; dhcp->tries = 0;
dhcp_discover(netif); dhcp_discover(netif);
break; break;
} }
} }
@ -909,13 +906,13 @@ dhcp_arp_reply(struct netif *netif, const ip4_addr_t *addr)
/* is a DHCP client doing an ARP check? */ /* is a DHCP client doing an ARP check? */
if ((dhcp != NULL) && (dhcp->state == DHCP_STATE_CHECKING)) { if ((dhcp != NULL) && (dhcp->state == DHCP_STATE_CHECKING)) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_arp_reply(): CHECKING, arp reply for 0x%08"X32_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_arp_reply(): CHECKING, arp reply for 0x%08"X32_F"\n",
ip4_addr_get_u32(addr))); ip4_addr_get_u32(addr)));
/* did a host respond with the address we /* did a host respond with the address we
were offered by the DHCP server? */ were offered by the DHCP server? */
if (ip4_addr_cmp(addr, &dhcp->offered_ip_addr)) { if (ip4_addr_cmp(addr, &dhcp->offered_ip_addr)) {
/* we will not accept the offered address */ /* we will not accept the offered address */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
("dhcp_arp_reply(): arp reply matched with offered address, declining\n")); ("dhcp_arp_reply(): arp reply matched with offered address, declining\n"));
dhcp_decline(netif); dhcp_decline(netif);
} }
} }
@ -957,13 +954,13 @@ dhcp_decline(struct netif *netif)
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_decline: BACKING OFF\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_decline: BACKING OFF\n"));
} else { } else {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
("dhcp_decline: could not allocate DHCP request\n")); ("dhcp_decline: could not allocate DHCP request\n"));
result = ERR_MEM; result = ERR_MEM;
} }
if (dhcp->tries < 255) { if (dhcp->tries < 255) {
dhcp->tries++; dhcp->tries++;
} }
msecs = 10*1000; msecs = 10 * 1000;
dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline(): set request timeout %"U16_F" msecs\n", msecs)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline(): set request timeout %"U16_F" msecs\n", msecs));
return result; return result;
@ -1044,23 +1041,23 @@ dhcp_bind(struct netif *netif)
LWIP_ERROR("dhcp_bind: netif != NULL", (netif != NULL), return;); LWIP_ERROR("dhcp_bind: netif != NULL", (netif != NULL), return;);
dhcp = netif_dhcp_data(netif); dhcp = netif_dhcp_data(netif);
LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;); LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
/* reset time used of lease */ /* reset time used of lease */
dhcp->lease_used = 0; dhcp->lease_used = 0;
if (dhcp->offered_t0_lease != 0xffffffffUL) { if (dhcp->offered_t0_lease != 0xffffffffUL) {
/* set renewal period timer */ /* set renewal period timer */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t0 renewal timer %"U32_F" secs\n", dhcp->offered_t0_lease)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t0 renewal timer %"U32_F" secs\n", dhcp->offered_t0_lease));
timeout = (dhcp->offered_t0_lease + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; timeout = (dhcp->offered_t0_lease + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
if (timeout > 0xffff) { if (timeout > 0xffff) {
timeout = 0xffff; timeout = 0xffff;
} }
dhcp->t0_timeout = (u16_t)timeout; dhcp->t0_timeout = (u16_t)timeout;
if (dhcp->t0_timeout == 0) { if (dhcp->t0_timeout == 0) {
dhcp->t0_timeout = 1; dhcp->t0_timeout = 1;
} }
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t0_lease*1000)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t0_lease * 1000));
} }
/* temporary DHCP lease? */ /* temporary DHCP lease? */
@ -1075,7 +1072,7 @@ dhcp_bind(struct netif *netif)
if (dhcp->t1_timeout == 0) { if (dhcp->t1_timeout == 0) {
dhcp->t1_timeout = 1; dhcp->t1_timeout = 1;
} }
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew*1000)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew * 1000));
dhcp->t1_renew_time = dhcp->t1_timeout; dhcp->t1_renew_time = dhcp->t1_timeout;
} }
/* set renewal period timer */ /* set renewal period timer */
@ -1089,7 +1086,7 @@ dhcp_bind(struct netif *netif)
if (dhcp->t2_timeout == 0) { if (dhcp->t2_timeout == 0) {
dhcp->t2_timeout = 1; dhcp->t2_timeout = 1;
} }
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind*1000)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind * 1000));
dhcp->t2_rebind_time = dhcp->t2_timeout; dhcp->t2_rebind_time = dhcp->t2_timeout;
} }
@ -1130,7 +1127,7 @@ dhcp_bind(struct netif *netif)
#endif /* LWIP_DHCP_AUTOIP_COOP */ #endif /* LWIP_DHCP_AUTOIP_COOP */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): IP: 0x%08"X32_F" SN: 0x%08"X32_F" GW: 0x%08"X32_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): IP: 0x%08"X32_F" SN: 0x%08"X32_F" GW: 0x%08"X32_F"\n",
ip4_addr_get_u32(&dhcp->offered_ip_addr), ip4_addr_get_u32(&sn_mask), ip4_addr_get_u32(&gw_addr))); ip4_addr_get_u32(&dhcp->offered_ip_addr), ip4_addr_get_u32(&sn_mask), ip4_addr_get_u32(&gw_addr)));
/* netif is now bound to DHCP leased address - set this before assigning the address /* netif is now bound to DHCP leased address - set this before assigning the address
to ensure the callback can use dhcp_supplied_address() */ to ensure the callback can use dhcp_supplied_address() */
dhcp_set_state(dhcp, DHCP_STATE_BOUND); dhcp_set_state(dhcp, DHCP_STATE_BOUND);
@ -1343,7 +1340,7 @@ dhcp_release_and_stop(struct netif *netif)
u16_t options_out_len; u16_t options_out_len;
p_out = dhcp_create_msg(netif, dhcp, DHCP_RELEASE, &options_out_len); p_out = dhcp_create_msg(netif, dhcp, DHCP_RELEASE, &options_out_len);
if (p_out != NULL) { if (p_out != NULL) {
struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload;
options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_SERVER_ID, 4); options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_SERVER_ID, 4);
options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr)))); options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr))));
@ -1354,7 +1351,7 @@ dhcp_release_and_stop(struct netif *netif)
pbuf_free(p_out); pbuf_free(p_out);
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_STATE_OFF\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_STATE_OFF\n"));
} else { } else {
/* sending release failed, but that's not a problem since the correct behaviour of dhcp does not rely on release */ /* sending release failed, but that's not a problem since the correct behaviour of dhcp does not rely on release */
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_release: could not allocate DHCP request\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_release: could not allocate DHCP request\n"));
} }
} }
@ -1540,7 +1537,7 @@ again:
} }
offset = options_idx; offset = options_idx;
offset_max = options_idx_max; offset_max = options_idx_max;
options = (u8_t*)q->payload; options = (u8_t *)q->payload;
/* at least 1 byte to read and no end marker, then at least 3 bytes to read? */ /* at least 1 byte to read and no end marker, then at least 3 bytes to read? */
while ((q != NULL) && (offset < offset_max) && (options[offset] != DHCP_OPTION_END)) { while ((q != NULL) && (offset < offset_max) && (options[offset] != DHCP_OPTION_END)) {
u8_t op = options[offset]; u8_t op = options[offset];
@ -1556,29 +1553,29 @@ again:
if ((offset + 1) < q->len) { if ((offset + 1) < q->len) {
len = options[offset + 1]; len = options[offset + 1];
} else { } else {
len = (q->next != NULL ? ((u8_t*)q->next->payload)[0] : 0); len = (q->next != NULL ? ((u8_t *)q->next->payload)[0] : 0);
} }
/* LWIP_DEBUGF(DHCP_DEBUG, ("msg_offset=%"U16_F", q->len=%"U16_F, msg_offset, q->len)); */ /* LWIP_DEBUGF(DHCP_DEBUG, ("msg_offset=%"U16_F", q->len=%"U16_F, msg_offset, q->len)); */
decode_len = len; decode_len = len;
switch(op) { switch (op) {
/* case(DHCP_OPTION_END): handled above */ /* case(DHCP_OPTION_END): handled above */
case(DHCP_OPTION_PAD): case (DHCP_OPTION_PAD):
/* special option: no len encoded */ /* special option: no len encoded */
decode_len = len = 0; decode_len = len = 0;
/* will be increased below */ /* will be increased below */
offset--; offset--;
break; break;
case(DHCP_OPTION_SUBNET_MASK): case (DHCP_OPTION_SUBNET_MASK):
LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); LWIP_ERROR("len == 4", len == 4, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_SUBNET_MASK; decode_idx = DHCP_OPTION_IDX_SUBNET_MASK;
break; break;
case(DHCP_OPTION_ROUTER): case (DHCP_OPTION_ROUTER):
decode_len = 4; /* only copy the first given router */ decode_len = 4; /* only copy the first given router */
LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_ROUTER; decode_idx = DHCP_OPTION_IDX_ROUTER;
break; break;
#if LWIP_DHCP_PROVIDE_DNS_SERVERS #if LWIP_DHCP_PROVIDE_DNS_SERVERS
case(DHCP_OPTION_DNS_SERVER): case (DHCP_OPTION_DNS_SERVER):
/* special case: there might be more than one server */ /* special case: there might be more than one server */
LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;); LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;);
/* limit number of DNS servers */ /* limit number of DNS servers */
@ -1587,12 +1584,12 @@ again:
decode_idx = DHCP_OPTION_IDX_DNS_SERVER; decode_idx = DHCP_OPTION_IDX_DNS_SERVER;
break; break;
#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ #endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */
case(DHCP_OPTION_LEASE_TIME): case (DHCP_OPTION_LEASE_TIME):
LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); LWIP_ERROR("len == 4", len == 4, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_LEASE_TIME; decode_idx = DHCP_OPTION_IDX_LEASE_TIME;
break; break;
#if LWIP_DHCP_GET_NTP_SRV #if LWIP_DHCP_GET_NTP_SRV
case(DHCP_OPTION_NTP): case (DHCP_OPTION_NTP):
/* special case: there might be more than one server */ /* special case: there might be more than one server */
LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;); LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;);
/* limit number of NTP servers */ /* limit number of NTP servers */
@ -1601,25 +1598,25 @@ again:
decode_idx = DHCP_OPTION_IDX_NTP_SERVER; decode_idx = DHCP_OPTION_IDX_NTP_SERVER;
break; break;
#endif /* LWIP_DHCP_GET_NTP_SRV*/ #endif /* LWIP_DHCP_GET_NTP_SRV*/
case(DHCP_OPTION_OVERLOAD): case (DHCP_OPTION_OVERLOAD):
LWIP_ERROR("len == 1", len == 1, return ERR_VAL;); LWIP_ERROR("len == 1", len == 1, return ERR_VAL;);
/* decode overload only in options, not in file/sname: invalid packet */ /* decode overload only in options, not in file/sname: invalid packet */
LWIP_ERROR("overload in file/sname", options_idx == DHCP_OPTIONS_OFS, return ERR_VAL;); LWIP_ERROR("overload in file/sname", options_idx == DHCP_OPTIONS_OFS, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_OVERLOAD; decode_idx = DHCP_OPTION_IDX_OVERLOAD;
break; break;
case(DHCP_OPTION_MESSAGE_TYPE): case (DHCP_OPTION_MESSAGE_TYPE):
LWIP_ERROR("len == 1", len == 1, return ERR_VAL;); LWIP_ERROR("len == 1", len == 1, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_MSG_TYPE; decode_idx = DHCP_OPTION_IDX_MSG_TYPE;
break; break;
case(DHCP_OPTION_SERVER_ID): case (DHCP_OPTION_SERVER_ID):
LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); LWIP_ERROR("len == 4", len == 4, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_SERVER_ID; decode_idx = DHCP_OPTION_IDX_SERVER_ID;
break; break;
case(DHCP_OPTION_T1): case (DHCP_OPTION_T1):
LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); LWIP_ERROR("len == 4", len == 4, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_T1; decode_idx = DHCP_OPTION_IDX_T1;
break; break;
case(DHCP_OPTION_T2): case (DHCP_OPTION_T2):
LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); LWIP_ERROR("len == 4", len == 4, return ERR_VAL;);
decode_idx = DHCP_OPTION_IDX_T2; decode_idx = DHCP_OPTION_IDX_T2;
break; break;
@ -1627,8 +1624,8 @@ again:
decode_len = 0; decode_len = 0;
LWIP_DEBUGF(DHCP_DEBUG, ("skipping option %"U16_F" in options\n", (u16_t)op)); LWIP_DEBUGF(DHCP_DEBUG, ("skipping option %"U16_F" in options\n", (u16_t)op));
LWIP_HOOK_DHCP_PARSE_OPTION(ip_current_netif(), dhcp, dhcp->state, msg_in, LWIP_HOOK_DHCP_PARSE_OPTION(ip_current_netif(), dhcp, dhcp->state, msg_in,
dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) ? (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) : 0, dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) ? (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) : 0,
op, len, q, val_offset); op, len, q, val_offset);
break; break;
} }
if (offset + len + 2 > 0xFFFF) { if (offset + len + 2 > 0xFFFF) {
@ -1665,7 +1662,7 @@ decode_next:
value = lwip_ntohl(value); value = lwip_ntohl(value);
} else { } else {
LWIP_ERROR("invalid decode_len", decode_len == 1, return ERR_VAL;); LWIP_ERROR("invalid decode_len", decode_len == 1, return ERR_VAL;);
value = ((u8_t*)&value)[0]; value = ((u8_t *)&value)[0];
} }
dhcp_got_option(dhcp, decode_idx); dhcp_got_option(dhcp, decode_idx);
dhcp_set_option_value(dhcp, decode_idx, value); dhcp_set_option_value(dhcp, decode_idx, value);
@ -1677,7 +1674,7 @@ decode_next:
if ((offset < offset_max) && offset_max) { if ((offset < offset_max) && offset_max) {
q = q->next; q = q->next;
LWIP_ERROR("next pbuf was null", q != NULL, return ERR_VAL;); LWIP_ERROR("next pbuf was null", q != NULL, return ERR_VAL;);
options = (u8_t*)q->payload; options = (u8_t *)q->payload;
} else { } else {
/* We've run out of bytes, probably no end marker. Don't proceed. */ /* We've run out of bytes, probably no end marker. Don't proceed. */
break; break;
@ -1705,13 +1702,13 @@ decode_next:
if (!parse_file_as_options) { if (!parse_file_as_options) {
/* only do this for ACK messages */ /* only do this for ACK messages */
if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) && if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) &&
(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) == DHCP_ACK)) (dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) == DHCP_ACK))
/* copy bootp file name, don't care for sname (server hostname) */ /* copy bootp file name, don't care for sname (server hostname) */
if (pbuf_copy_partial(p, dhcp->boot_file_name, DHCP_FILE_LEN-1, DHCP_FILE_OFS) != (DHCP_FILE_LEN-1)) { if (pbuf_copy_partial(p, dhcp->boot_file_name, DHCP_FILE_LEN - 1, DHCP_FILE_OFS) != (DHCP_FILE_LEN - 1)) {
return ERR_BUF; return ERR_BUF;
} }
/* make sure the string is really NULL-terminated */ /* make sure the string is really NULL-terminated */
dhcp->boot_file_name[DHCP_FILE_LEN-1] = 0; dhcp->boot_file_name[DHCP_FILE_LEN - 1] = 0;
} }
#endif /* LWIP_DHCP_BOOTP_FILE */ #endif /* LWIP_DHCP_BOOTP_FILE */
} }
@ -1752,8 +1749,8 @@ dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
LWIP_ASSERT("invalid server address type", IP_IS_V4(addr)); LWIP_ASSERT("invalid server address type", IP_IS_V4(addr));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_recv(pbuf = %p) from DHCP server %"U16_F".%"U16_F".%"U16_F".%"U16_F" port %"U16_F"\n", (void*)p, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_recv(pbuf = %p) from DHCP server %"U16_F".%"U16_F".%"U16_F".%"U16_F" port %"U16_F"\n", (void *)p,
ip4_addr1_16(ip_2_ip4(addr)), ip4_addr2_16(ip_2_ip4(addr)), ip4_addr3_16(ip_2_ip4(addr)), ip4_addr4_16(ip_2_ip4(addr)), port)); ip4_addr1_16(ip_2_ip4(addr)), ip4_addr2_16(ip_2_ip4(addr)), ip4_addr3_16(ip_2_ip4(addr)), ip4_addr4_16(ip_2_ip4(addr)), port));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->len = %"U16_F"\n", p->len)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->len = %"U16_F"\n", p->len));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->tot_len = %"U16_F"\n", p->tot_len)); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->tot_len = %"U16_F"\n", p->tot_len));
/* prevent warnings about unused arguments */ /* prevent warnings about unused arguments */
@ -1774,21 +1771,21 @@ dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
for (i = 0; i < netif->hwaddr_len && i < NETIF_MAX_HWADDR_LEN && i < DHCP_CHADDR_LEN; i++) { for (i = 0; i < netif->hwaddr_len && i < NETIF_MAX_HWADDR_LEN && i < DHCP_CHADDR_LEN; i++) {
if (netif->hwaddr[i] != reply_msg->chaddr[i]) { if (netif->hwaddr[i] != reply_msg->chaddr[i]) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("netif->hwaddr[%"U16_F"]==%02"X16_F" != reply_msg->chaddr[%"U16_F"]==%02"X16_F"\n", ("netif->hwaddr[%"U16_F"]==%02"X16_F" != reply_msg->chaddr[%"U16_F"]==%02"X16_F"\n",
(u16_t)i, (u16_t)netif->hwaddr[i], (u16_t)i, (u16_t)reply_msg->chaddr[i])); (u16_t)i, (u16_t)netif->hwaddr[i], (u16_t)i, (u16_t)reply_msg->chaddr[i]));
goto free_pbuf_and_return; goto free_pbuf_and_return;
} }
} }
/* match transaction ID against what we expected */ /* match transaction ID against what we expected */
if (lwip_ntohl(reply_msg->xid) != dhcp->xid) { if (lwip_ntohl(reply_msg->xid) != dhcp->xid) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n",lwip_ntohl(reply_msg->xid),dhcp->xid)); ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n", lwip_ntohl(reply_msg->xid), dhcp->xid));
goto free_pbuf_and_return; goto free_pbuf_and_return;
} }
/* option fields could be unfold? */ /* option fields could be unfold? */
if (dhcp_parse_reply(p, dhcp) != ERR_OK) { if (dhcp_parse_reply(p, dhcp) != ERR_OK) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
("problem unfolding DHCP message - too short on memory?\n")); ("problem unfolding DHCP message - too short on memory?\n"));
goto free_pbuf_and_return; goto free_pbuf_and_return;
} }
@ -1830,8 +1827,8 @@ dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
} }
/* received a DHCP_NAK in appropriate state? */ /* received a DHCP_NAK in appropriate state? */
else if ((msg_type == DHCP_NAK) && else if ((msg_type == DHCP_NAK) &&
((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REQUESTING) || ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REQUESTING) ||
(dhcp->state == DHCP_STATE_REBINDING) || (dhcp->state == DHCP_STATE_RENEWING ))) { (dhcp->state == DHCP_STATE_REBINDING) || (dhcp->state == DHCP_STATE_RENEWING ))) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_NAK received\n")); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_NAK received\n"));
dhcp_handle_nak(netif); dhcp_handle_nak(netif);
} }
@ -1883,11 +1880,11 @@ dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type, u16_t
p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM); p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM);
if (p_out == NULL) { if (p_out == NULL) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
("dhcp_create_msg(): could not allocate pbuf\n")); ("dhcp_create_msg(): could not allocate pbuf\n"));
return NULL; return NULL;
} }
LWIP_ASSERT("dhcp_create_msg: check that first pbuf can hold struct dhcp_msg", LWIP_ASSERT("dhcp_create_msg: check that first pbuf can hold struct dhcp_msg",
(p_out->len >= sizeof(struct dhcp_msg))); (p_out->len >= sizeof(struct dhcp_msg)));
/* DHCP_REQUEST should reuse 'xid' from DHCPOFFER */ /* DHCP_REQUEST should reuse 'xid' from DHCPOFFER */
if ((message_type != DHCP_REQUEST) || (dhcp->state == DHCP_STATE_REBOOTING)) { if ((message_type != DHCP_REQUEST) || (dhcp->state == DHCP_STATE_REBOOTING)) {
@ -1964,7 +1961,7 @@ u8_t
dhcp_supplied_address(const struct netif *netif) dhcp_supplied_address(const struct netif *netif)
{ {
if ((netif != NULL) && (netif_dhcp_data(netif) != NULL)) { if ((netif != NULL) && (netif_dhcp_data(netif) != NULL)) {
struct dhcp* dhcp = netif_dhcp_data(netif); struct dhcp *dhcp = netif_dhcp_data(netif);
return (dhcp->state == DHCP_STATE_BOUND) || (dhcp->state == DHCP_STATE_RENEWING) || return (dhcp->state == DHCP_STATE_BOUND) || (dhcp->state == DHCP_STATE_RENEWING) ||
(dhcp->state == DHCP_STATE_REBINDING); (dhcp->state == DHCP_STATE_REBINDING);
} }

162
src/core/ipv4/etharp.c
View File

@ -85,7 +85,7 @@ enum etharp_state {
ETHARP_STATE_STABLE_REREQUESTING_1, ETHARP_STATE_STABLE_REREQUESTING_1,
ETHARP_STATE_STABLE_REREQUESTING_2 ETHARP_STATE_STABLE_REREQUESTING_2
#if ETHARP_SUPPORT_STATIC_ENTRIES #if ETHARP_SUPPORT_STATIC_ENTRIES
,ETHARP_STATE_STATIC , ETHARP_STATE_STATIC
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ #endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
}; };
@ -128,11 +128,11 @@ static u8_t etharp_cached_entry;
/* Some checks, instead of etharp_init(): */ /* Some checks, instead of etharp_init(): */
#if (LWIP_ARP && (ARP_TABLE_SIZE > 0x7f)) #if (LWIP_ARP && (ARP_TABLE_SIZE > 0x7f))
#error "ARP_TABLE_SIZE must fit in an s8_t, you have to reduce it in your lwipopts.h" #error "ARP_TABLE_SIZE must fit in an s8_t, you have to reduce it in your lwipopts.h"
#endif #endif
static err_t etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr* hw_dst_addr); static err_t etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr);
static err_t etharp_raw(struct netif *netif, static err_t etharp_raw(struct netif *netif,
const struct eth_addr *ethsrc_addr, const struct eth_addr *ethdst_addr, const struct eth_addr *ethsrc_addr, const struct eth_addr *ethdst_addr,
const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr, const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr,
@ -207,16 +207,16 @@ etharp_tmr(void)
u8_t state = arp_table[i].state; u8_t state = arp_table[i].state;
if (state != ETHARP_STATE_EMPTY if (state != ETHARP_STATE_EMPTY
#if ETHARP_SUPPORT_STATIC_ENTRIES #if ETHARP_SUPPORT_STATIC_ENTRIES
&& (state != ETHARP_STATE_STATIC) && (state != ETHARP_STATE_STATIC)
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ #endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
) { ) {
arp_table[i].ctime++; arp_table[i].ctime++;
if ((arp_table[i].ctime >= ARP_MAXAGE) || if ((arp_table[i].ctime >= ARP_MAXAGE) ||
((arp_table[i].state == ETHARP_STATE_PENDING) && ((arp_table[i].state == ETHARP_STATE_PENDING) &&
(arp_table[i].ctime >= ARP_MAXPENDING))) { (arp_table[i].ctime >= ARP_MAXPENDING))) {
/* pending or stable entry has become old! */ /* pending or stable entry has become old! */
LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired %s entry %"U16_F".\n", LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired %s entry %"U16_F".\n",
arp_table[i].state >= ETHARP_STATE_STABLE ? "stable" : "pending", (u16_t)i)); arp_table[i].state >= ETHARP_STATE_STABLE ? "stable" : "pending", (u16_t)i));
/* clean up entries that have just been expired */ /* clean up entries that have just been expired */
etharp_free_entry(i); etharp_free_entry(i);
} else if (arp_table[i].state == ETHARP_STATE_STABLE_REREQUESTING_1) { } else if (arp_table[i].state == ETHARP_STATE_STABLE_REREQUESTING_1) {
@ -256,7 +256,7 @@ etharp_tmr(void)
* entry is found or could be recycled. * entry is found or could be recycled.
*/ */
static s8_t static s8_t
etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif* netif) etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif *netif)
{ {
s8_t old_pending = ARP_TABLE_SIZE, old_stable = ARP_TABLE_SIZE; s8_t old_pending = ARP_TABLE_SIZE, old_stable = ARP_TABLE_SIZE;
s8_t empty = ARP_TABLE_SIZE; s8_t empty = ARP_TABLE_SIZE;
@ -292,13 +292,13 @@ etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif* netif)
empty = (s8_t)i; empty = (s8_t)i;
} else if (state != ETHARP_STATE_EMPTY) { } else if (state != ETHARP_STATE_EMPTY) {
LWIP_ASSERT("state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE", LWIP_ASSERT("state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE",
state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE); state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE);
/* if given, does IP address match IP address in ARP entry? */ /* if given, does IP address match IP address in ARP entry? */
if (ipaddr && ip4_addr_cmp(ipaddr, &arp_table[i].ipaddr) if (ipaddr && ip4_addr_cmp(ipaddr, &arp_table[i].ipaddr)
#if ETHARP_TABLE_MATCH_NETIF #if ETHARP_TABLE_MATCH_NETIF
&& ((netif == NULL) || (netif == arp_table[i].netif)) && ((netif == NULL) || (netif == arp_table[i].netif))
#endif /* ETHARP_TABLE_MATCH_NETIF */ #endif /* ETHARP_TABLE_MATCH_NETIF */
) { ) {
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: found matching entry %"U16_F"\n", (u16_t)i)); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: found matching entry %"U16_F"\n", (u16_t)i));
/* found exact IP address match, simply bail out */ /* found exact IP address match, simply bail out */
return (s8_t)i; return (s8_t)i;
@ -312,14 +312,14 @@ etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif* netif)
age_queue = arp_table[i].ctime; age_queue = arp_table[i].ctime;
} }
} else } else
/* pending without queued packets? */ /* pending without queued packets? */
{ {
if (arp_table[i].ctime >= age_pending) { if (arp_table[i].ctime >= age_pending) {
old_pending = (s8_t)i; old_pending = (s8_t)i;
age_pending = arp_table[i].ctime; age_pending = arp_table[i].ctime;
} }
} }
/* stable entry? */ /* stable entry? */
} else if (state >= ETHARP_STATE_STABLE) { } else if (state >= ETHARP_STATE_STABLE) {
#if ETHARP_SUPPORT_STATIC_ENTRIES #if ETHARP_SUPPORT_STATIC_ENTRIES
/* don't record old_stable for static entries since they never expire */ /* don't record old_stable for static entries since they never expire */
@ -366,12 +366,12 @@ etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif* netif)
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest stable entry %"U16_F"\n", (u16_t)i)); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest stable entry %"U16_F"\n", (u16_t)i));
/* no queued packets should exist on stable entries */ /* no queued packets should exist on stable entries */
LWIP_ASSERT("arp_table[i].q == NULL", arp_table[i].q == NULL); LWIP_ASSERT("arp_table[i].q == NULL", arp_table[i].q == NULL);
/* 3) found recyclable pending entry without queued packets? */ /* 3) found recyclable pending entry without queued packets? */
} else if (old_pending < ARP_TABLE_SIZE) { } else if (old_pending < ARP_TABLE_SIZE) {
/* recycle oldest pending */ /* recycle oldest pending */
i = (u8_t)old_pending; i = (u8_t)old_pending;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %"U16_F" (without queue)\n", (u16_t)i)); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %"U16_F" (without queue)\n", (u16_t)i));
/* 4) found recyclable pending entry with queued packets? */ /* 4) found recyclable pending entry with queued packets? */
} else if (old_queue < ARP_TABLE_SIZE) { } else if (old_queue < ARP_TABLE_SIZE) {
/* recycle oldest pending (queued packets are free in etharp_free_entry) */ /* recycle oldest pending (queued packets are free in etharp_free_entry) */
i = (u8_t)old_queue; i = (u8_t)old_queue;
@ -389,7 +389,7 @@ etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif* netif)
LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE); LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE);
LWIP_ASSERT("arp_table[i].state == ETHARP_STATE_EMPTY", LWIP_ASSERT("arp_table[i].state == ETHARP_STATE_EMPTY",
arp_table[i].state == ETHARP_STATE_EMPTY); arp_table[i].state == ETHARP_STATE_EMPTY);
/* IP address given? */ /* IP address given? */
if (ipaddr != NULL) { if (ipaddr != NULL) {
@ -427,9 +427,9 @@ etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct et
s8_t i; s8_t i;
LWIP_ASSERT("netif->hwaddr_len == ETH_HWADDR_LEN", netif->hwaddr_len == ETH_HWADDR_LEN); LWIP_ASSERT("netif->hwaddr_len == ETH_HWADDR_LEN", netif->hwaddr_len == ETH_HWADDR_LEN);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_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", LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_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",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr),
(u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2], (u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2],
(u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5])); (u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5]));
/* non-unicast address? */ /* non-unicast address? */
if (ip4_addr_isany(ipaddr) || if (ip4_addr_isany(ipaddr) ||
ip4_addr_isbroadcast(ipaddr, netif) || ip4_addr_isbroadcast(ipaddr, netif) ||
@ -486,7 +486,7 @@ etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct et
arp_table[i].q = NULL; arp_table[i].q = NULL;
#endif /* ARP_QUEUEING */ #endif /* ARP_QUEUEING */
/* send the queued IP packet */ /* send the queued IP packet */
ethernet_output(netif, p, (struct eth_addr*)(netif->hwaddr), ethaddr, ETHTYPE_IP); ethernet_output(netif, p, (struct eth_addr *)(netif->hwaddr), ethaddr, ETHTYPE_IP);
/* free the queued IP packet */ /* free the queued IP packet */
pbuf_free(p); pbuf_free(p);
} }
@ -507,9 +507,9 @@ etharp_add_static_entry(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr)
{ {
struct netif *netif; struct netif *netif;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_add_static_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", LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_add_static_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",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr),
(u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2], (u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2],
(u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5])); (u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5]));
netif = ip4_route(ipaddr); netif = ip4_route(ipaddr);
if (netif == NULL) { if (netif == NULL) {
@ -532,7 +532,7 @@ etharp_remove_static_entry(const ip4_addr_t *ipaddr)
{ {
s8_t i; s8_t i;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_remove_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_remove_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr)));
/* find or create ARP entry */ /* find or create ARP entry */
i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, NULL); i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, NULL);
@ -582,20 +582,20 @@ etharp_cleanup_netif(struct netif *netif)
*/ */
s8_t s8_t
etharp_find_addr(struct netif *netif, const ip4_addr_t *ipaddr, etharp_find_addr(struct netif *netif, const ip4_addr_t *ipaddr,
struct eth_addr **eth_ret, const ip4_addr_t **ip_ret) struct eth_addr **eth_ret, const ip4_addr_t **ip_ret)
{ {
s8_t i; s8_t i;
LWIP_ASSERT("eth_ret != NULL && ip_ret != NULL", LWIP_ASSERT("eth_ret != NULL && ip_ret != NULL",
eth_ret != NULL && ip_ret != NULL); eth_ret != NULL && ip_ret != NULL);
LWIP_UNUSED_ARG(netif); LWIP_UNUSED_ARG(netif);
i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, netif); i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, netif);
if ((i >= 0) && (arp_table[i].state >= ETHARP_STATE_STABLE)) { if ((i >= 0) && (arp_table[i].state >= ETHARP_STATE_STABLE)) {
*eth_ret = &arp_table[i].ethaddr; *eth_ret = &arp_table[i].ethaddr;
*ip_ret = &arp_table[i].ipaddr; *ip_ret = &arp_table[i].ipaddr;
return i; return i;
} }
return -1; return -1;
} }
@ -616,7 +616,7 @@ etharp_get_entry(u8_t i, ip4_addr_t **ipaddr, struct netif **netif, struct eth_a
LWIP_ASSERT("netif != NULL", netif != NULL); LWIP_ASSERT("netif != NULL", netif != NULL);
LWIP_ASSERT("eth_ret != NULL", eth_ret != NULL); LWIP_ASSERT("eth_ret != NULL", eth_ret != NULL);
if((i < ARP_TABLE_SIZE) && (arp_table[i].state >= ETHARP_STATE_STABLE)) { if ((i < ARP_TABLE_SIZE) && (arp_table[i].state >= ETHARP_STATE_STABLE)) {
*ipaddr = &arp_table[i].ipaddr; *ipaddr = &arp_table[i].ipaddr;
*netif = arp_table[i].netif; *netif = arp_table[i].netif;
*eth_ret = &arp_table[i].ethaddr; *eth_ret = &arp_table[i].ethaddr;
@ -656,8 +656,8 @@ etharp_input(struct pbuf *p, struct netif *netif)
(hdr->protolen != sizeof(ip4_addr_t)) || (hdr->protolen != sizeof(ip4_addr_t)) ||
(hdr->proto != PP_HTONS(ETHTYPE_IP))) { (hdr->proto != PP_HTONS(ETHTYPE_IP))) {
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("etharp_input: packet dropped, wrong hw type, hwlen, proto, protolen or ethernet type (%"U16_F"/%"U16_F"/%"U16_F"/%"U16_F")\n", ("etharp_input: packet dropped, wrong hw type, hwlen, proto, protolen or ethernet type (%"U16_F"/%"U16_F"/%"U16_F"/%"U16_F")\n",
hdr->hwtype, (u16_t)hdr->hwlen, hdr->proto, (u16_t)hdr->protolen)); hdr->hwtype, (u16_t)hdr->hwlen, hdr->proto, (u16_t)hdr->protolen));
ETHARP_STATS_INC(etharp.proterr); ETHARP_STATS_INC(etharp.proterr);
ETHARP_STATS_INC(etharp.drop); ETHARP_STATS_INC(etharp.drop);
pbuf_free(p); pbuf_free(p);
@ -691,50 +691,50 @@ etharp_input(struct pbuf *p, struct netif *netif)
ARP message not directed to us? ARP message not directed to us?
-> update the source IP address in the cache, if present */ -> update the source IP address in the cache, if present */
etharp_update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), etharp_update_arp_entry(netif, &sipaddr, &(hdr->shwaddr),
for_us ? ETHARP_FLAG_TRY_HARD : ETHARP_FLAG_FIND_ONLY); for_us ? ETHARP_FLAG_TRY_HARD : ETHARP_FLAG_FIND_ONLY);
/* now act on the message itself */ /* now act on the message itself */
switch (hdr->opcode) { switch (hdr->opcode) {
/* ARP request? */ /* ARP request? */
case PP_HTONS(ARP_REQUEST): case PP_HTONS(ARP_REQUEST):
/* ARP request. If it asked for our address, we send out a /* ARP request. If it asked for our address, we send out a
* reply. In any case, we time-stamp any existing ARP entry, * reply. In any case, we time-stamp any existing ARP entry,
* and possibly send out an IP packet that was queued on it. */ * and possibly send out an IP packet that was queued on it. */
LWIP_DEBUGF (ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP request\n")); LWIP_DEBUGF (ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP request\n"));
/* ARP request for our address? */ /* ARP request for our address? */
if (for_us) { if (for_us) {
/* send ARP response */ /* send ARP response */
etharp_raw(netif, etharp_raw(netif,
(struct eth_addr *)netif->hwaddr, &hdr->shwaddr, (struct eth_addr *)netif->hwaddr, &hdr->shwaddr,
(struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif),
&hdr->shwaddr, &sipaddr, &hdr->shwaddr, &sipaddr,
ARP_REPLY); ARP_REPLY);
/* we are not configured? */ /* we are not configured? */
} else if (ip4_addr_isany_val(*netif_ip4_addr(netif))) { } else if (ip4_addr_isany_val(*netif_ip4_addr(netif))) {
/* { for_us == 0 and netif->ip_addr.addr == 0 } */ /* { for_us == 0 and netif->ip_addr.addr == 0 } */
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: we are unconfigured, ARP request ignored.\n")); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: we are unconfigured, ARP request ignored.\n"));
/* request was not directed to us */ /* request was not directed to us */
} else { } else {
/* { for_us == 0 and netif->ip_addr.addr != 0 } */ /* { for_us == 0 and netif->ip_addr.addr != 0 } */
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP request was not for us.\n")); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP request was not for us.\n"));
} }
break; break;
case PP_HTONS(ARP_REPLY): case PP_HTONS(ARP_REPLY):
/* ARP reply. We already updated the ARP cache earlier. */ /* ARP reply. We already updated the ARP cache earlier. */
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP reply\n")); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP reply\n"));
#if (LWIP_DHCP && DHCP_DOES_ARP_CHECK) #if (LWIP_DHCP && DHCP_DOES_ARP_CHECK)
/* DHCP wants to know about ARP replies from any host with an /* DHCP wants to know about ARP replies from any host with an
* IP address also offered to us by the DHCP server. We do not * IP address also offered to us by the DHCP server. We do not
* want to take a duplicate IP address on a single network. * want to take a duplicate IP address on a single network.
* @todo How should we handle redundant (fail-over) interfaces? */ * @todo How should we handle redundant (fail-over) interfaces? */
dhcp_arp_reply(netif, &sipaddr); dhcp_arp_reply(netif, &sipaddr);
#endif /* (LWIP_DHCP && DHCP_DOES_ARP_CHECK) */ #endif /* (LWIP_DHCP && DHCP_DOES_ARP_CHECK) */
break; break;
default: default:
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP unknown opcode type %"S16_F"\n", lwip_htons(hdr->opcode))); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP unknown opcode type %"S16_F"\n", lwip_htons(hdr->opcode)));
ETHARP_STATS_INC(etharp.err); ETHARP_STATS_INC(etharp.err);
break; break;
} }
/* free ARP packet */ /* free ARP packet */
pbuf_free(p); pbuf_free(p);
@ -765,7 +765,7 @@ etharp_output_to_arp_index(struct netif *netif, struct pbuf *q, u8_t arp_idx)
} }
} }
return ethernet_output(netif, q, (struct eth_addr*)(netif->hwaddr), &arp_table[arp_idx].ethaddr, ETHTYPE_IP); return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), &arp_table[arp_idx].ethaddr, ETHTYPE_IP);
} }
/** /**
@ -804,7 +804,7 @@ etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
if (ip4_addr_isbroadcast(ipaddr, netif)) { if (ip4_addr_isbroadcast(ipaddr, netif)) {
/* broadcast on Ethernet also */ /* broadcast on Ethernet also */
dest = (const struct eth_addr *)&ethbroadcast; dest = (const struct eth_addr *)&ethbroadcast;
/* multicast destination IP address? */ /* multicast destination IP address? */
} else if (ip4_addr_ismulticast(ipaddr)) { } else if (ip4_addr_ismulticast(ipaddr)) {
/* Hash IP multicast address to MAC address.*/ /* Hash IP multicast address to MAC address.*/
mcastaddr.addr[0] = LL_IP4_MULTICAST_ADDR_0; mcastaddr.addr[0] = LL_IP4_MULTICAST_ADDR_0;
@ -815,7 +815,7 @@ etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
mcastaddr.addr[5] = ip4_addr4(ipaddr); mcastaddr.addr[5] = ip4_addr4(ipaddr);
/* destination Ethernet address is multicast */ /* destination Ethernet address is multicast */
dest = &mcastaddr; dest = &mcastaddr;
/* unicast destination IP address? */ /* unicast destination IP address? */
} else { } else {
u8_t i; u8_t i;
/* outside local network? if so, this can neither be a global broadcast nor /* outside local network? if so, this can neither be a global broadcast nor
@ -823,7 +823,7 @@ etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
if (!ip4_addr_netcmp(ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) && if (!ip4_addr_netcmp(ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) &&
!ip4_addr_islinklocal(ipaddr)) { !ip4_addr_islinklocal(ipaddr)) {
#if LWIP_AUTOIP #if LWIP_AUTOIP
struct ip_hdr *iphdr = LWIP_ALIGNMENT_CAST(struct ip_hdr*, q->payload); struct ip_hdr *iphdr = LWIP_ALIGNMENT_CAST(struct ip_hdr *, q->payload);
/* According to RFC 3297, chapter 2.6.2 (Forwarding Rules), a packet with /* According to RFC 3297, chapter 2.6.2 (Forwarding Rules), a packet with
a link-local source address must always be "directly to its destination a link-local source address must always be "directly to its destination
on the same physical link. The host MUST NOT send the packet to any on the same physical link. The host MUST NOT send the packet to any
@ -842,7 +842,7 @@ etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
if (!ip4_addr_isany_val(*netif_ip4_gw(netif))) { if (!ip4_addr_isany_val(*netif_ip4_gw(netif))) {
/* send to hardware address of default gateway IP address */ /* send to hardware address of default gateway IP address */
dst_addr = netif_ip4_gw(netif); dst_addr = netif_ip4_gw(netif);
/* no default gateway available */ /* no default gateway available */
} else { } else {
/* no route to destination error (default gateway missing) */ /* no route to destination error (default gateway missing) */
return ERR_RTE; return ERR_RTE;
@ -891,7 +891,7 @@ etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
/* continuation for multicast/broadcast destinations */ /* continuation for multicast/broadcast destinations */
/* obtain source Ethernet address of the given interface */ /* obtain source Ethernet address of the given interface */
/* send packet directly on the link */ /* send packet directly on the link */
return ethernet_output(netif, q, (struct eth_addr*)(netif->hwaddr), dest, ETHTYPE_IP); return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), dest, ETHTYPE_IP);
} }
/** /**
@ -930,7 +930,7 @@ etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr)
err_t err_t
etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q) etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q)
{ {
struct eth_addr * srcaddr = (struct eth_addr *)netif->hwaddr; struct eth_addr *srcaddr = (struct eth_addr *)netif->hwaddr;
err_t result = ERR_MEM; err_t result = ERR_MEM;
int is_new_entry = 0; int is_new_entry = 0;
s8_t i_err; s8_t i_err;
@ -968,8 +968,8 @@ etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q)
/* { i is either a STABLE or (new or existing) PENDING entry } */ /* { i is either a STABLE or (new or existing) PENDING entry } */
LWIP_ASSERT("arp_table[i].state == PENDING or STABLE", LWIP_ASSERT("arp_table[i].state == PENDING or STABLE",
((arp_table[i].state == ETHARP_STATE_PENDING) || ((arp_table[i].state == ETHARP_STATE_PENDING) ||
(arp_table[i].state >= ETHARP_STATE_STABLE))); (arp_table[i].state >= ETHARP_STATE_STABLE)));
/* do we have a new entry? or an implicit query request? */ /* do we have a new entry? or an implicit query request? */
if (is_new_entry || (q == NULL)) { if (is_new_entry || (q == NULL)) {
@ -994,7 +994,7 @@ etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q)
ETHARP_SET_ADDRHINT(netif, i); ETHARP_SET_ADDRHINT(netif, i);
/* send the packet */ /* send the packet */
result = ethernet_output(netif, q, srcaddr, &(arp_table[i].ethaddr), ETHTYPE_IP); result = ethernet_output(netif, q, srcaddr, &(arp_table[i].ethaddr), ETHTYPE_IP);
/* pending entry? (either just created or already pending */ /* pending entry? (either just created or already pending */
} else if (arp_table[i].state == ETHARP_STATE_PENDING) { } else if (arp_table[i].state == ETHARP_STATE_PENDING) {
/* entry is still pending, queue the given packet 'q' */ /* entry is still pending, queue the given packet 'q' */
struct pbuf *p; struct pbuf *p;
@ -1118,7 +1118,7 @@ etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
/* could allocate a pbuf for an ARP request? */ /* could allocate a pbuf for an ARP request? */
if (p == NULL) { if (p == NULL) {
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS,
("etharp_raw: could not allocate pbuf for ARP request.\n")); ("etharp_raw: could not allocate pbuf for ARP request.\n"));
ETHARP_STATS_INC(etharp.memerr); ETHARP_STATS_INC(etharp.memerr);
return ERR_MEM; return ERR_MEM;
} }
@ -1151,7 +1151,7 @@ etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
/* If we are using Link-Local, all ARP packets that contain a Link-Local /* If we are using Link-Local, all ARP packets that contain a Link-Local
* 'sender IP address' MUST be sent using link-layer broadcast instead of * 'sender IP address' MUST be sent using link-layer broadcast instead of
* link-layer unicast. (See RFC3927 Section 2.5, last paragraph) */ * link-layer unicast. (See RFC3927 Section 2.5, last paragraph) */
if(ip4_addr_islinklocal(ipsrc_addr)) { if (ip4_addr_islinklocal(ipsrc_addr)) {
ethernet_output(netif, p, ethsrc_addr, &ethbroadcast, ETHTYPE_ARP); ethernet_output(netif, p, ethsrc_addr, &ethbroadcast, ETHTYPE_ARP);
} else } else
#endif /* LWIP_AUTOIP */ #endif /* LWIP_AUTOIP */
@ -1181,7 +1181,7 @@ etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
* any other err_t on failure * any other err_t on failure
*/ */
static err_t static err_t
etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr* hw_dst_addr) etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr)
{ {
return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, hw_dst_addr, return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, hw_dst_addr,
(struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), &ethzero, (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), &ethzero,

308
src/core/ipv4/icmp.c
View File

@ -86,7 +86,7 @@ icmp_input(struct pbuf *p, struct netif *inp)
struct icmp_echo_hdr *iecho; struct icmp_echo_hdr *iecho;
const struct ip_hdr *iphdr_in; const struct ip_hdr *iphdr_in;
u16_t hlen; u16_t hlen;
const ip4_addr_t* src; const ip4_addr_t *src;
ICMP_STATS_INC(icmp.recv); ICMP_STATS_INC(icmp.recv);
MIB2_STATS_INC(mib2.icmpinmsgs); MIB2_STATS_INC(mib2.icmpinmsgs);
@ -97,187 +97,187 @@ icmp_input(struct pbuf *p, struct netif *inp)
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short IP header (%"S16_F" bytes) received\n", hlen)); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short IP header (%"S16_F" bytes) received\n", hlen));
goto lenerr; goto lenerr;
} }
if (p->len < sizeof(u16_t)*2) { if (p->len < sizeof(u16_t) * 2) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short ICMP (%"U16_F" bytes) received\n", p->tot_len)); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short ICMP (%"U16_F" bytes) received\n", p->tot_len));
goto lenerr; goto lenerr;
} }
type = *((u8_t *)p->payload); type = *((u8_t *)p->payload);
#ifdef LWIP_DEBUG #ifdef LWIP_DEBUG
code = *(((u8_t *)p->payload)+1); code = *(((u8_t *)p->payload) + 1);
/* if debug is enabled but debug statement below is somehow disabled: */ /* if debug is enabled but debug statement below is somehow disabled: */
LWIP_UNUSED_ARG(code); LWIP_UNUSED_ARG(code);
#endif /* LWIP_DEBUG */ #endif /* LWIP_DEBUG */
switch (type) { switch (type) {
case ICMP_ER: case ICMP_ER:
/* This is OK, echo reply might have been parsed by a raw PCB /* This is OK, echo reply might have been parsed by a raw PCB
(as obviously, an echo request has been sent, too). */ (as obviously, an echo request has been sent, too). */
MIB2_STATS_INC(mib2.icmpinechoreps); MIB2_STATS_INC(mib2.icmpinechoreps);
break; break;
case ICMP_ECHO: case ICMP_ECHO:
MIB2_STATS_INC(mib2.icmpinechos); MIB2_STATS_INC(mib2.icmpinechos);
src = ip4_current_dest_addr(); src = ip4_current_dest_addr();
/* multicast destination address? */ /* multicast destination address? */
if (ip4_addr_ismulticast(ip4_current_dest_addr())) { if (ip4_addr_ismulticast(ip4_current_dest_addr())) {
#if LWIP_MULTICAST_PING #if LWIP_MULTICAST_PING
/* For multicast, use address of receiving interface as source address */ /* For multicast, use address of receiving interface as source address */
src = netif_ip4_addr(inp); src = netif_ip4_addr(inp);
#else /* LWIP_MULTICAST_PING */ #else /* LWIP_MULTICAST_PING */
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to multicast pings\n")); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to multicast pings\n"));
goto icmperr; goto icmperr;
#endif /* LWIP_MULTICAST_PING */ #endif /* LWIP_MULTICAST_PING */
} }
/* broadcast destination address? */ /* broadcast destination address? */
if (ip4_addr_isbroadcast(ip4_current_dest_addr(), ip_current_netif())) { if (ip4_addr_isbroadcast(ip4_current_dest_addr(), ip_current_netif())) {
#if LWIP_BROADCAST_PING #if LWIP_BROADCAST_PING
/* For broadcast, use address of receiving interface as source address */ /* For broadcast, use address of receiving interface as source address */
src = netif_ip4_addr(inp); src = netif_ip4_addr(inp);
#else /* LWIP_BROADCAST_PING */ #else /* LWIP_BROADCAST_PING */
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to broadcast pings\n")); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to broadcast pings\n"));
goto icmperr; goto icmperr;
#endif /* LWIP_BROADCAST_PING */ #endif /* LWIP_BROADCAST_PING */
} }
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ping\n")); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ping\n"));
if (p->tot_len < sizeof(struct icmp_echo_hdr)) { if (p->tot_len < sizeof(struct icmp_echo_hdr)) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: bad ICMP echo received\n")); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: bad ICMP echo received\n"));
goto lenerr; goto lenerr;
} }
#if CHECKSUM_CHECK_ICMP #if CHECKSUM_CHECK_ICMP
IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_ICMP) { IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_ICMP) {
if (inet_chksum_pbuf(p) != 0) { if (inet_chksum_pbuf(p) != 0) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: checksum failed for received ICMP echo\n")); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: checksum failed for received ICMP echo\n"));
pbuf_free(p); pbuf_free(p);
ICMP_STATS_INC(icmp.chkerr); ICMP_STATS_INC(icmp.chkerr);
MIB2_STATS_INC(mib2.icmpinerrors); MIB2_STATS_INC(mib2.icmpinerrors);
return; return;
}
}
#endif
#if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN
if (pbuf_add_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) {
/* p is not big enough to contain link headers
* allocate a new one and copy p into it
*/
struct pbuf *r;
u16_t alloc_len = (u16_t)(p->tot_len + hlen);
if (alloc_len < p->tot_len) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed (tot_len overflow)\n"));
goto icmperr;
}
/* allocate new packet buffer with space for link headers */
r = pbuf_alloc(PBUF_LINK, alloc_len, PBUF_RAM);
if (r == NULL) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed\n"));
goto icmperr;
}
if (r->len < hlen + sizeof(struct icmp_echo_hdr)) {
LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("first pbuf cannot hold the ICMP header"));
pbuf_free(r);
goto icmperr;
}
/* copy the ip header */
MEMCPY(r->payload, iphdr_in, hlen);
/* switch r->payload back to icmp header (cannot fail) */
if (pbuf_remove_header(r, hlen)) {
LWIP_ASSERT("icmp_input: moving r->payload to icmp header failed\n", 0);
pbuf_free(r);
goto icmperr;
}
/* copy the rest of the packet without ip header */
if (pbuf_copy(r, p) != ERR_OK) {
LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("icmp_input: copying to new pbuf failed"));
pbuf_free(r);
goto icmperr;
}
/* free the original p */
pbuf_free(p);
/* we now have an identical copy of p that has room for link headers */
p = r;
} else {
/* restore p->payload to point to icmp header (cannot fail) */
if (pbuf_remove_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) {
LWIP_ASSERT("icmp_input: restoring original p->payload failed\n", 0);
goto icmperr;
}
}
#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN */
/* At this point, all checks are OK. */
/* We generate an answer by switching the dest and src ip addresses,
* setting the icmp type to ECHO_RESPONSE and updating the checksum. */
iecho = (struct icmp_echo_hdr *)p->payload;
if (pbuf_add_header(p, hlen)) {
LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Can't move over header in packet"));
} else {
err_t ret;
struct ip_hdr *iphdr = (struct ip_hdr*)p->payload;
ip4_addr_copy(iphdr->src, *src);
ip4_addr_copy(iphdr->dest, *ip4_current_src_addr());
ICMPH_TYPE_SET(iecho, ICMP_ER);
#if CHECKSUM_GEN_ICMP
IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP) {
/* adjust the checksum */
if (iecho->chksum > PP_HTONS(0xffffU - (ICMP_ECHO << 8))) {
iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS((u16_t)(ICMP_ECHO << 8)) + 1);
} else {
iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS(ICMP_ECHO << 8));
} }
} }
#if LWIP_CHECKSUM_CTRL_PER_NETIF #endif
else { #if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN
iecho->chksum = 0; if (pbuf_add_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) {
/* p is not big enough to contain link headers
* allocate a new one and copy p into it
*/
struct pbuf *r;
u16_t alloc_len = (u16_t)(p->tot_len + hlen);
if (alloc_len < p->tot_len) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed (tot_len overflow)\n"));
goto icmperr;
}
/* allocate new packet buffer with space for link headers */
r = pbuf_alloc(PBUF_LINK, alloc_len, PBUF_RAM);
if (r == NULL) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed\n"));
goto icmperr;
}
if (r->len < hlen + sizeof(struct icmp_echo_hdr)) {
LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("first pbuf cannot hold the ICMP header"));
pbuf_free(r);
goto icmperr;
}
/* copy the ip header */
MEMCPY(r->payload, iphdr_in, hlen);
/* switch r->payload back to icmp header (cannot fail) */
if (pbuf_remove_header(r, hlen)) {
LWIP_ASSERT("icmp_input: moving r->payload to icmp header failed\n", 0);
pbuf_free(r);
goto icmperr;
}
/* copy the rest of the packet without ip header */
if (pbuf_copy(r, p) != ERR_OK) {
LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("icmp_input: copying to new pbuf failed"));
pbuf_free(r);
goto icmperr;
}
/* free the original p */
pbuf_free(p);
/* we now have an identical copy of p that has room for link headers */
p = r;
} else {
/* restore p->payload to point to icmp header (cannot fail) */
if (pbuf_remove_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) {
LWIP_ASSERT("icmp_input: restoring original p->payload failed\n", 0);
goto icmperr;
}
} }
#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN */
/* At this point, all checks are OK. */
/* We generate an answer by switching the dest and src ip addresses,
* setting the icmp type to ECHO_RESPONSE and updating the checksum. */
iecho = (struct icmp_echo_hdr *)p->payload;
if (pbuf_add_header(p, hlen)) {
LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Can't move over header in packet"));
} else {
err_t ret;
struct ip_hdr *iphdr = (struct ip_hdr *)p->payload;
ip4_addr_copy(iphdr->src, *src);
ip4_addr_copy(iphdr->dest, *ip4_current_src_addr());
ICMPH_TYPE_SET(iecho, ICMP_ER);
#if CHECKSUM_GEN_ICMP
IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP) {
/* adjust the checksum */
if (iecho->chksum > PP_HTONS(0xffffU - (ICMP_ECHO << 8))) {
iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS((u16_t)(ICMP_ECHO << 8)) + 1);
} else {
iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS(ICMP_ECHO << 8));
}
}
#if LWIP_CHECKSUM_CTRL_PER_NETIF
else {
iecho->chksum = 0;
}
#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ #endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */
#else /* CHECKSUM_GEN_ICMP */ #else /* CHECKSUM_GEN_ICMP */
iecho->chksum = 0; iecho->chksum = 0;
#endif /* CHECKSUM_GEN_ICMP */ #endif /* CHECKSUM_GEN_ICMP */
/* Set the correct TTL and recalculate the header checksum. */ /* Set the correct TTL and recalculate the header checksum. */
IPH_TTL_SET(iphdr, ICMP_TTL); IPH_TTL_SET(iphdr, ICMP_TTL);
IPH_CHKSUM_SET(iphdr, 0); IPH_CHKSUM_SET(iphdr, 0);
#if CHECKSUM_GEN_IP #if CHECKSUM_GEN_IP
IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_IP) { IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_IP) {
IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, hlen)); IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, hlen));
} }
#endif /* CHECKSUM_GEN_IP */ #endif /* CHECKSUM_GEN_IP */
ICMP_STATS_INC(icmp.xmit); ICMP_STATS_INC(icmp.xmit);
/* increase number of messages attempted to send */ /* increase number of messages attempted to send */
MIB2_STATS_INC(mib2.icmpoutmsgs); MIB2_STATS_INC(mib2.icmpoutmsgs);
/* increase number of echo replies attempted to send */ /* increase number of echo replies attempted to send */
MIB2_STATS_INC(mib2.icmpoutechoreps); MIB2_STATS_INC(mib2.icmpoutechoreps);
/* send an ICMP packet */ /* send an ICMP packet */
ret = ip4_output_if(p, src, LWIP_IP_HDRINCL, ret = ip4_output_if(p, src, LWIP_IP_HDRINCL,
ICMP_TTL, 0, IP_PROTO_ICMP, inp); ICMP_TTL, 0, IP_PROTO_ICMP, inp);
if (ret != ERR_OK) { if (ret != ERR_OK) {
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ip_output_if returned an error: %s\n", lwip_strerr(ret))); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ip_output_if returned an error: %s\n", lwip_strerr(ret)));
}
} }
} break;
break; default:
default: if (type == ICMP_DUR) {
if (type == ICMP_DUR) { MIB2_STATS_INC(mib2.icmpindestunreachs);
MIB2_STATS_INC(mib2.icmpindestunreachs); } else if (type == ICMP_TE) {
} else if (type == ICMP_TE) { MIB2_STATS_INC(mib2.icmpintimeexcds);
MIB2_STATS_INC(mib2.icmpintimeexcds); } else if (type == ICMP_PP) {
} else if (type == ICMP_PP) { MIB2_STATS_INC(mib2.icmpinparmprobs);
MIB2_STATS_INC(mib2.icmpinparmprobs); } else if (type == ICMP_SQ) {
} else if (type == ICMP_SQ) { MIB2_STATS_INC(mib2.icmpinsrcquenchs);
MIB2_STATS_INC(mib2.icmpinsrcquenchs); } else if (type == ICMP_RD) {
} else if (type == ICMP_RD) { MIB2_STATS_INC(mib2.icmpinredirects);
MIB2_STATS_INC(mib2.icmpinredirects); } else if (type == ICMP_TS) {
} else if (type == ICMP_TS) { MIB2_STATS_INC(mib2.icmpintimestamps);
MIB2_STATS_INC(mib2.icmpintimestamps); } else if (type == ICMP_TSR) {
} else if (type == ICMP_TSR) { MIB2_STATS_INC(mib2.icmpintimestampreps);
MIB2_STATS_INC(mib2.icmpintimestampreps); } else if (type == ICMP_AM) {
} else if (type == ICMP_AM) { MIB2_STATS_INC(mib2.icmpinaddrmasks);
MIB2_STATS_INC(mib2.icmpinaddrmasks); } else if (type == ICMP_AMR) {
} else if (type == ICMP_AMR) { MIB2_STATS_INC(mib2.icmpinaddrmaskreps);
MIB2_STATS_INC(mib2.icmpinaddrmaskreps); }
} LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ICMP type %"S16_F" code %"S16_F" not supported.\n",
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ICMP type %"S16_F" code %"S16_F" not supported.\n", (s16_t)type, (s16_t)code));
(s16_t)type, (s16_t)code)); ICMP_STATS_INC(icmp.proterr);
ICMP_STATS_INC(icmp.proterr); ICMP_STATS_INC(icmp.drop);
ICMP_STATS_INC(icmp.drop);
} }
pbuf_free(p); pbuf_free(p);
return; return;
@ -358,7 +358,7 @@ icmp_send_response(struct pbuf *p, u8_t type, u8_t code)
return; return;
} }
LWIP_ASSERT("check that first pbuf can hold icmp message", LWIP_ASSERT("check that first pbuf can hold icmp message",
(q->len >= (sizeof(struct icmp_echo_hdr) + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE))); (q->len >= (sizeof(struct icmp_echo_hdr) + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE)));
iphdr = (struct ip_hdr *)p->payload; iphdr = (struct ip_hdr *)p->payload;
LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded from ")); LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded from "));

174
src/core/ipv4/igmp.c
View File

@ -97,7 +97,7 @@ Steve Reynolds
#include "string.h" #include "string.h"
static struct igmp_group *igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr); static struct igmp_group *igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr);
static err_t igmp_remove_group(struct netif* netif, struct igmp_group *group); static err_t igmp_remove_group(struct netif *netif, struct igmp_group *group);
static void igmp_timeout(struct netif *netif, struct igmp_group *group); static void igmp_timeout(struct netif *netif, struct igmp_group *group);
static void igmp_start_timer(struct igmp_group *group, u8_t max_time); static void igmp_start_timer(struct igmp_group *group, u8_t max_time);
static void igmp_delaying_member(struct igmp_group *group, u8_t maxresp); static void igmp_delaying_member(struct igmp_group *group, u8_t maxresp);
@ -127,9 +127,9 @@ igmp_init(void)
err_t err_t
igmp_start(struct netif *netif) igmp_start(struct netif *netif)
{ {
struct igmp_group* group; struct igmp_group *group;
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: starting IGMP processing on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: starting IGMP processing on if %p\n", (void *)netif));
group = igmp_lookup_group(netif, &allsystems); group = igmp_lookup_group(netif, &allsystems);
@ -141,7 +141,7 @@ igmp_start(struct netif *netif)
if (netif->igmp_mac_filter != NULL) { if (netif->igmp_mac_filter != NULL) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: igmp_mac_filter(ADD ")); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: igmp_mac_filter(ADD "));
ip4_addr_debug_print_val(IGMP_DEBUG, allsystems); ip4_addr_debug_print_val(IGMP_DEBUG, allsystems);
LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif));
netif->igmp_mac_filter(netif, &allsystems, NETIF_ADD_MAC_FILTER); netif->igmp_mac_filter(netif, &allsystems, NETIF_ADD_MAC_FILTER);
} }
@ -170,7 +170,7 @@ igmp_stop(struct netif *netif)
if (netif->igmp_mac_filter != NULL) { if (netif->igmp_mac_filter != NULL) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_stop: igmp_mac_filter(DEL ")); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_stop: igmp_mac_filter(DEL "));
ip4_addr_debug_print(IGMP_DEBUG, &group->group_address); ip4_addr_debug_print(IGMP_DEBUG, &group->group_address);
LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif));
netif->igmp_mac_filter(netif, &(group->group_address), NETIF_DEL_MAC_FILTER); netif->igmp_mac_filter(netif, &(group->group_address), NETIF_DEL_MAC_FILTER);
} }
@ -193,10 +193,10 @@ igmp_report_groups(struct netif *netif)
{ {
struct igmp_group *group = netif_igmp_data(netif); struct igmp_group *group = netif_igmp_data(netif);
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_report_groups: sending IGMP reports on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_report_groups: sending IGMP reports on if %p\n", (void *)netif));
/* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */
if(group != NULL) { if (group != NULL) {
group = group->next; group = group->next;
} }
@ -266,21 +266,21 @@ igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr)
if (list_head == NULL) { if (list_head == NULL) {
/* this is the first entry in linked list */ /* this is the first entry in linked list */
LWIP_ASSERT("igmp_lookup_group: first group must be allsystems", LWIP_ASSERT("igmp_lookup_group: first group must be allsystems",
(ip4_addr_cmp(addr, &allsystems) != 0)); (ip4_addr_cmp(addr, &allsystems) != 0));
group->next = NULL; group->next = NULL;
netif_set_client_data(ifp, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, group); netif_set_client_data(ifp, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, group);
} else { } else {
/* append _after_ first entry */ /* append _after_ first entry */
LWIP_ASSERT("igmp_lookup_group: all except first group must not be allsystems", LWIP_ASSERT("igmp_lookup_group: all except first group must not be allsystems",
(ip4_addr_cmp(addr, &allsystems) == 0)); (ip4_addr_cmp(addr, &allsystems) == 0));
group->next = list_head->next; group->next = list_head->next;
list_head->next = group; list_head->next = group;
} }
} }
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_lookup_group: %sallocated a new group with address ", (group?"":"impossible to "))); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_lookup_group: %sallocated a new group with address ", (group ? "" : "impossible to ")));
ip4_addr_debug_print(IGMP_DEBUG, addr); ip4_addr_debug_print(IGMP_DEBUG, addr);
LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void*)ifp)); LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)ifp));
return group; return group;
} }
@ -292,7 +292,7 @@ igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr)
* @return ERR_OK if group was removed from the list, an err_t otherwise * @return ERR_OK if group was removed from the list, an err_t otherwise
*/ */
static err_t static err_t
igmp_remove_group(struct netif* netif, struct igmp_group *group) igmp_remove_group(struct netif *netif, struct igmp_group *group)
{ {
err_t err = ERR_OK; err_t err = ERR_OK;
struct igmp_group *tmp_group; struct igmp_group *tmp_group;
@ -322,9 +322,9 @@ igmp_remove_group(struct netif* netif, struct igmp_group *group)
void void
igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest) igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest)
{ {
struct igmp_msg* igmp; struct igmp_msg *igmp;
struct igmp_group* group; struct igmp_group *group;
struct igmp_group* groupref; struct igmp_group *groupref;
IGMP_STATS_INC(igmp.recv); IGMP_STATS_INC(igmp.recv);
@ -340,7 +340,7 @@ igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest)
ip4_addr_debug_print(IGMP_DEBUG, &(ip4_current_header()->src)); ip4_addr_debug_print(IGMP_DEBUG, &(ip4_current_header()->src));
LWIP_DEBUGF(IGMP_DEBUG, (" to address ")); LWIP_DEBUGF(IGMP_DEBUG, (" to address "));
ip4_addr_debug_print(IGMP_DEBUG, &(ip4_current_header()->dest)); ip4_addr_debug_print(IGMP_DEBUG, &(ip4_current_header()->dest));
LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void*)inp)); LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)inp));
/* Now calculate and check the checksum */ /* Now calculate and check the checksum */
igmp = (struct igmp_msg *)p->payload; igmp = (struct igmp_msg *)p->payload;
@ -364,73 +364,73 @@ igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest)
/* NOW ACT ON THE INCOMING MESSAGE TYPE... */ /* NOW ACT ON THE INCOMING MESSAGE TYPE... */
switch (igmp->igmp_msgtype) { switch (igmp->igmp_msgtype) {
case IGMP_MEMB_QUERY: case IGMP_MEMB_QUERY:
/* IGMP_MEMB_QUERY to the "all systems" address ? */ /* IGMP_MEMB_QUERY to the "all systems" address ? */
if ((ip4_addr_cmp(dest, &allsystems)) && ip4_addr_isany(&igmp->igmp_group_address)) { if ((ip4_addr_cmp(dest, &allsystems)) && ip4_addr_isany(&igmp->igmp_group_address)) {
/* THIS IS THE GENERAL QUERY */ /* THIS IS THE GENERAL QUERY */
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: General IGMP_MEMB_QUERY on \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: General IGMP_MEMB_QUERY on \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp)));
if (igmp->igmp_maxresp == 0) { if (igmp->igmp_maxresp == 0) {
IGMP_STATS_INC(igmp.rx_v1); IGMP_STATS_INC(igmp.rx_v1);
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: got an all hosts query with time== 0 - this is V1 and not implemented - treat as v2\n")); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: got an all hosts query with time== 0 - this is V1 and not implemented - treat as v2\n"));
igmp->igmp_maxresp = IGMP_V1_DELAYING_MEMBER_TMR; igmp->igmp_maxresp = IGMP_V1_DELAYING_MEMBER_TMR;
} else {
IGMP_STATS_INC(igmp.rx_general);
}
groupref = netif_igmp_data(inp);
/* Do not send messages on the all systems group address! */
/* Skip the first group in the list, it is always the allsystems group added in igmp_start() */
if(groupref != NULL) {
groupref = groupref->next;
}
while (groupref) {
igmp_delaying_member(groupref, igmp->igmp_maxresp);
groupref = groupref->next;
}
} else {
/* IGMP_MEMB_QUERY to a specific group ? */
if (!ip4_addr_isany(&igmp->igmp_group_address)) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_MEMB_QUERY to a specific group "));
ip4_addr_debug_print(IGMP_DEBUG, &igmp->igmp_group_address);
if (ip4_addr_cmp(dest, &allsystems)) {
ip4_addr_t groupaddr;
LWIP_DEBUGF(IGMP_DEBUG, (" using \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp)));
/* we first need to re-look for the group since we used dest last time */
ip4_addr_copy(groupaddr, igmp->igmp_group_address);
group = igmp_lookfor_group(inp, &groupaddr);
} else { } else {
LWIP_DEBUGF(IGMP_DEBUG, (" with the group address as destination [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); IGMP_STATS_INC(igmp.rx_general);
} }
if (group != NULL) { groupref = netif_igmp_data(inp);
IGMP_STATS_INC(igmp.rx_group);
igmp_delaying_member(group, igmp->igmp_maxresp); /* Do not send messages on the all systems group address! */
} else { /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */
IGMP_STATS_INC(igmp.drop); if (groupref != NULL) {
groupref = groupref->next;
}
while (groupref) {
igmp_delaying_member(groupref, igmp->igmp_maxresp);
groupref = groupref->next;
} }
} else { } else {
IGMP_STATS_INC(igmp.proterr); /* IGMP_MEMB_QUERY to a specific group ? */
if (!ip4_addr_isany(&igmp->igmp_group_address)) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_MEMB_QUERY to a specific group "));
ip4_addr_debug_print(IGMP_DEBUG, &igmp->igmp_group_address);
if (ip4_addr_cmp(dest, &allsystems)) {
ip4_addr_t groupaddr;
LWIP_DEBUGF(IGMP_DEBUG, (" using \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp)));
/* we first need to re-look for the group since we used dest last time */
ip4_addr_copy(groupaddr, igmp->igmp_group_address);
group = igmp_lookfor_group(inp, &groupaddr);
} else {
LWIP_DEBUGF(IGMP_DEBUG, (" with the group address as destination [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp)));
}
if (group != NULL) {
IGMP_STATS_INC(igmp.rx_group);
igmp_delaying_member(group, igmp->igmp_maxresp);
} else {
IGMP_STATS_INC(igmp.drop);
}
} else {
IGMP_STATS_INC(igmp.proterr);
}
} }
} break;
break; case IGMP_V2_MEMB_REPORT:
case IGMP_V2_MEMB_REPORT: LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_V2_MEMB_REPORT\n"));
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_V2_MEMB_REPORT\n")); IGMP_STATS_INC(igmp.rx_report);
IGMP_STATS_INC(igmp.rx_report); if (group->group_state == IGMP_GROUP_DELAYING_MEMBER) {
if (group->group_state == IGMP_GROUP_DELAYING_MEMBER) { /* This is on a specific group we have already looked up */
/* This is on a specific group we have already looked up */ group->timer = 0; /* stopped */
group->timer = 0; /* stopped */ group->group_state = IGMP_GROUP_IDLE_MEMBER;
group->group_state = IGMP_GROUP_IDLE_MEMBER; group->last_reporter_flag = 0;
group->last_reporter_flag = 0; }
} break;
break; default:
default: LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: unexpected msg %d in state %d on group %p on if %p\n",
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: unexpected msg %d in state %d on group %p on if %p\n", igmp->igmp_msgtype, group->group_state, (void *)&group, (void *)inp));
igmp->igmp_msgtype, group->group_state, (void*)&group, (void*)inp)); IGMP_STATS_INC(igmp.proterr);
IGMP_STATS_INC(igmp.proterr); break;
break;
} }
pbuf_free(p); pbuf_free(p);
@ -505,10 +505,10 @@ igmp_joingroup_netif(struct netif *netif, const ip4_addr_t *groupaddr)
LWIP_DEBUGF(IGMP_DEBUG, ("\n")); LWIP_DEBUGF(IGMP_DEBUG, ("\n"));
/* If first use of the group, allow the group at the MAC level */ /* If first use of the group, allow the group at the MAC level */
if ((group->use==0) && (netif->igmp_mac_filter != NULL)) { if ((group->use == 0) && (netif->igmp_mac_filter != NULL)) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: igmp_mac_filter(ADD ")); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: igmp_mac_filter(ADD "));
ip4_addr_debug_print(IGMP_DEBUG, groupaddr); ip4_addr_debug_print(IGMP_DEBUG, groupaddr);
LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif));
netif->igmp_mac_filter(netif, groupaddr, NETIF_ADD_MAC_FILTER); netif->igmp_mac_filter(netif, groupaddr, NETIF_ADD_MAC_FILTER);
} }
@ -608,7 +608,7 @@ igmp_leavegroup_netif(struct netif *netif, const ip4_addr_t *groupaddr)
if (netif->igmp_mac_filter != NULL) { if (netif->igmp_mac_filter != NULL) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: igmp_mac_filter(DEL ")); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: igmp_mac_filter(DEL "));
ip4_addr_debug_print(IGMP_DEBUG, groupaddr); ip4_addr_debug_print(IGMP_DEBUG, groupaddr);
LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif));
netif->igmp_mac_filter(netif, groupaddr, NETIF_DEL_MAC_FILTER); netif->igmp_mac_filter(netif, groupaddr, NETIF_DEL_MAC_FILTER);
} }
@ -664,10 +664,10 @@ igmp_timeout(struct netif *netif, struct igmp_group *group)
(!(ip4_addr_cmp(&(group->group_address), &allsystems)))) { (!(ip4_addr_cmp(&(group->group_address), &allsystems)))) {
LWIP_DEBUGF(IGMP_DEBUG, ("igmp_timeout: report membership for group with address ")); LWIP_DEBUGF(IGMP_DEBUG, ("igmp_timeout: report membership for group with address "));
ip4_addr_debug_print(IGMP_DEBUG, &(group->group_address)); ip4_addr_debug_print(IGMP_DEBUG, &(group->group_address));
LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void*)netif)); LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)netif));
group->group_state = IGMP_GROUP_IDLE_MEMBER; group->group_state = IGMP_GROUP_IDLE_MEMBER;
IGMP_STATS_INC(igmp.tx_report); IGMP_STATS_INC(igmp.tx_report);
igmp_send(netif, group, IGMP_V2_MEMB_REPORT); igmp_send(netif, group, IGMP_V2_MEMB_REPORT);
} }
@ -705,8 +705,8 @@ static void
igmp_delaying_member(struct igmp_group *group, u8_t maxresp) igmp_delaying_member(struct igmp_group *group, u8_t maxresp)
{ {
if ((group->group_state == IGMP_GROUP_IDLE_MEMBER) || if ((group->group_state == IGMP_GROUP_IDLE_MEMBER) ||
((group->group_state == IGMP_GROUP_DELAYING_MEMBER) && ((group->group_state == IGMP_GROUP_DELAYING_MEMBER) &&
((group->timer == 0) || (maxresp < group->timer)))) { ((group->timer == 0) || (maxresp < group->timer)))) {
igmp_start_timer(group, maxresp); igmp_start_timer(group, maxresp);
group->group_state = IGMP_GROUP_DELAYING_MEMBER; group->group_state = IGMP_GROUP_DELAYING_MEMBER;
} }
@ -749,10 +749,10 @@ igmp_ip_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
static void static void
igmp_send(struct netif *netif, struct igmp_group *group, u8_t type) igmp_send(struct netif *netif, struct igmp_group *group, u8_t type)
{ {
struct pbuf* p = NULL; struct pbuf *p = NULL;
struct igmp_msg* igmp = NULL; struct igmp_msg *igmp = NULL;
ip4_addr_t src = *IP4_ADDR_ANY4; ip4_addr_t src = *IP4_ADDR_ANY4;
ip4_addr_t* dest = NULL; ip4_addr_t *dest = NULL;
/* IP header + "router alert" option + IGMP header */ /* IP header + "router alert" option + IGMP header */
p = pbuf_alloc(PBUF_TRANSPORT, IGMP_MINLEN, PBUF_RAM); p = pbuf_alloc(PBUF_TRANSPORT, IGMP_MINLEN, PBUF_RAM);
@ -760,7 +760,7 @@ igmp_send(struct netif *netif, struct igmp_group *group, u8_t type)
if (p) { if (p) {
igmp = (struct igmp_msg *)p->payload; igmp = (struct igmp_msg *)p->payload;
LWIP_ASSERT("igmp_send: check that first pbuf can hold struct igmp_msg", LWIP_ASSERT("igmp_send: check that first pbuf can hold struct igmp_msg",
(p->len >= sizeof(struct igmp_msg))); (p->len >= sizeof(struct igmp_msg)));
ip4_addr_copy(src, *netif_ip4_addr(netif)); ip4_addr_copy(src, *netif_ip4_addr(netif));
if (type == IGMP_V2_MEMB_REPORT) { if (type == IGMP_V2_MEMB_REPORT) {

184
src/core/ipv4/ip4.c
View File

@ -108,13 +108,13 @@ static u16_t ip_id;
#if LWIP_MULTICAST_TX_OPTIONS #if LWIP_MULTICAST_TX_OPTIONS
/** The default netif used for multicast */ /** The default netif used for multicast */
static struct netif* ip4_default_multicast_netif; static struct netif *ip4_default_multicast_netif;
/** /**
* @ingroup ip4 * @ingroup ip4
* Set a default netif for IPv4 multicast. */ * Set a default netif for IPv4 multicast. */
void void
ip4_set_default_multicast_netif(struct netif* default_multicast_netif) ip4_set_default_multicast_netif(struct netif *default_multicast_netif)
{ {
ip4_default_multicast_netif = default_multicast_netif; ip4_default_multicast_netif = default_multicast_netif;
} }
@ -213,7 +213,7 @@ ip4_route(const ip4_addr_t *dest)
/* No matching netif found and default netif is not usable. /* No matching netif found and default netif is not usable.
If this is not good enough for you, use LWIP_HOOK_IP4_ROUTE() */ If this is not good enough for you, use LWIP_HOOK_IP4_ROUTE() */
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));
IP_STATS_INC(ip.rterr); IP_STATS_INC(ip.rterr);
MIB2_STATS_INC(mib2.ipoutnoroutes); MIB2_STATS_INC(mib2.ipoutnoroutes);
return NULL; return NULL;
@ -281,8 +281,8 @@ ip4_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
/* RFC3927 2.7: do not forward link-local addresses */ /* RFC3927 2.7: do not forward link-local addresses */
if (ip4_addr_islinklocal(ip4_current_dest_addr())) { if (ip4_addr_islinklocal(ip4_current_dest_addr())) {
LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not forwarding LLA %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not forwarding LLA %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()),
ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr())));
goto return_noroute; goto return_noroute;
} }
@ -290,8 +290,8 @@ ip4_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
netif = ip4_route_src(ip4_current_src_addr(), ip4_current_dest_addr()); netif = ip4_route_src(ip4_current_src_addr(), ip4_current_dest_addr());
if (netif == NULL) { if (netif == NULL) {
LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: no forwarding route for %"U16_F".%"U16_F".%"U16_F".%"U16_F" found\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: no forwarding route for %"U16_F".%"U16_F".%"U16_F".%"U16_F" found\n",
ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()),
ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr())));
/* @todo: send ICMP_DUR_NET? */ /* @todo: send ICMP_DUR_NET? */
goto return_noroute; goto return_noroute;
} }
@ -326,8 +326,8 @@ ip4_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp)
} }
LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: forwarding packet to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: forwarding packet to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()),
ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr())));
IP_STATS_INC(ip.fw); IP_STATS_INC(ip.fw);
MIB2_STATS_INC(mib2.ipforwdatagrams); MIB2_STATS_INC(mib2.ipforwdatagrams);
@ -363,10 +363,10 @@ static int
ip4_input_accept(struct netif *netif) ip4_input_accept(struct netif *netif)
{ {
LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%"X32_F" netif->ip_addr 0x%"X32_F" (0x%"X32_F", 0x%"X32_F", 0x%"X32_F")\n", LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%"X32_F" netif->ip_addr 0x%"X32_F" (0x%"X32_F", 0x%"X32_F", 0x%"X32_F")\n",
ip4_addr_get_u32(ip4_current_dest_addr()), ip4_addr_get_u32(netif_ip4_addr(netif)), ip4_addr_get_u32(ip4_current_dest_addr()), ip4_addr_get_u32(netif_ip4_addr(netif)),
ip4_addr_get_u32(ip4_current_dest_addr()) & ip4_addr_get_u32(netif_ip4_netmask(netif)), ip4_addr_get_u32(ip4_current_dest_addr()) & ip4_addr_get_u32(netif_ip4_netmask(netif)),
ip4_addr_get_u32(netif_ip4_addr(netif)) & ip4_addr_get_u32(netif_ip4_netmask(netif)), ip4_addr_get_u32(netif_ip4_addr(netif)) & ip4_addr_get_u32(netif_ip4_netmask(netif)),
ip4_addr_get_u32(ip4_current_dest_addr()) & ~ip4_addr_get_u32(netif_ip4_netmask(netif)))); ip4_addr_get_u32(ip4_current_dest_addr()) & ~ip4_addr_get_u32(netif_ip4_netmask(netif))));
/* interface is up and configured? */ /* interface is up and configured? */
if ((netif_is_up(netif)) && (!ip4_addr_isany_val(*netif_ip4_addr(netif)))) { if ((netif_is_up(netif)) && (!ip4_addr_isany_val(*netif_ip4_addr(netif)))) {
@ -377,9 +377,9 @@ ip4_input_accept(struct netif *netif)
#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF #if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF
|| (ip4_addr_get_u32(ip4_current_dest_addr()) == PP_HTONL(IPADDR_LOOPBACK)) || (ip4_addr_get_u32(ip4_current_dest_addr()) == PP_HTONL(IPADDR_LOOPBACK))
#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ #endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */
) { ) {
LWIP_DEBUGF(IP_DEBUG, ("ip4_input: packet accepted on interface %c%c\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_input: packet accepted on interface %c%c\n",
netif->name[0], netif->name[1])); netif->name[0], netif->name[1]));
/* accept on this netif */ /* accept on this netif */
return 1; return 1;
} }
@ -388,7 +388,7 @@ ip4_input_accept(struct netif *netif)
the netif's address (RFC3927 ch. 1.9) */ the netif's address (RFC3927 ch. 1.9) */
if (autoip_accept_packet(netif, ip4_current_dest_addr())) { if (autoip_accept_packet(netif, ip4_current_dest_addr())) {
LWIP_DEBUGF(IP_DEBUG, ("ip4_input: LLA packet accepted on interface %c%c\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_input: LLA packet accepted on interface %c%c\n",
netif->name[0], netif->name[1])); netif->name[0], netif->name[1]));
/* accept on this netif */ /* accept on this netif */
return 1; return 1;
} }
@ -458,17 +458,17 @@ ip4_input(struct pbuf *p, struct netif *inp)
if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len) || (iphdr_hlen < IP_HLEN)) { if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len) || (iphdr_hlen < IP_HLEN)) {
if (iphdr_hlen < IP_HLEN) { if (iphdr_hlen < IP_HLEN) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
("ip4_input: short IP header (%"U16_F" bytes) received, IP packet dropped\n", iphdr_hlen)); ("ip4_input: short IP header (%"U16_F" bytes) received, IP packet dropped\n", iphdr_hlen));
} }
if (iphdr_hlen > p->len) { if (iphdr_hlen > p->len) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
("IP header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n", ("IP header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n",
iphdr_hlen, p->len)); iphdr_hlen, p->len));
} }
if (iphdr_len > p->tot_len) { if (iphdr_len > p->tot_len) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n", ("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n",
iphdr_len, p->tot_len)); iphdr_len, p->tot_len));
} }
/* free (drop) packet pbufs */ /* free (drop) packet pbufs */
pbuf_free(p); pbuf_free(p);
@ -484,7 +484,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
if (inet_chksum(iphdr, iphdr_hlen) != 0) { if (inet_chksum(iphdr, iphdr_hlen) != 0) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
("Checksum (0x%"X16_F") failed, IP packet dropped.\n", inet_chksum(iphdr, iphdr_hlen))); ("Checksum (0x%"X16_F") failed, IP packet dropped.\n", inet_chksum(iphdr, iphdr_hlen)));
ip4_debug_print(p); ip4_debug_print(p);
pbuf_free(p); pbuf_free(p);
IP_STATS_INC(ip.chkerr); IP_STATS_INC(ip.chkerr);
@ -565,7 +565,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
if (IPH_PROTO(iphdr) == IP_PROTO_UDP) { if (IPH_PROTO(iphdr) == IP_PROTO_UDP) {
const struct udp_hdr *udphdr = (const struct udp_hdr *)((const u8_t *)iphdr + iphdr_hlen); const struct udp_hdr *udphdr = (const struct udp_hdr *)((const u8_t *)iphdr + iphdr_hlen);
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n", LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n",
lwip_ntohs(udphdr->dest))); lwip_ntohs(udphdr->dest)));
if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) { if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n")); LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n"));
netif = inp; netif = inp;
@ -579,7 +579,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
#if LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING #if LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING
if (check_ip_src if (check_ip_src
#if IP_ACCEPT_LINK_LAYER_ADDRESSING #if IP_ACCEPT_LINK_LAYER_ADDRESSING
/* DHCP servers need 0.0.0.0 to be allowed as source address (RFC 1.1.2.2: 3.2.1.3/a) */ /* DHCP servers need 0.0.0.0 to be allowed as source address (RFC 1.1.2.2: 3.2.1.3/a) */
&& !ip4_addr_isany_val(*ip4_current_src_addr()) && !ip4_addr_isany_val(*ip4_current_src_addr())
#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ #endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */
) )
@ -621,7 +621,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) { if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) {
#if IP_REASSEMBLY /* packet fragment reassembly code present? */ #if IP_REASSEMBLY /* packet fragment reassembly code present? */
LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n", LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n",
lwip_ntohs(IPH_ID(iphdr)), p->tot_len, lwip_ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)*8))); lwip_ntohs(IPH_ID(iphdr)), p->tot_len, lwip_ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK) * 8)));
/* reassemble the packet*/ /* reassemble the packet*/
p = ip4_reass(p); p = ip4_reass(p);
/* packet not fully reassembled yet? */ /* packet not fully reassembled yet? */
@ -632,7 +632,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
#else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */ #else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */
pbuf_free(p); pbuf_free(p);
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n", LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n",
lwip_ntohs(IPH_OFFSET(iphdr)))); lwip_ntohs(IPH_OFFSET(iphdr))));
IP_STATS_INC(ip.opterr); IP_STATS_INC(ip.opterr);
IP_STATS_INC(ip.drop); IP_STATS_INC(ip.drop);
/* unsupported protocol feature */ /* unsupported protocol feature */
@ -678,47 +678,47 @@ ip4_input(struct pbuf *p, struct netif *inp)
switch (IPH_PROTO(iphdr)) { switch (IPH_PROTO(iphdr)) {
#if LWIP_UDP #if LWIP_UDP
case IP_PROTO_UDP: case IP_PROTO_UDP:
#if LWIP_UDPLITE #if LWIP_UDPLITE
case IP_PROTO_UDPLITE: case IP_PROTO_UDPLITE:
#endif /* LWIP_UDPLITE */ #endif /* LWIP_UDPLITE */
MIB2_STATS_INC(mib2.ipindelivers); MIB2_STATS_INC(mib2.ipindelivers);
udp_input(p, inp); udp_input(p, inp);
break; break;
#endif /* LWIP_UDP */ #endif /* LWIP_UDP */
#if LWIP_TCP #if LWIP_TCP
case IP_PROTO_TCP: case IP_PROTO_TCP:
MIB2_STATS_INC(mib2.ipindelivers); MIB2_STATS_INC(mib2.ipindelivers);
tcp_input(p, inp); tcp_input(p, inp);
break; break;
#endif /* LWIP_TCP */ #endif /* LWIP_TCP */
#if LWIP_ICMP #if LWIP_ICMP
case IP_PROTO_ICMP: case IP_PROTO_ICMP:
MIB2_STATS_INC(mib2.ipindelivers); MIB2_STATS_INC(mib2.ipindelivers);
icmp_input(p, inp); icmp_input(p, inp);
break; break;
#endif /* LWIP_ICMP */ #endif /* LWIP_ICMP */
#if LWIP_IGMP #if LWIP_IGMP
case IP_PROTO_IGMP: case IP_PROTO_IGMP:
igmp_input(p, inp, ip4_current_dest_addr()); igmp_input(p, inp, ip4_current_dest_addr());
break; break;
#endif /* LWIP_IGMP */ #endif /* LWIP_IGMP */
default: default:
#if LWIP_ICMP #if LWIP_ICMP
/* send ICMP destination protocol unreachable unless is was a broadcast */ /* send ICMP destination protocol unreachable unless is was a broadcast */
if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) && if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) &&
!ip4_addr_ismulticast(ip4_current_dest_addr())) { !ip4_addr_ismulticast(ip4_current_dest_addr())) {
pbuf_header_force(p, (s16_t)iphdr_hlen); /* Move to ip header, no check necessary. */ pbuf_header_force(p, (s16_t)iphdr_hlen); /* Move to ip header, no check necessary. */
icmp_dest_unreach(p, ICMP_DUR_PROTO); icmp_dest_unreach(p, ICMP_DUR_PROTO);
} }
#endif /* LWIP_ICMP */ #endif /* LWIP_ICMP */
pbuf_free(p); pbuf_free(p);
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Unsupported transport protocol %"U16_F"\n", (u16_t)IPH_PROTO(iphdr))); LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Unsupported transport protocol %"U16_F"\n", (u16_t)IPH_PROTO(iphdr)));
IP_STATS_INC(ip.proterr); IP_STATS_INC(ip.proterr);
IP_STATS_INC(ip.drop); IP_STATS_INC(ip.drop);
MIB2_STATS_INC(mib2.ipinunknownprotos); MIB2_STATS_INC(mib2.ipinunknownprotos);
} }
} }
@ -760,8 +760,8 @@ ip4_input(struct pbuf *p, struct netif *inp)
*/ */
err_t err_t
ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
u8_t ttl, u8_t tos, u8_t ttl, u8_t tos,
u8_t proto, struct netif *netif) u8_t proto, struct netif *netif)
{ {
#if IP_OPTIONS_SEND #if IP_OPTIONS_SEND
return ip4_output_if_opt(p, src, dest, ttl, tos, proto, netif, NULL, 0); return ip4_output_if_opt(p, src, dest, ttl, tos, proto, netif, NULL, 0);
@ -775,8 +775,8 @@ ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
*/ */
err_t err_t
ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options,
u16_t optlen) u16_t optlen)
{ {
#endif /* IP_OPTIONS_SEND */ #endif /* IP_OPTIONS_SEND */
const ip4_addr_t *src_used = src; const ip4_addr_t *src_used = src;
@ -788,7 +788,7 @@ ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
#if IP_OPTIONS_SEND #if IP_OPTIONS_SEND
return ip4_output_if_opt_src(p, src_used, dest, ttl, tos, proto, netif, return ip4_output_if_opt_src(p, src_used, dest, ttl, tos, proto, netif,
ip_options, optlen); ip_options, optlen);
#else /* IP_OPTIONS_SEND */ #else /* IP_OPTIONS_SEND */
return ip4_output_if_src(p, src_used, dest, ttl, tos, proto, netif); return ip4_output_if_src(p, src_used, dest, ttl, tos, proto, netif);
#endif /* IP_OPTIONS_SEND */ #endif /* IP_OPTIONS_SEND */
@ -800,8 +800,8 @@ ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
*/ */
err_t err_t
ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
u8_t ttl, u8_t tos, u8_t ttl, u8_t tos,
u8_t proto, struct netif *netif) u8_t proto, struct netif *netif)
{ {
#if IP_OPTIONS_SEND #if IP_OPTIONS_SEND
return ip4_output_if_opt_src(p, src, dest, ttl, tos, proto, netif, NULL, 0); return ip4_output_if_opt_src(p, src, dest, ttl, tos, proto, netif, NULL, 0);
@ -813,8 +813,8 @@ ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
*/ */
err_t err_t
ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options,
u16_t optlen) u16_t optlen)
{ {
#endif /* IP_OPTIONS_SEND */ #endif /* IP_OPTIONS_SEND */
struct ip_hdr *iphdr; struct ip_hdr *iphdr;
@ -856,11 +856,11 @@ ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *d
MEMCPY(p->payload, ip_options, optlen); MEMCPY(p->payload, ip_options, optlen);
if (optlen < optlen_aligned) { if (optlen < optlen_aligned) {
/* zero the remaining bytes */ /* zero the remaining bytes */
memset(((char*)p->payload) + optlen, 0, (size_t)(optlen_aligned - optlen)); memset(((char *)p->payload) + optlen, 0, (size_t)(optlen_aligned - optlen));
} }
#if CHECKSUM_GEN_IP_INLINE #if CHECKSUM_GEN_IP_INLINE
for (i = 0; i < optlen_aligned/2; i++) { for (i = 0; i < optlen_aligned / 2; i++) {
chk_sum += ((u16_t*)p->payload)[i]; chk_sum += ((u16_t *)p->payload)[i];
} }
#endif /* CHECKSUM_GEN_IP_INLINE */ #endif /* CHECKSUM_GEN_IP_INLINE */
} }
@ -876,7 +876,7 @@ ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *d
iphdr = (struct ip_hdr *)p->payload; iphdr = (struct ip_hdr *)p->payload;
LWIP_ASSERT("check that first pbuf can hold struct ip_hdr", LWIP_ASSERT("check that first pbuf can hold struct ip_hdr",
(p->len >= sizeof(struct ip_hdr))); (p->len >= sizeof(struct ip_hdr)));
IPH_TTL_SET(iphdr, ttl); IPH_TTL_SET(iphdr, ttl);
IPH_PROTO_SET(iphdr, proto); IPH_PROTO_SET(iphdr, proto);
@ -959,7 +959,7 @@ ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *d
#if !LWIP_HAVE_LOOPIF #if !LWIP_HAVE_LOOPIF
|| ip4_addr_isloopback(dest) || ip4_addr_isloopback(dest)
#endif /* !LWIP_HAVE_LOOPIF */ #endif /* !LWIP_HAVE_LOOPIF */
) { ) {
/* Packet to self, enqueue it for loopback */ /* Packet to self, enqueue it for loopback */
LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()")); LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()"));
return netif_loop_output(netif, p); return netif_loop_output(netif, p);
@ -1000,7 +1000,7 @@ ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *d
*/ */
err_t err_t
ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
u8_t ttl, u8_t tos, u8_t proto) u8_t ttl, u8_t tos, u8_t proto)
{ {
struct netif *netif; struct netif *netif;
@ -1008,7 +1008,7 @@ ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
if ((netif = ip4_route_src(src, dest)) == NULL) { if ((netif = ip4_route_src(src, dest)) == NULL) {
LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));
IP_STATS_INC(ip.rterr); IP_STATS_INC(ip.rterr);
return ERR_RTE; return ERR_RTE;
} }
@ -1037,7 +1037,7 @@ ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
*/ */
err_t err_t
ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
u8_t ttl, u8_t tos, u8_t proto, struct netif_hint *netif_hint) u8_t ttl, u8_t tos, u8_t proto, struct netif_hint *netif_hint)
{ {
struct netif *netif; struct netif *netif;
err_t err; err_t err;
@ -1046,7 +1046,7 @@ ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest,
if ((netif = ip4_route_src(src, dest)) == NULL) { if ((netif = ip4_route_src(src, dest)) == NULL) {
LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest)));
IP_STATS_INC(ip.rterr); IP_STATS_INC(ip.rterr);
return ERR_RTE; return ERR_RTE;
} }
@ -1071,34 +1071,34 @@ ip4_debug_print(struct pbuf *p)
LWIP_DEBUGF(IP_DEBUG, ("IP header:\n")); LWIP_DEBUGF(IP_DEBUG, ("IP header:\n"));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("|%2"S16_F" |%2"S16_F" | 0x%02"X16_F" | %5"U16_F" | (v, hl, tos, len)\n", LWIP_DEBUGF(IP_DEBUG, ("|%2"S16_F" |%2"S16_F" | 0x%02"X16_F" | %5"U16_F" | (v, hl, tos, len)\n",
(u16_t)IPH_V(iphdr), (u16_t)IPH_V(iphdr),
(u16_t)IPH_HL(iphdr), (u16_t)IPH_HL(iphdr),
(u16_t)IPH_TOS(iphdr), (u16_t)IPH_TOS(iphdr),
lwip_ntohs(IPH_LEN(iphdr)))); lwip_ntohs(IPH_LEN(iphdr))));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %5"U16_F" |%"U16_F"%"U16_F"%"U16_F"| %4"U16_F" | (id, flags, offset)\n", LWIP_DEBUGF(IP_DEBUG, ("| %5"U16_F" |%"U16_F"%"U16_F"%"U16_F"| %4"U16_F" | (id, flags, offset)\n",
lwip_ntohs(IPH_ID(iphdr)), lwip_ntohs(IPH_ID(iphdr)),
(u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 15 & 1), (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 15 & 1),
(u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 14 & 1), (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 14 & 1),
(u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 13 & 1), (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 13 & 1),
(u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK))); (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | 0x%04"X16_F" | (ttl, proto, chksum)\n", LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | 0x%04"X16_F" | (ttl, proto, chksum)\n",
(u16_t)IPH_TTL(iphdr), (u16_t)IPH_TTL(iphdr),
(u16_t)IPH_PROTO(iphdr), (u16_t)IPH_PROTO(iphdr),
lwip_ntohs(IPH_CHKSUM(iphdr)))); lwip_ntohs(IPH_CHKSUM(iphdr))));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (src)\n", LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (src)\n",
ip4_addr1_16(&iphdr->src), ip4_addr1_16(&iphdr->src),
ip4_addr2_16(&iphdr->src), ip4_addr2_16(&iphdr->src),
ip4_addr3_16(&iphdr->src), ip4_addr3_16(&iphdr->src),
ip4_addr4_16(&iphdr->src))); ip4_addr4_16(&iphdr->src)));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (dest)\n", LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (dest)\n",
ip4_addr1_16(&iphdr->dest), ip4_addr1_16(&iphdr->dest),
ip4_addr2_16(&iphdr->dest), ip4_addr2_16(&iphdr->dest),
ip4_addr3_16(&iphdr->dest), ip4_addr3_16(&iphdr->dest),
ip4_addr4_16(&iphdr->dest))); ip4_addr4_16(&iphdr->dest)));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
} }
#endif /* IP_DEBUG */ #endif /* IP_DEBUG */

84
src/core/ipv4/ip4_addr.c
View File

@ -64,19 +64,19 @@ ip4_addr_isbroadcast_u32(u32_t addr, const struct netif *netif)
if ((~addr == IPADDR_ANY) || if ((~addr == IPADDR_ANY) ||
(addr == IPADDR_ANY)) { (addr == IPADDR_ANY)) {
return 1; return 1;
/* no broadcast support on this network interface? */ /* no broadcast support on this network interface? */
} else if ((netif->flags & NETIF_FLAG_BROADCAST) == 0) { } else if ((netif->flags & NETIF_FLAG_BROADCAST) == 0) {
/* the given address cannot be a broadcast address /* the given address cannot be a broadcast address
* nor can we check against any broadcast addresses */ * nor can we check against any broadcast addresses */
return 0; return 0;
/* address matches network interface address exactly? => no broadcast */ /* address matches network interface address exactly? => no broadcast */
} else if (addr == ip4_addr_get_u32(netif_ip4_addr(netif))) { } else if (addr == ip4_addr_get_u32(netif_ip4_addr(netif))) {
return 0; return 0;
/* on the same (sub) network... */ /* on the same (sub) network... */
} else if (ip4_addr_netcmp(&ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) } else if (ip4_addr_netcmp(&ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif))
/* ...and host identifier bits are all ones? =>... */ /* ...and host identifier bits are all ones? =>... */
&& ((addr & ~ip4_addr_get_u32(netif_ip4_netmask(netif))) == && ((addr & ~ip4_addr_get_u32(netif_ip4_netmask(netif))) ==
(IPADDR_BROADCAST & ~ip4_addr_get_u32(netif_ip4_netmask(netif))))) { (IPADDR_BROADCAST & ~ip4_addr_get_u32(netif_ip4_netmask(netif))))) {
/* => network broadcast address */ /* => network broadcast address */
return 1; return 1;
} else { } else {
@ -220,44 +220,44 @@ ip4addr_aton(const char *cp, ip4_addr_t *addr)
*/ */
switch (pp - parts + 1) { switch (pp - parts + 1) {
case 0: case 0:
return 0; /* initial nondigit */ return 0; /* initial nondigit */
case 1: /* a -- 32 bits */ case 1: /* a -- 32 bits */
break; break;
case 2: /* a.b -- 8.24 bits */ case 2: /* a.b -- 8.24 bits */
if (val > 0xffffffUL) { if (val > 0xffffffUL) {
return 0; return 0;
} }
if (parts[0] > 0xff) { if (parts[0] > 0xff) {
return 0; return 0;
} }
val |= parts[0] << 24; val |= parts[0] << 24;
break; break;
case 3: /* a.b.c -- 8.8.16 bits */ case 3: /* a.b.c -- 8.8.16 bits */
if (val > 0xffff) { if (val > 0xffff) {
return 0; return 0;
} }
if ((parts[0] > 0xff) || (parts[1] > 0xff)) { if ((parts[0] > 0xff) || (parts[1] > 0xff)) {
return 0; return 0;
} }
val |= (parts[0] << 24) | (parts[1] << 16); val |= (parts[0] << 24) | (parts[1] << 16);
break; break;
case 4: /* a.b.c.d -- 8.8.8.8 bits */ case 4: /* a.b.c.d -- 8.8.8.8 bits */
if (val > 0xff) { if (val > 0xff) {
return 0; return 0;
} }
if ((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) { if ((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) {
return 0; return 0;
} }
val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8); val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
break; break;
default: default:
LWIP_ASSERT("unhandled", 0); LWIP_ASSERT("unhandled", 0);
break; break;
} }
if (addr) { if (addr) {
ip4_addr_set_u32(addr, lwip_htonl(val)); ip4_addr_set_u32(addr, lwip_htonl(val));
@ -273,7 +273,7 @@ ip4addr_aton(const char *cp, ip4_addr_t *addr)
* @return pointer to a global static (!) buffer that holds the ASCII * @return pointer to a global static (!) buffer that holds the ASCII
* representation of addr * representation of addr
*/ */
char* char *
ip4addr_ntoa(const ip4_addr_t *addr) ip4addr_ntoa(const ip4_addr_t *addr)
{ {
static char str[IP4ADDR_STRLEN_MAX]; static char str[IP4ADDR_STRLEN_MAX];
@ -289,7 +289,7 @@ ip4addr_ntoa(const ip4_addr_t *addr)
* @return either pointer to buf which now holds the ASCII * @return either pointer to buf which now holds the ASCII
* representation of addr or NULL if buf was too small * representation of addr or NULL if buf was too small
*/ */
char* char *
ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen) ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen)
{ {
u32_t s_addr; u32_t s_addr;

74
src/core/ipv4/ip4_frag.c
View File

@ -135,7 +135,7 @@ ip_reass_tmr(void)
* clean up the incomplete fragment assembly */ * clean up the incomplete fragment assembly */
if (r->timer > 0) { if (r->timer > 0) {
r->timer--; r->timer--;
LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer dec %"U16_F"\n",(u16_t)r->timer)); LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer dec %"U16_F"\n", (u16_t)r->timer));
prev = r; prev = r;
r = r->next; r = r->next;
} else { } else {
@ -147,8 +147,8 @@ ip_reass_tmr(void)
r = r->next; r = r->next;
/* free the helper struct and all enqueued pbufs */ /* free the helper struct and all enqueued pbufs */
ip_reass_free_complete_datagram(tmp, prev); ip_reass_free_complete_datagram(tmp, prev);
} }
} }
} }
/** /**
@ -274,10 +274,10 @@ ip_reass_remove_oldest_datagram(struct ip_hdr *fraghdr, int pbufs_needed)
* @param clen number of pbufs needed to enqueue (used for freeing other datagrams if not enough space) * @param clen number of pbufs needed to enqueue (used for freeing other datagrams if not enough space)
* @return A pointer to the queue location into which the fragment was enqueued * @return A pointer to the queue location into which the fragment was enqueued
*/ */
static struct ip_reassdata* static struct ip_reassdata *
ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen) ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen)
{ {
struct ip_reassdata* ipr; struct ip_reassdata *ipr;
#if ! IP_REASS_FREE_OLDEST #if ! IP_REASS_FREE_OLDEST
LWIP_UNUSED_ARG(clen); LWIP_UNUSED_ARG(clen);
#endif #endif
@ -293,7 +293,7 @@ ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen)
#endif /* IP_REASS_FREE_OLDEST */ #endif /* IP_REASS_FREE_OLDEST */
{ {
IPFRAG_STATS_INC(ip_frag.memerr); IPFRAG_STATS_INC(ip_frag.memerr);
LWIP_DEBUGF(IP_REASS_DEBUG,("Failed to alloc reassdata struct\n")); LWIP_DEBUGF(IP_REASS_DEBUG, ("Failed to alloc reassdata struct\n"));
return NULL; return NULL;
} }
} }
@ -343,7 +343,7 @@ ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev)
static int static int
ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p, int is_last) ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p, int is_last)
{ {
struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev=NULL; struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev = NULL;
struct pbuf *q; struct pbuf *q;
u16_t offset, len, clen; u16_t offset, len, clen;
u8_t hlen; u8_t hlen;
@ -351,7 +351,7 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
int valid = 1; int valid = 1;
/* Extract length and fragment offset from current fragment */ /* Extract length and fragment offset from current fragment */
fraghdr = (struct ip_hdr*)new_p->payload; fraghdr = (struct ip_hdr *)new_p->payload;
len = lwip_ntohs(IPH_LEN(fraghdr)); len = lwip_ntohs(IPH_LEN(fraghdr));
hlen = IPH_HL_BYTES(fraghdr); hlen = IPH_HL_BYTES(fraghdr);
if (hlen > len) { if (hlen > len) {
@ -366,7 +366,7 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
/* make sure the struct ip_reass_helper fits into the IP header */ /* make sure the struct ip_reass_helper fits into the IP header */
LWIP_ASSERT("sizeof(struct ip_reass_helper) <= IP_HLEN", LWIP_ASSERT("sizeof(struct ip_reass_helper) <= IP_HLEN",
sizeof(struct ip_reass_helper) <= IP_HLEN); sizeof(struct ip_reass_helper) <= IP_HLEN);
iprh = (struct ip_reass_helper*)new_p->payload; iprh = (struct ip_reass_helper *)new_p->payload;
iprh->next_pbuf = NULL; iprh->next_pbuf = NULL;
iprh->start = offset; iprh->start = offset;
iprh->end = (u16_t)(offset + len); iprh->end = (u16_t)(offset + len);
@ -378,7 +378,7 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
/* Iterate through until we either get to the end of the list (append), /* Iterate through until we either get to the end of the list (append),
* or we find one with a larger offset (insert). */ * or we find one with a larger offset (insert). */
for (q = ipr->p; q != NULL;) { for (q = ipr->p; q != NULL;) {
iprh_tmp = (struct ip_reass_helper*)q->payload; iprh_tmp = (struct ip_reass_helper *)q->payload;
if (iprh->start < iprh_tmp->start) { if (iprh->start < iprh_tmp->start) {
/* the new pbuf should be inserted before this */ /* the new pbuf should be inserted before this */
iprh->next_pbuf = q; iprh->next_pbuf = q;
@ -444,7 +444,7 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
} else { } else {
#if IP_REASS_CHECK_OVERLAP #if IP_REASS_CHECK_OVERLAP
LWIP_ASSERT("no previous fragment, this must be the first fragment!", LWIP_ASSERT("no previous fragment, this must be the first fragment!",
ipr->p == NULL); ipr->p == NULL);
#endif /* IP_REASS_CHECK_OVERLAP */ #endif /* IP_REASS_CHECK_OVERLAP */
/* this is the first fragment we ever received for this ip datagram */ /* this is the first fragment we ever received for this ip datagram */
ipr->p = new_p; ipr->p = new_p;
@ -458,14 +458,14 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
if (valid) { if (valid) {
/* then check if the rest of the fragments is here */ /* then check if the rest of the fragments is here */
/* Check if the queue starts with the first datagram */ /* Check if the queue starts with the first datagram */
if ((ipr->p == NULL) || (((struct ip_reass_helper*)ipr->p->payload)->start != 0)) { if ((ipr->p == NULL) || (((struct ip_reass_helper *)ipr->p->payload)->start != 0)) {
valid = 0; valid = 0;
} else { } else {
/* and check that there are no holes after this datagram */ /* and check that there are no holes after this datagram */
iprh_prev = iprh; iprh_prev = iprh;
q = iprh->next_pbuf; q = iprh->next_pbuf;
while (q != NULL) { while (q != NULL) {
iprh = (struct ip_reass_helper*)q->payload; iprh = (struct ip_reass_helper *)q->payload;
if (iprh_prev->end != iprh->start) { if (iprh_prev->end != iprh->start) {
valid = 0; valid = 0;
break; break;
@ -478,9 +478,9 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
if (valid) { if (valid) {
LWIP_ASSERT("sanity check", ipr->p != NULL); LWIP_ASSERT("sanity check", ipr->p != NULL);
LWIP_ASSERT("sanity check", LWIP_ASSERT("sanity check",
((struct ip_reass_helper*)ipr->p->payload) != iprh); ((struct ip_reass_helper *)ipr->p->payload) != iprh);
LWIP_ASSERT("validate_datagram:next_pbuf!=NULL", LWIP_ASSERT("validate_datagram:next_pbuf!=NULL",
iprh->next_pbuf == NULL); iprh->next_pbuf == NULL);
} }
} }
} }
@ -522,10 +522,10 @@ ip4_reass(struct pbuf *p)
IPFRAG_STATS_INC(ip_frag.recv); IPFRAG_STATS_INC(ip_frag.recv);
MIB2_STATS_INC(mib2.ipreasmreqds); MIB2_STATS_INC(mib2.ipreasmreqds);
fraghdr = (struct ip_hdr*)p->payload; fraghdr = (struct ip_hdr *)p->payload;
if ((IPH_HL(fraghdr) * 4) != IP_HLEN) { if ((IPH_HL(fraghdr) * 4) != IP_HLEN) {
LWIP_DEBUGF(IP_REASS_DEBUG,("ip4_reass: IP options currently not supported!\n")); LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: IP options currently not supported!\n"));
IPFRAG_STATS_INC(ip_frag.err); IPFRAG_STATS_INC(ip_frag.err);
goto nullreturn; goto nullreturn;
} }
@ -548,8 +548,8 @@ ip4_reass(struct pbuf *p)
#endif /* IP_REASS_FREE_OLDEST */ #endif /* IP_REASS_FREE_OLDEST */
{ {
/* No datagram could be freed and still too many pbufs enqueued */ /* No datagram could be freed and still too many pbufs enqueued */
LWIP_DEBUGF(IP_REASS_DEBUG,("ip4_reass: Overflow condition: pbufct=%d, clen=%d, MAX=%d\n", LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: Overflow condition: pbufct=%d, clen=%d, MAX=%d\n",
ip_reass_pbufcount, clen, IP_REASS_MAX_PBUFS)); ip_reass_pbufcount, clen, IP_REASS_MAX_PBUFS));
IPFRAG_STATS_INC(ip_frag.memerr); IPFRAG_STATS_INC(ip_frag.memerr);
/* @todo: send ICMP time exceeded here? */ /* @todo: send ICMP time exceeded here? */
/* drop this pbuf */ /* drop this pbuf */
@ -565,14 +565,14 @@ ip4_reass(struct pbuf *p)
fragment into the buffer. */ fragment into the buffer. */
if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) { if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) {
LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n", LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n",
lwip_ntohs(IPH_ID(fraghdr)))); lwip_ntohs(IPH_ID(fraghdr))));
IPFRAG_STATS_INC(ip_frag.cachehit); IPFRAG_STATS_INC(ip_frag.cachehit);
break; break;
} }
} }
if (ipr == NULL) { if (ipr == NULL) {
/* Enqueue a new datagram into the datagram queue */ /* Enqueue a new datagram into the datagram queue */
ipr = ip_reass_enqueue_new_datagram(fraghdr, clen); ipr = ip_reass_enqueue_new_datagram(fraghdr, clen);
/* Bail if unable to enqueue */ /* Bail if unable to enqueue */
if (ipr == NULL) { if (ipr == NULL) {
@ -580,7 +580,7 @@ ip4_reass(struct pbuf *p)
} }
} else { } else {
if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) &&
((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) { ((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) {
/* ipr->iphdr is not the header from the first fragment, but fraghdr is /* ipr->iphdr is not the header from the first fragment, but fraghdr is
* -> copy fraghdr into ipr->iphdr since we want to have the header * -> copy fraghdr into ipr->iphdr since we want to have the header
* of the first fragment (for ICMP time exceeded and later, for copying * of the first fragment (for ICMP time exceeded and later, for copying
@ -618,8 +618,8 @@ ip4_reass(struct pbuf *p)
ipr->datagram_len = datagram_len; ipr->datagram_len = datagram_len;
ipr->flags |= IP_REASS_FLAG_LASTFRAG; ipr->flags |= IP_REASS_FLAG_LASTFRAG;
LWIP_DEBUGF(IP_REASS_DEBUG, LWIP_DEBUGF(IP_REASS_DEBUG,
("ip4_reass: last fragment seen, total len %"S16_F"\n", ("ip4_reass: last fragment seen, total len %"S16_F"\n",
ipr->datagram_len)); ipr->datagram_len));
} }
if (valid == IP_REASS_VALIDATE_TELEGRAM_FINISHED) { if (valid == IP_REASS_VALIDATE_TELEGRAM_FINISHED) {
@ -629,10 +629,10 @@ ip4_reass(struct pbuf *p)
u16_t datagram_len = (u16_t)(ipr->datagram_len + IP_HLEN); u16_t datagram_len = (u16_t)(ipr->datagram_len + IP_HLEN);
/* save the second pbuf before copying the header over the pointer */ /* save the second pbuf before copying the header over the pointer */
r = ((struct ip_reass_helper*)ipr->p->payload)->next_pbuf; r = ((struct ip_reass_helper *)ipr->p->payload)->next_pbuf;
/* copy the original ip header back to the first pbuf */ /* copy the original ip header back to the first pbuf */
fraghdr = (struct ip_hdr*)(ipr->p->payload); fraghdr = (struct ip_hdr *)(ipr->p->payload);
SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN); SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN);
IPH_LEN_SET(fraghdr, lwip_htons(datagram_len)); IPH_LEN_SET(fraghdr, lwip_htons(datagram_len));
IPH_OFFSET_SET(fraghdr, 0); IPH_OFFSET_SET(fraghdr, 0);
@ -648,7 +648,7 @@ ip4_reass(struct pbuf *p)
/* chain together the pbufs contained within the reass_data list. */ /* chain together the pbufs contained within the reass_data list. */
while (r != NULL) { while (r != NULL) {
iprh = (struct ip_reass_helper*)r->payload; iprh = (struct ip_reass_helper *)r->payload;
/* hide the ip header for every succeeding fragment */ /* hide the ip header for every succeeding fragment */
pbuf_remove_header(r, IP_HLEN); pbuf_remove_header(r, IP_HLEN);
@ -681,11 +681,11 @@ ip4_reass(struct pbuf *p)
return p; return p;
} }
/* the datagram is not (yet?) reassembled completely */ /* the datagram is not (yet?) reassembled completely */
LWIP_DEBUGF(IP_REASS_DEBUG,("ip_reass_pbufcount: %d out\n", ip_reass_pbufcount)); LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_pbufcount: %d out\n", ip_reass_pbufcount));
return NULL; return NULL;
nullreturn: nullreturn:
LWIP_DEBUGF(IP_REASS_DEBUG,("ip4_reass: nullreturn\n")); LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: nullreturn\n"));
IPFRAG_STATS_INC(ip_frag.drop); IPFRAG_STATS_INC(ip_frag.drop);
pbuf_free(p); pbuf_free(p);
return NULL; return NULL;
@ -695,15 +695,15 @@ nullreturn:
#if IP_FRAG #if IP_FRAG
#if !LWIP_NETIF_TX_SINGLE_PBUF #if !LWIP_NETIF_TX_SINGLE_PBUF
/** Allocate a new struct pbuf_custom_ref */ /** Allocate a new struct pbuf_custom_ref */
static struct pbuf_custom_ref* static struct pbuf_custom_ref *
ip_frag_alloc_pbuf_custom_ref(void) ip_frag_alloc_pbuf_custom_ref(void)
{ {
return (struct pbuf_custom_ref*)memp_malloc(MEMP_FRAG_PBUF); return (struct pbuf_custom_ref *)memp_malloc(MEMP_FRAG_PBUF);
} }
/** Free a struct pbuf_custom_ref */ /** Free a struct pbuf_custom_ref */
static void static void
ip_frag_free_pbuf_custom_ref(struct pbuf_custom_ref* p) ip_frag_free_pbuf_custom_ref(struct pbuf_custom_ref *p)
{ {
LWIP_ASSERT("p != NULL", p != NULL); LWIP_ASSERT("p != NULL", p != NULL);
memp_free(MEMP_FRAG_PBUF, p); memp_free(MEMP_FRAG_PBUF, p);
@ -714,9 +714,9 @@ ip_frag_free_pbuf_custom_ref(struct pbuf_custom_ref* p)
static void static void
ipfrag_free_pbuf_custom(struct pbuf *p) ipfrag_free_pbuf_custom(struct pbuf *p)
{ {
struct pbuf_custom_ref *pcr = (struct pbuf_custom_ref*)p; struct pbuf_custom_ref *pcr = (struct pbuf_custom_ref *)p;
LWIP_ASSERT("pcr != NULL", pcr != NULL); LWIP_ASSERT("pcr != NULL", pcr != NULL);
LWIP_ASSERT("pcr == p", (void*)pcr == (void*)p); LWIP_ASSERT("pcr == p", (void *)pcr == (void *)p);
if (pcr->original != NULL) { if (pcr->original != NULL) {
pbuf_free(pcr->original); pbuf_free(pcr->original);
} }
@ -776,7 +776,7 @@ ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest)
goto memerr; goto memerr;
} }
LWIP_ASSERT("this needs a pbuf in one piece!", LWIP_ASSERT("this needs a pbuf in one piece!",
(rambuf->len == rambuf->tot_len) && (rambuf->next == NULL)); (rambuf->len == rambuf->tot_len) && (rambuf->next == NULL));
poff += pbuf_copy_partial(p, rambuf->payload, fragsize, poff); poff += pbuf_copy_partial(p, rambuf->payload, fragsize, poff);
/* make room for the IP header */ /* make room for the IP header */
if (pbuf_add_header(rambuf, IP_HLEN)) { if (pbuf_add_header(rambuf, IP_HLEN)) {
@ -785,7 +785,7 @@ ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest)
} }
/* fill in the IP header */ /* fill in the IP header */
SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN); SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN);
iphdr = (struct ip_hdr*)rambuf->payload; iphdr = (struct ip_hdr *)rambuf->payload;
#else /* LWIP_NETIF_TX_SINGLE_PBUF */ #else /* LWIP_NETIF_TX_SINGLE_PBUF */
/* When not using a static buffer, create a chain of pbufs. /* When not using a static buffer, create a chain of pbufs.
* The first will be a PBUF_RAM holding the link and IP header. * The first will be a PBUF_RAM holding the link and IP header.
@ -820,7 +820,7 @@ ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest)
} }
/* Mirror this pbuf, although we might not need all of it. */ /* Mirror this pbuf, although we might not need all of it. */
newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc, newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc,
(u8_t*)p->payload + poff, newpbuflen); (u8_t *)p->payload + poff, newpbuflen);
if (newpbuf == NULL) { if (newpbuf == NULL) {
ip_frag_free_pbuf_custom_ref(pcr); ip_frag_free_pbuf_custom_ref(pcr);
pbuf_free(rambuf); pbuf_free(rambuf);