Lines Matching defs:dhcp
53 * In lwip/dhcp.h
79 #include "lwip/dhcp.h"
113 * This might be moved into the struct dhcp (not necessarily since
128 @todo: move this into struct dhcp? */
132 @todo: move this into struct dhcp? */
140 #define dhcp_option_given(dhcp, idx) (dhcp_rx_options_given[idx] != 0)
141 #define dhcp_got_option(dhcp, idx) (dhcp_rx_options_given[idx] = 1)
142 #define dhcp_clear_option(dhcp, idx) (dhcp_rx_options_given[idx] = 0)
143 #define dhcp_clear_all_options(dhcp) (memset(dhcp_rx_options_given, 0, sizeof(dhcp_rx_options_given)))
144 #define dhcp_get_option_value(dhcp, idx) (dhcp_rx_options_val[idx])
145 #define dhcp_set_option_value(dhcp, idx, val) (dhcp_rx_options_val[idx] = (val))
157 static void dhcp_set_state(struct dhcp *dhcp, u8_t new_state);
169 static err_t dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type);
171 static void dhcp_delete_msg(struct dhcp *dhcp);
173 static void dhcp_option(struct dhcp *dhcp, u8_t option_type, u8_t option_len);
175 static void dhcp_option_byte(struct dhcp *dhcp, u8_t value);
176 static void dhcp_option_short(struct dhcp *dhcp, u16_t value);
177 static void dhcp_option_long(struct dhcp *dhcp, u32_t value);
179 static void dhcp_option_hostname(struct dhcp *dhcp, struct netif *netif);
182 static void dhcp_option_trailer(struct dhcp *dhcp);
199 struct dhcp *dhcp = netif->dhcp;
209 dhcp_set_state(dhcp, DHCP_BACKING_OFF);
227 struct dhcp *dhcp = netif->dhcp;
232 dhcp_set_state(dhcp, DHCP_CHECKING);
235 result = etharp_query(netif, &dhcp->offered_ip_addr, NULL);
239 dhcp->tries++;
241 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
254 struct dhcp *dhcp = netif->dhcp;
258 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) {
259 ip4_addr_set_u32(&dhcp->server_ip_addr, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID)));
261 ip4_addr_get_u32(&dhcp->server_ip_addr)));
263 ip_addr_copy(dhcp->offered_ip_addr, dhcp->msg_in->yiaddr);
265 ip4_addr_get_u32(&dhcp->offered_ip_addr)));
285 struct dhcp *dhcp = netif->dhcp;
290 dhcp_set_state(dhcp, DHCP_REQUESTING);
293 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
295 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
296 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
299 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
300 dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
302 dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
303 dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->server_ip_addr)));
305 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, 4/*num options*/);
306 dhcp_option_byte(dhcp, DHCP_OPTION_SUBNET_MASK);
307 dhcp_option_byte(dhcp, DHCP_OPTION_ROUTER);
308 dhcp_option_byte(dhcp, DHCP_OPTION_BROADCAST);
309 dhcp_option_byte(dhcp, DHCP_OPTION_DNS_SERVER);
312 dhcp_option_hostname(dhcp, netif);
315 dhcp_option_trailer(dhcp);
317 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
320 udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
321 dhcp_delete_msg(dhcp);
326 dhcp->tries++;
327 msecs = (dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000;
328 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
344 if (netif->dhcp != NULL) {
346 if (netif->dhcp->t2_timeout-- == 1) {
351 } else if (netif->dhcp->t1_timeout-- == 1) {
375 if (netif->dhcp != NULL) {
377 if (netif->dhcp->request_timeout > 1) {
378 netif->dhcp->request_timeout--;
380 else if (netif->dhcp->request_timeout == 1) {
381 netif->dhcp->request_timeout--;
382 /* { netif->dhcp->request_timeout == 0 } */
404 struct dhcp *dhcp = netif->dhcp;
407 if ((dhcp->state == DHCP_BACKING_OFF) || (dhcp->state == DHCP_SELECTING)) {
411 } else if (dhcp->state == DHCP_REQUESTING) {
413 if (dhcp->tries <= 5) {
422 } else if (dhcp->state == DHCP_CHECKING) {
424 if (dhcp->tries <= 1) {
435 else if (dhcp->state == DHCP_RENEWING) {
441 } else if (dhcp->state == DHCP_REBINDING) {
443 if (dhcp->tries <= 8) {
450 } else if (dhcp->state == DHCP_REBOOTING) {
451 if (dhcp->tries < REBOOT_TRIES) {
467 struct dhcp *dhcp = netif->dhcp;
469 if ((dhcp->state == DHCP_REQUESTING) || (dhcp->state == DHCP_BOUND) ||
470 (dhcp->state == DHCP_RENEWING)) {
489 struct dhcp *dhcp = netif->dhcp;
491 if ((dhcp->state == DHCP_REQUESTING) || (dhcp->state == DHCP_BOUND) ||
492 (dhcp->state == DHCP_RENEWING)) {
510 struct dhcp *dhcp = netif->dhcp;
516 ip_addr_set_zero(&dhcp->offered_sn_mask);
517 ip_addr_set_zero(&dhcp->offered_gw_addr);
519 ip_addr_set_zero(&dhcp->offered_si_addr);
523 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_LEASE_TIME)) {
525 dhcp->offered_t0_lease = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_LEASE_TIME);
528 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T1)) {
530 dhcp->offered_t1_renew = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T1);
533 dhcp->offered_t1_renew = dhcp->offered_t0_lease / 2;
537 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T2)) {
539 dhcp->offered_t2_rebind = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T2);
542 dhcp->offered_t2_rebind = dhcp->offered_t0_lease;
546 ip_addr_copy(dhcp->offered_ip_addr, dhcp->msg_in->yiaddr);
551 ip_addr_copy(dhcp->offered_si_addr, dhcp->msg_in->siaddr);
555 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)) {
557 ip4_addr_set_u32(&dhcp->offered_sn_mask, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)));
558 dhcp->subnet_mask_given = 1;
560 dhcp->subnet_mask_given = 0;
564 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_ROUTER)) {
565 ip4_addr_set_u32(&dhcp->offered_gw_addr, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_ROUTER)));
571 while(dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n) && (n < DNS_MAX_SERVERS)) {
573 ip4_addr_set_u32(&dns_addr, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n)));
580 /** Set a statically allocated struct dhcp to work with.
583 * @param netif the netif for which to set the struct dhcp
584 * @param dhcp (uninitialised) dhcp struct allocated by the application
587 dhcp_set_struct(struct netif *netif, struct dhcp *dhcp)
590 LWIP_ASSERT("dhcp != NULL", dhcp != NULL);
591 LWIP_ASSERT("netif already has a struct dhcp set", netif->dhcp == NULL);
594 memset(dhcp, 0, sizeof(struct dhcp));
595 /* dhcp_set_state(&dhcp, DHCP_OFF); */
596 netif->dhcp = dhcp;
599 /** Removes a struct dhcp from a netif.
602 * struct dhcp since the memory is passed back to the heap.
604 * @param netif the netif from which to remove the struct dhcp
610 if (netif->dhcp != NULL) {
611 mem_free(netif->dhcp);
612 netif->dhcp = NULL;
631 struct dhcp *dhcp;
635 dhcp = netif->dhcp;
654 if (dhcp == NULL) {
656 dhcp = (struct dhcp *)mem_malloc(sizeof(struct dhcp));
657 if (dhcp == NULL) {
658 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not allocate dhcp\n"));
661 /* store this dhcp client in the netif */
662 netif->dhcp = dhcp;
663 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp"));
667 if (dhcp->pcb != NULL) {
668 udp_remove(dhcp->pcb);
670 LWIP_ASSERT("pbuf p_out wasn't freed", dhcp->p_out == NULL);
671 LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL );
675 memset(dhcp, 0, sizeof(struct dhcp));
676 /* dhcp_set_state(&dhcp, DHCP_OFF); */
678 dhcp->pcb = udp_new();
679 if (dhcp->pcb == NULL) {
683 ip_set_option(dhcp->pcb, SOF_BROADCAST);
685 udp_bind(dhcp->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT);
686 udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT);
688 udp_recv(dhcp->pcb, dhcp_recv, netif);
714 struct dhcp dhcp;
720 memset(&dhcp, 0, sizeof(struct dhcp));
721 dhcp_set_state(&dhcp, DHCP_INFORM);
723 if ((netif->dhcp != NULL) && (netif->dhcp->pcb != NULL)) {
725 pcb = netif->dhcp->pcb;
732 dhcp.pcb = pcb;
733 ip_set_option(dhcp.pcb, SOF_BROADCAST);
734 udp_bind(dhcp.pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT);
738 result = dhcp_create_msg(netif, &dhcp, DHCP_INFORM);
740 dhcp_option(&dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
741 dhcp_option_short(&dhcp, DHCP_MAX_MSG_LEN(netif));
743 dhcp_option_trailer(&dhcp);
745 pbuf_realloc(dhcp.p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp.options_out_len);
748 udp_sendto_if(pcb, dhcp.p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
749 dhcp_delete_msg(&dhcp);
754 if (dhcp.pcb != NULL) {
756 udp_remove(dhcp.pcb);
768 struct dhcp *dhcp = netif->dhcp;
769 if (!dhcp)
771 switch (dhcp->state) {
777 dhcp->tries = 0;
784 dhcp->tries = 0;
786 if(dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
788 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
808 if ((netif->dhcp != NULL) && (netif->dhcp->state == DHCP_CHECKING)) {
813 if (ip_addr_cmp(addr, &netif->dhcp->offered_ip_addr)) {
834 struct dhcp *dhcp = netif->dhcp;
838 dhcp_set_state(dhcp, DHCP_BACKING_OFF);
840 result = dhcp_create_msg(netif, dhcp, DHCP_DECLINE);
842 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
843 dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
845 dhcp_option_trailer(dhcp);
847 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
850 udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
851 dhcp_delete_msg(dhcp);
857 dhcp->tries++;
859 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
874 struct dhcp *dhcp = netif->dhcp;
878 ip_addr_set_any(&dhcp->offered_ip_addr);
879 dhcp_set_state(dhcp, DHCP_SELECTING);
881 result = dhcp_create_msg(netif, dhcp, DHCP_DISCOVER);
885 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
886 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
888 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, 4/*num options*/);
889 dhcp_option_byte(dhcp, DHCP_OPTION_SUBNET_MASK);
890 dhcp_option_byte(dhcp, DHCP_OPTION_ROUTER);
891 dhcp_option_byte(dhcp, DHCP_OPTION_BROADCAST);
892 dhcp_option_byte(dhcp, DHCP_OPTION_DNS_SERVER);
894 dhcp_option_trailer(dhcp);
897 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
900 udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
902 dhcp_delete_msg(dhcp);
907 dhcp->tries++;
909 if(dhcp->tries >= LWIP_DHCP_AUTOIP_COOP_TRIES && dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_OFF) {
910 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_ON;
914 msecs = (dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000;
915 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
930 struct dhcp *dhcp;
933 dhcp = netif->dhcp;
934 LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;);
938 if (dhcp->offered_t1_renew != 0xffffffffUL) {
940 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t1 renewal timer %"U32_F" secs\n", dhcp->offered_t1_renew));
941 timeout = (dhcp->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
945 dhcp->t1_timeout = (u16_t)timeout;
946 if (dhcp->t1_timeout == 0) {
947 dhcp->t1_timeout = 1;
949 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew*1000));
952 if (dhcp->offered_t2_rebind != 0xffffffffUL) {
953 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t2 rebind timer %"U32_F" secs\n", dhcp->offered_t2_rebind));
954 timeout = (dhcp->offered_t2_rebind + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
958 dhcp->t2_timeout = (u16_t)timeout;
959 if (dhcp->t2_timeout == 0) {
960 dhcp->t2_timeout = 1;
962 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind*1000));
966 if ((dhcp->t1_timeout >= dhcp->t2_timeout) && (dhcp->t2_timeout > 0)) {
967 dhcp->t1_timeout = 0;
970 if (dhcp->subnet_mask_given) {
972 ip_addr_copy(sn_mask, dhcp->offered_sn_mask);
975 u8_t first_octet = ip4_addr1(&dhcp->offered_ip_addr);
985 ip_addr_copy(gw_addr, dhcp->offered_gw_addr);
989 ip_addr_get_network(&gw_addr, &dhcp->offered_ip_addr, &sn_mask);
995 if(dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
997 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
1002 ip4_addr_get_u32(&dhcp->offered_ip_addr)));
1003 netif_set_ipaddr(netif, &dhcp->offered_ip_addr);
1013 dhcp_set_state(dhcp, DHCP_BOUND);
1024 struct dhcp *dhcp = netif->dhcp;
1028 dhcp_set_state(dhcp, DHCP_RENEWING);
1031 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
1033 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
1034 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
1037 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
1038 dhcp_option_long(dhcp, ntohl(dhcp->offered_ip_addr.addr));
1042 dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
1043 dhcp_option_long(dhcp, ntohl(dhcp->server_ip_addr.addr));
1047 dhcp_option_hostname(dhcp, netif);
1051 dhcp_option_trailer(dhcp);
1053 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1055 udp_sendto_if(dhcp->pcb, dhcp->p_out, &dhcp->server_ip_addr, DHCP_SERVER_PORT, netif);
1056 dhcp_delete_msg(dhcp);
1062 dhcp->tries++;
1064 msecs = dhcp->tries < 10 ? dhcp->tries * 2000 : 20 * 1000;
1065 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1078 struct dhcp *dhcp = netif->dhcp;
1082 dhcp_set_state(dhcp, DHCP_REBINDING);
1085 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
1087 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
1088 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
1091 dhcp_option_hostname(dhcp, netif);
1095 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
1096 dhcp_option_long(dhcp, ntohl(dhcp->offered_ip_addr.addr));
1098 dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
1099 dhcp_option_long(dhcp, ntohl(dhcp->server_ip_addr.addr));
1102 dhcp_option_trailer(dhcp);
1104 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1107 udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
1108 dhcp_delete_msg(dhcp);
1113 dhcp->tries++;
1114 msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000;
1115 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1128 struct dhcp *dhcp = netif->dhcp;
1132 dhcp_set_state(dhcp, DHCP_REBOOTING);
1135 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
1137 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
1138 dhcp_option_short(dhcp, 576);
1140 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
1141 dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
1143 dhcp_option_trailer(dhcp);
1145 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1148 udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
1149 dhcp_delete_msg(dhcp);
1154 dhcp->tries++;
1155 msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000;
1156 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1170 struct dhcp *dhcp = netif->dhcp;
1176 dhcp_set_state(dhcp, DHCP_OFF);
1178 ip_addr_set_zero(&dhcp->server_ip_addr);
1179 ip_addr_set_zero(&dhcp->offered_ip_addr);
1180 ip_addr_set_zero(&dhcp->offered_sn_mask);
1181 ip_addr_set_zero(&dhcp->offered_gw_addr);
1183 ip_addr_set_zero(&dhcp->offered_si_addr);
1185 dhcp->offered_t0_lease = dhcp->offered_t1_renew = dhcp->offered_t2_rebind = 0;
1188 result = dhcp_create_msg(netif, dhcp, DHCP_RELEASE);
1190 dhcp_option_trailer(dhcp);
1192 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1194 udp_sendto_if(dhcp->pcb, dhcp->p_out, &dhcp->server_ip_addr, DHCP_SERVER_PORT, netif);
1195 dhcp_delete_msg(dhcp);
1200 dhcp->tries++;
1201 msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000;
1202 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1222 struct dhcp *dhcp;
1224 dhcp = netif->dhcp;
1230 if (dhcp != NULL) {
1232 if(dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
1234 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
1238 if (dhcp->pcb != NULL) {
1239 udp_remove(dhcp->pcb);
1240 dhcp->pcb = NULL;
1242 LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL);
1243 dhcp_set_state(dhcp, DHCP_OFF);
1253 dhcp_set_state(struct dhcp *dhcp, u8_t new_state)
1255 if (new_state != dhcp->state) {
1256 dhcp->state = new_state;
1257 dhcp->tries = 0;
1258 dhcp->request_timeout = 0;
1268 dhcp_option(struct dhcp *dhcp, u8_t option_type, u8_t option_len)
1270 LWIP_ASSERT("dhcp_option: dhcp->options_out_len + 2 + option_len <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 2U + option_len <= DHCP_OPTIONS_LEN);
1271 dhcp->msg_out->options[dhcp->options_out_len++] = option_type;
1272 dhcp->msg_out->options[dhcp->options_out_len++] = option_len;
1279 dhcp_option_byte(struct dhcp *dhcp, u8_t value)
1281 LWIP_ASSERT("dhcp_option_byte: dhcp->options_out_len < DHCP_OPTIONS_LEN", dhcp->options_out_len < DHCP_OPTIONS_LEN);
1282 dhcp->msg_out->options[dhcp->options_out_len++] = value;
1286 dhcp_option_short(struct dhcp *dhcp, u16_t value)
1288 LWIP_ASSERT("dhcp_option_short: dhcp->options_out_len + 2 <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 2U <= DHCP_OPTIONS_LEN);
1289 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0xff00U) >> 8);
1290 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t) (value & 0x00ffU);
1294 dhcp_option_long(struct dhcp *dhcp, u32_t value)
1296 LWIP_ASSERT("dhcp_option_long: dhcp->options_out_len + 4 <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 4U <= DHCP_OPTIONS_LEN);
1297 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0xff000000UL) >> 24);
1298 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x00ff0000UL) >> 16);
1299 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x0000ff00UL) >> 8);
1300 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x000000ffUL));
1305 dhcp_option_hostname(struct dhcp *dhcp, struct netif *netif)
1314 size_t available = DHCP_OPTIONS_LEN - dhcp->options_out_len - 3;
1317 dhcp_option(dhcp, DHCP_OPTION_HOSTNAME, len);
1319 dhcp_option_byte(dhcp, *p++);
1337 dhcp_parse_reply(struct dhcp *dhcp, struct pbuf *p)
1349 dhcp_clear_all_options(dhcp);
1354 dhcp->msg_in = (struct dhcp_msg *)p->payload;
1357 dhcp->boot_file_name[0] = 0;
1454 if (!dhcp_option_given(dhcp, decode_idx)) {
1460 dhcp_got_option(dhcp, decode_idx);
1461 dhcp_set_option_value(dhcp, decode_idx, htonl(value));
1472 dhcp_got_option(dhcp, decode_idx);
1473 dhcp_set_option_value(dhcp, decode_idx, value);
1490 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_OVERLOAD)) {
1491 u32_t overload = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_OVERLOAD);
1492 dhcp_clear_option(dhcp, DHCP_OPTION_IDX_OVERLOAD);
1509 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) &&
1510 (dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) == DHCP_ACK))
1512 pbuf_copy_partial(p, dhcp->boot_file_name, DHCP_FILE_LEN-1, DHCP_FILE_OFS);
1514 dhcp->boot_file_name[DHCP_FILE_LEN-1] = 0;
1540 struct dhcp *dhcp = netif->dhcp;
1553 LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL);
1574 if (ntohl(reply_msg->xid) != dhcp->xid) {
1576 ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n",ntohl(reply_msg->xid),dhcp->xid));
1580 if (dhcp_parse_reply(dhcp, p) != ERR_OK) {
1588 if (!dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE)) {
1594 msg_type = (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE);
1599 if (dhcp->state == DHCP_REQUESTING) {
1610 else if ((dhcp->state == DHCP_REBOOTING) || (dhcp->state == DHCP_REBINDING) || (dhcp->state == DHCP_RENEWING)) {
1616 ((dhcp->state == DHCP_REBOOTING) || (dhcp->state == DHCP_REQUESTING) ||
1617 (dhcp->state == DHCP_REBINDING) || (dhcp->state == DHCP_RENEWING ))) {
1622 else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_SELECTING)) {
1624 dhcp->request_timeout = 0;
1629 dhcp->msg_in = NULL;
1637 * @param dhcp dhcp control struct
1641 dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type)
1661 LWIP_ERROR("dhcp_create_msg: dhcp != NULL", (dhcp != NULL), return ERR_VAL;);
1662 LWIP_ASSERT("dhcp_create_msg: dhcp->p_out == NULL", dhcp->p_out == NULL);
1663 LWIP_ASSERT("dhcp_create_msg: dhcp->msg_out == NULL", dhcp->msg_out == NULL);
1664 dhcp->p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM);
1665 if (dhcp->p_out == NULL) {
1671 (dhcp->p_out->len >= sizeof(struct dhcp_msg)));
1674 if (dhcp->tries == 0) {
1681 dhcp->xid = xid;
1685 dhcp->msg_out = (struct dhcp_msg *)dhcp->p_out->payload;
1687 dhcp->msg_out->op = DHCP_BOOTREQUEST;
1689 dhcp->msg_out->htype = DHCP_HTYPE_ETH;
1690 dhcp->msg_out->hlen = netif->hwaddr_len;
1691 dhcp->msg_out->hops = 0;
1692 dhcp->msg_out->xid = htonl(dhcp->xid);
1693 dhcp->msg_out->secs = 0;
1696 dhcp->msg_out->flags = 0;
1697 ip_addr_set_zero(&dhcp->msg_out->ciaddr);
1701 ((dhcp->state==DHCP_RENEWING) || dhcp->state==DHCP_REBINDING))) {
1702 ip_addr_copy(dhcp->msg_out->ciaddr, netif->ip_addr);
1704 ip_addr_set_zero(&dhcp->msg_out->yiaddr);
1705 ip_addr_set_zero(&dhcp->msg_out->siaddr);
1706 ip_addr_set_zero(&dhcp->msg_out->giaddr);
1709 dhcp->msg_out->chaddr[i] = (i < netif->hwaddr_len) ? netif->hwaddr[i] : 0/* pad byte*/;
1712 dhcp->msg_out->sname[i] = 0;
1715 dhcp->msg_out->file[i] = 0;
1717 dhcp->msg_out->cookie = PP_HTONL(DHCP_MAGIC_COOKIE);
1718 dhcp->options_out_len = 0;
1721 dhcp->msg_out->options[i] = (u8_t)i; /* for debugging only, no matter if truncated */
1724 dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN);
1725 dhcp_option_byte(dhcp, message_type);
1732 * @param dhcp the dhcp struct to free the request from
1735 dhcp_delete_msg(struct dhcp *dhcp)
1737 LWIP_ERROR("dhcp_delete_msg: dhcp != NULL", (dhcp != NULL), return;);
1738 LWIP_ASSERT("dhcp_delete_msg: dhcp->p_out != NULL", dhcp->p_out != NULL);
1739 LWIP_ASSERT("dhcp_delete_msg: dhcp->msg_out != NULL", dhcp->msg_out != NULL);
1740 if (dhcp->p_out != NULL) {
1741 pbuf_free(dhcp->p_out);
1743 dhcp->p_out = NULL;
1744 dhcp->msg_out = NULL;
1753 * @param dhcp DHCP state structure
1756 dhcp_option_trailer(struct dhcp *dhcp)
1758 LWIP_ERROR("dhcp_option_trailer: dhcp != NULL", (dhcp != NULL), return;);
1759 LWIP_ASSERT("dhcp_option_trailer: dhcp->msg_out != NULL\n", dhcp->msg_out != NULL);
1760 LWIP_ASSERT("dhcp_option_trailer: dhcp->options_out_len < DHCP_OPTIONS_LEN\n", dhcp->options_out_len < DHCP_OPTIONS_LEN);
1761 dhcp->msg_out->options[dhcp->options_out_len++] = DHCP_OPTION_END;
1763 while (((dhcp->options_out_len < DHCP_MIN_OPTIONS_LEN) || (dhcp->options_out_len & 3)) &&
1764 (dhcp->options_out_len < DHCP_OPTIONS_LEN)) {
1766 dhcp->msg_out->options[dhcp->options_out_len++] = 0;