From 050d233e10266088cda8575c877d86834d463045 Mon Sep 17 00:00:00 2001 From: goldsimon Date: Tue, 19 May 2015 10:32:14 +0200 Subject: [PATCH] changed dhcp state name defines to include "STATE_" to prevent confusion with message types (e.g. INFORMING vs. INFORM) --- src/core/dhcp.c | 87 +++++++++++++++++++++-------------------- src/include/lwip/dhcp.h | 28 ++++++------- 2 files changed, 58 insertions(+), 57 deletions(-) diff --git a/src/core/dhcp.c b/src/core/dhcp.c index aa769791..e9275264 100644 --- a/src/core/dhcp.c +++ b/src/core/dhcp.c @@ -217,7 +217,7 @@ dhcp_handle_nak(struct netif *netif) /* remove IP address from interface (must no longer be used, as per RFC2131) */ netif_set_addr(netif, IP4_ADDR_ANY, IP4_ADDR_ANY, IP4_ADDR_ANY); /* Change to a defined state */ - dhcp_set_state(dhcp, DHCP_BACKING_OFF); + dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); /* We can immediately restart discovery */ dhcp_discover(netif); } @@ -240,7 +240,7 @@ dhcp_check(struct netif *netif) u16_t msecs; 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])); - dhcp_set_state(dhcp, DHCP_CHECKING); + dhcp_set_state(dhcp, DHCP_STATE_CHECKING); /* create an ARP query for the offered IP address, expecting that no host responds, as the IP address should not be in use. */ result = etharp_query(netif, &dhcp->offered_ip_addr, NULL); @@ -301,7 +301,7 @@ dhcp_select(struct netif *netif) u8_t i; 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_REQUESTING); + dhcp_set_state(dhcp, DHCP_STATE_REQUESTING); /* create and initialize the DHCP message header */ result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST); @@ -425,11 +425,11 @@ dhcp_timeout(struct netif *netif) struct dhcp *dhcp = netif->dhcp; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout()\n")); /* back-off period has passed, or server selection timed out */ - if ((dhcp->state == DHCP_BACKING_OFF) || (dhcp->state == DHCP_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")); dhcp_discover(netif); /* receiving the requested lease timed out */ - } else if (dhcp->state == DHCP_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")); if (dhcp->tries <= 5) { dhcp_select(netif); @@ -440,7 +440,7 @@ dhcp_timeout(struct netif *netif) } #if DHCP_DOES_ARP_CHECK /* received no ARP reply for the offered address (which is good) */ - } else if (dhcp->state == DHCP_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")); if (dhcp->tries <= 1) { dhcp_check(netif); @@ -451,7 +451,7 @@ dhcp_timeout(struct netif *netif) dhcp_bind(netif); } #endif /* DHCP_DOES_ARP_CHECK */ - } else if (dhcp->state == DHCP_REBOOTING) { + } else if (dhcp->state == DHCP_STATE_REBOOTING) { if (dhcp->tries < REBOOT_TRIES) { dhcp_reboot(netif); } else { @@ -470,14 +470,14 @@ dhcp_t1_timeout(struct netif *netif) { struct dhcp *dhcp = netif->dhcp; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_t1_timeout()\n")); - if ((dhcp->state == DHCP_REQUESTING) || (dhcp->state == DHCP_BOUND) || - (dhcp->state == DHCP_RENEWING)) { + if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) || + (dhcp->state == DHCP_STATE_RENEWING)) { /* just retry to renew - note that the rebind timer (t2) will * eventually time-out if renew tries fail. */ LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t1_timeout(): must renew\n")); /* This slightly different to RFC2131: DHCPREQUEST will be sent from state - DHCP_RENEWING, not DHCP_BOUND */ + DHCP_STATE_RENEWING, not DHCP_STATE_BOUND */ dhcp_renew(netif); /* Calculate next timeout */ if (((netif->dhcp->t2_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) @@ -497,13 +497,13 @@ dhcp_t2_timeout(struct netif *netif) { struct dhcp *dhcp = netif->dhcp; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t2_timeout()\n")); - if ((dhcp->state == DHCP_REQUESTING) || (dhcp->state == DHCP_BOUND) || - (dhcp->state == DHCP_RENEWING) || (dhcp->state == DHCP_REBINDING)) { + if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) || + (dhcp->state == DHCP_STATE_RENEWING) || (dhcp->state == DHCP_STATE_REBINDING)) { /* just retry to rebind */ LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t2_timeout(): must rebind\n")); /* This slightly different to RFC2131: DHCPREQUEST will be sent from state - DHCP_REBINDING, not DHCP_BOUND */ + DHCP_STATE_REBINDING, not DHCP_STATE_BOUND */ dhcp_rebind(netif); /* Calculate next timeout */ if (((netif->dhcp->t0_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) @@ -615,7 +615,7 @@ dhcp_set_struct(struct netif *netif, struct dhcp *dhcp) /* clear data structure */ memset(dhcp, 0, sizeof(struct dhcp)); - /* dhcp_set_state(&dhcp, DHCP_OFF); */ + /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */ netif->dhcp = dhcp; } @@ -694,7 +694,7 @@ dhcp_start(struct netif *netif) /* clear data structure */ memset(dhcp, 0, sizeof(struct dhcp)); - /* dhcp_set_state(&dhcp, DHCP_OFF); */ + /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */ /* allocate UDP PCB */ dhcp->pcb = udp_new(); if (dhcp->pcb == NULL) { @@ -712,7 +712,7 @@ dhcp_start(struct netif *netif) #if LWIP_DHCP_CHECK_LINK_UP if (!netif_is_link_up(netif)) { /* set state INIT and wait for dhcp_network_changed() to call dhcp_discover() */ - dhcp_set_state(dhcp, DHCP_INIT); + dhcp_set_state(dhcp, DHCP_STATE_INIT); return ERR_OK; } #endif /* LWIP_DHCP_CHECK_LINK_UP */ @@ -746,7 +746,7 @@ dhcp_inform(struct netif *netif) LWIP_ERROR("netif != NULL", (netif != NULL), return;); memset(&dhcp, 0, sizeof(struct dhcp)); - dhcp_set_state(&dhcp, DHCP_INFORMING); + dhcp_set_state(&dhcp, DHCP_STATE_INFORMING); if ((netif->dhcp != NULL) && (netif->dhcp->pcb != NULL)) { /* re-use existing pcb */ @@ -797,14 +797,14 @@ dhcp_network_changed(struct netif *netif) if (!dhcp) return; switch (dhcp->state) { - case DHCP_REBINDING: - case DHCP_RENEWING: - case DHCP_BOUND: - case DHCP_REBOOTING: + case DHCP_STATE_REBINDING: + case DHCP_STATE_RENEWING: + case DHCP_STATE_BOUND: + case DHCP_STATE_REBOOTING: dhcp->tries = 0; dhcp_reboot(netif); break; - case DHCP_OFF: + case DHCP_STATE_OFF: /* stay off */ break; default: @@ -836,7 +836,7 @@ void dhcp_arp_reply(struct netif *netif, const ip4_addr_t *addr) LWIP_ERROR("netif != NULL", (netif != NULL), return;); LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_arp_reply()\n")); /* is a DHCP client doing an ARP check? */ - if ((netif->dhcp != NULL) && (netif->dhcp->state == DHCP_CHECKING)) { + if ((netif->dhcp != NULL) && (netif->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", ip4_addr_get_u32(addr))); /* did a host respond with the address we @@ -866,7 +866,7 @@ dhcp_decline(struct netif *netif) err_t result = ERR_OK; u16_t msecs; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline()\n")); - dhcp_set_state(dhcp, DHCP_BACKING_OFF); + dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); /* create and initialize the DHCP message header */ result = dhcp_create_msg(netif, dhcp, DHCP_DECLINE); if (result == ERR_OK) { @@ -910,7 +910,7 @@ dhcp_discover(struct netif *netif) u8_t i; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover()\n")); ip4_addr_set_any(&dhcp->offered_ip_addr); - dhcp_set_state(dhcp, DHCP_SELECTING); + dhcp_set_state(dhcp, DHCP_STATE_SELECTING); /* create and initialize the DHCP message header */ result = dhcp_create_msg(netif, dhcp, DHCP_DISCOVER); if (result == ERR_OK) { @@ -1057,7 +1057,7 @@ dhcp_bind(struct netif *netif) /* interface is used by routing now that an address is set */ /* netif is now bound to DHCP leased address */ - dhcp_set_state(dhcp, DHCP_BOUND); + dhcp_set_state(dhcp, DHCP_STATE_BOUND); } /** @@ -1072,7 +1072,7 @@ dhcp_renew(struct netif *netif) err_t result; u16_t msecs; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_renew()\n")); - dhcp_set_state(dhcp, DHCP_RENEWING); + dhcp_set_state(dhcp, DHCP_STATE_RENEWING); /* create and initialize the DHCP message header */ result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST); @@ -1118,7 +1118,7 @@ dhcp_rebind(struct netif *netif) err_t result; u16_t msecs; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind()\n")); - dhcp_set_state(dhcp, DHCP_REBINDING); + dhcp_set_state(dhcp, DHCP_STATE_REBINDING); /* create and initialize the DHCP message header */ result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST); @@ -1162,7 +1162,7 @@ dhcp_reboot(struct netif *netif) err_t result; u16_t msecs; LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot()\n")); - dhcp_set_state(dhcp, DHCP_REBOOTING); + dhcp_set_state(dhcp, DHCP_STATE_REBOOTING); /* create and initialize the DHCP message header */ result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST); @@ -1213,7 +1213,7 @@ dhcp_release(struct netif *netif) ip_addr_copy(server_ip_addr, dhcp->server_ip_addr); /* idle DHCP client */ - dhcp_set_state(dhcp, DHCP_OFF); + dhcp_set_state(dhcp, DHCP_STATE_OFF); /* clean old DHCP offer */ ip_addr_set_zero(&dhcp->server_ip_addr); ip4_addr_set_zero(&dhcp->offered_ip_addr); @@ -1236,7 +1236,7 @@ dhcp_release(struct netif *netif) udp_sendto_if(dhcp->pcb, dhcp->p_out, &server_ip_addr, DHCP_SERVER_PORT, netif); dhcp_delete_msg(dhcp); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_OFF\n")); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_STATE_OFF\n")); } else { LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_release: could not allocate DHCP request\n")); } @@ -1279,7 +1279,7 @@ dhcp_stop(struct netif *netif) dhcp->pcb = NULL; } LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL); - dhcp_set_state(dhcp, DHCP_OFF); + dhcp_set_state(dhcp, DHCP_STATE_OFF); } } @@ -1645,7 +1645,7 @@ dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, if (msg_type == DHCP_ACK) { LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_ACK received\n")); /* in requesting state? */ - if (dhcp->state == DHCP_REQUESTING) { + if (dhcp->state == DHCP_STATE_REQUESTING) { dhcp_handle_ack(netif); #if DHCP_DOES_ARP_CHECK /* check if the acknowledged lease address is already in use */ @@ -1656,21 +1656,22 @@ dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, #endif } /* already bound to the given lease address? */ - else if ((dhcp->state == DHCP_REBOOTING) || (dhcp->state == DHCP_REBINDING) || (dhcp->state == DHCP_RENEWING)) { + else if ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REBINDING) || + (dhcp->state == DHCP_STATE_RENEWING)) { dhcp_handle_ack(netif); dhcp_bind(netif); } } /* received a DHCP_NAK in appropriate state? */ else if ((msg_type == DHCP_NAK) && - ((dhcp->state == DHCP_REBOOTING) || (dhcp->state == DHCP_REQUESTING) || - (dhcp->state == DHCP_REBINDING) || (dhcp->state == DHCP_RENEWING ))) { + ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REQUESTING) || + (dhcp->state == DHCP_STATE_REBINDING) || (dhcp->state == DHCP_STATE_RENEWING ))) { LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_NAK received\n")); dhcp_handle_nak(netif); } - /* received a DHCP_OFFER in DHCP_SELECTING state? */ - else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_SELECTING)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_OFFER received in DHCP_SELECTING state\n")); + /* received a DHCP_OFFER in DHCP_STATE_SELECTING state? */ + else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_STATE_SELECTING)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_OFFER received in DHCP_STATE_SELECTING state\n")); dhcp->request_timeout = 0; /* remember offered lease */ dhcp_handle_offer(netif); @@ -1750,8 +1751,8 @@ dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type) ip4_addr_set_zero(&dhcp->msg_out->ciaddr); /* set ciaddr to netif->ip_addr based on message_type and state */ if ((message_type == DHCP_INFORM) || (message_type == DHCP_DECLINE) || (message_type == DHCP_RELEASE) || - ((message_type == DHCP_REQUEST) && /* DHCP_BOUND not used for sending! */ - ((dhcp->state==DHCP_RENEWING) || dhcp->state==DHCP_REBINDING))) { + ((message_type == DHCP_REQUEST) && /* DHCP_STATE_BOUND not used for sending! */ + ((dhcp->state== DHCP_STATE_RENEWING) || dhcp->state== DHCP_STATE_REBINDING))) { ip4_addr_copy(dhcp->msg_out->ciaddr, netif->ip_addr); } ip4_addr_set_zero(&dhcp->msg_out->yiaddr); @@ -1830,8 +1831,8 @@ u8_t dhcp_supplied_address(struct netif *netif) { if ((netif != NULL) && (netif->dhcp != NULL)) { - if ((netif->dhcp->state == DHCP_BOUND) || - (netif->dhcp->state == DHCP_RENEWING)) { + if ((netif->dhcp->state == DHCP_STATE_BOUND) || + (netif->dhcp->state == DHCP_STATE_RENEWING)) { return 1; } } diff --git a/src/include/lwip/dhcp.h b/src/include/lwip/dhcp.h index c9c0608b..da208ff2 100644 --- a/src/include/lwip/dhcp.h +++ b/src/include/lwip/dhcp.h @@ -157,23 +157,23 @@ void dhcp_fine_tmr(void); #define DHCP_COOKIE_OFS DHCP_MSG_LEN #define DHCP_OPTIONS_OFS (DHCP_MSG_LEN + 4) -#define DHCP_CLIENT_PORT 68 +#define DHCP_CLIENT_PORT 68 #define DHCP_SERVER_PORT 67 /** DHCP client states */ -#define DHCP_OFF 0 -#define DHCP_REQUESTING 1 -#define DHCP_INIT 2 -#define DHCP_REBOOTING 3 -#define DHCP_REBINDING 4 -#define DHCP_RENEWING 5 -#define DHCP_SELECTING 6 -#define DHCP_INFORMING 7 -#define DHCP_CHECKING 8 -#define DHCP_PERMANENT 9 -#define DHCP_BOUND 10 -/** not yet implemented #define DHCP_RELEASING 11 */ -#define DHCP_BACKING_OFF 12 +#define DHCP_STATE_OFF 0 +#define DHCP_STATE_REQUESTING 1 +#define DHCP_STATE_INIT 2 +#define DHCP_STATE_REBOOTING 3 +#define DHCP_STATE_REBINDING 4 +#define DHCP_STATE_RENEWING 5 +#define DHCP_STATE_SELECTING 6 +#define DHCP_STATE_INFORMING 7 +#define DHCP_STATE_CHECKING 8 +/** not yet implemented #define DHCP_STATE_PERMANENT 9 */ +#define DHCP_STATE_BOUND 10 +/** not yet implemented #define DHCP_STATE_RELEASING 11 */ +#define DHCP_STATE_BACKING_OFF 12 /** AUTOIP cooperation flags */ #define DHCP_AUTOIP_COOP_STATE_OFF 0