Lines Matching defs:dhcp
73 #include "lwip/dhcp.h"
77 #include "lwip/prot/dhcp.h"
118 * This might be moved into the struct dhcp (not necessarily since
142 @todo: move this into struct dhcp? */
146 @todo: move this into struct dhcp? */
166 #define dhcp_option_given(dhcp, idx) (dhcp_rx_options_given[idx] != 0)
167 #define dhcp_got_option(dhcp, idx) (dhcp_rx_options_given[idx] = 1)
168 #define dhcp_clear_option(dhcp, idx) (dhcp_rx_options_given[idx] = 0)
169 #define dhcp_clear_all_options(dhcp) (memset(dhcp_rx_options_given, 0, sizeof(dhcp_rx_options_given)))
170 #define dhcp_get_option_value(dhcp, idx) (dhcp_rx_options_val[idx])
171 #define dhcp_set_option_value(dhcp, idx, val) (dhcp_rx_options_val[idx] = (val))
185 static void dhcp_set_state(struct dhcp *dhcp, u8_t new_state);
197 static err_t dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type);
199 static void dhcp_delete_msg(struct dhcp *dhcp);
201 static void dhcp_option(struct dhcp *dhcp, u8_t option_type, u8_t option_len);
203 static void dhcp_option_byte(struct dhcp *dhcp, u8_t value);
204 static void dhcp_option_short(struct dhcp *dhcp, u16_t value);
205 static void dhcp_option_long(struct dhcp *dhcp, u32_t value);
207 static void dhcp_option_hostname(struct dhcp *dhcp, struct netif *netif);
210 static void dhcp_option_trailer(struct dhcp *dhcp);
267 struct dhcp *dhcp = netif_dhcp_data(netif);
273 dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF);
293 struct dhcp *dhcp = netif_dhcp_data(netif);
298 dhcp_set_state(dhcp, DHCP_STATE_CHECKING);
301 result = etharp_query(netif, &dhcp->offered_ip_addr, NULL);
305 if (dhcp->tries < 255) {
306 dhcp->tries++;
309 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
322 struct dhcp *dhcp = netif_dhcp_data(netif);
327 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) {
328 ip_addr_set_ip4_u32(&dhcp->server_ip_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID)));
330 ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr))));
332 ip4_addr_copy(dhcp->offered_ip_addr, dhcp->msg_in->yiaddr);
334 ip4_addr_get_u32(&dhcp->offered_ip_addr)));
354 struct dhcp *dhcp = netif_dhcp_data(netif);
360 dhcp_set_state(dhcp, DHCP_STATE_REQUESTING);
363 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
365 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
366 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
369 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
370 dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
372 dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
373 dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr))));
375 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
377 dhcp_option_byte(dhcp, dhcp_discover_request_options[i]);
381 dhcp_option_hostname(dhcp, netif);
384 dhcp_option_trailer(dhcp);
386 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
389 udp_sendto_if_src(dhcp_pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif, IP4_ADDR_ANY);
390 dhcp_delete_msg(dhcp);
395 if (dhcp->tries < 255) {
396 dhcp->tries++;
398 msecs = (dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000;
399 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
416 struct dhcp *dhcp = netif_dhcp_data(netif);
417 if ((dhcp != NULL) && (dhcp->state != DHCP_STATE_OFF)) {
419 if (dhcp->t0_timeout && (++dhcp->lease_used == dhcp->t0_timeout)) {
425 } else if (dhcp->t2_rebind_time && (dhcp->t2_rebind_time-- == 1)) {
430 } else if (dhcp->t1_renew_time && (dhcp->t1_renew_time-- == 1)) {
454 struct dhcp *dhcp = netif_dhcp_data(netif);
456 if (dhcp != NULL) {
458 if (dhcp->request_timeout > 1) {
459 dhcp->request_timeout--;
461 else if (dhcp->request_timeout == 1) {
462 dhcp->request_timeout--;
463 /* { netif->dhcp->request_timeout == 0 } */
485 struct dhcp *dhcp = netif_dhcp_data(netif);
489 if ((dhcp->state == DHCP_STATE_BACKING_OFF) || (dhcp->state == DHCP_STATE_SELECTING)) {
493 } else if (dhcp->state == DHCP_STATE_REQUESTING) {
495 if (dhcp->tries <= 5) {
504 } else if (dhcp->state == DHCP_STATE_CHECKING) {
506 if (dhcp->tries <= 1) {
515 } else if (dhcp->state == DHCP_STATE_REBOOTING) {
516 if (dhcp->tries < REBOOT_TRIES) {
532 struct dhcp *dhcp = netif_dhcp_data(netif);
535 if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) ||
536 (dhcp->state == DHCP_STATE_RENEWING)) {
545 if (((dhcp->t2_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS))
547 dhcp->t1_renew_time = ((dhcp->t2_timeout - dhcp->lease_used) / 2);
560 struct dhcp *dhcp = netif_dhcp_data(netif);
563 if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) ||
564 (dhcp->state == DHCP_STATE_RENEWING) || (dhcp->state == DHCP_STATE_REBINDING)) {
572 if (((dhcp->t0_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS))
574 dhcp->t2_rebind_time = ((dhcp->t0_timeout - dhcp->lease_used) / 2);
587 struct dhcp *dhcp = netif_dhcp_data(netif);
597 ip4_addr_set_zero(&dhcp->offered_sn_mask);
598 ip4_addr_set_zero(&dhcp->offered_gw_addr);
600 ip4_addr_set_zero(&dhcp->offered_si_addr);
604 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_LEASE_TIME)) {
606 dhcp->offered_t0_lease = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_LEASE_TIME);
609 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T1)) {
611 dhcp->offered_t1_renew = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T1);
614 dhcp->offered_t1_renew = dhcp->offered_t0_lease / 2;
618 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T2)) {
620 dhcp->offered_t2_rebind = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T2);
623 dhcp->offered_t2_rebind = (dhcp->offered_t0_lease * 7U) / 8U;
627 ip4_addr_copy(dhcp->offered_ip_addr, dhcp->msg_in->yiaddr);
632 ip4_addr_copy(dhcp->offered_si_addr, dhcp->msg_in->siaddr);
636 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)) {
638 ip4_addr_set_u32(&dhcp->offered_sn_mask, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)));
639 dhcp->subnet_mask_given = 1;
641 dhcp->subnet_mask_given = 0;
645 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_ROUTER)) {
646 ip4_addr_set_u32(&dhcp->offered_gw_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_ROUTER)));
651 for (n = 0; (n < LWIP_DHCP_MAX_NTP_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n); n++) {
652 ip4_addr_set_u32(&ntp_server_addrs[n], lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n)));
659 for (n = 0; (n < LWIP_DHCP_PROVIDE_DNS_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n); n++) {
661 ip_addr_set_ip4_u32(&dns_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n)));
669 * Set a statically allocated struct dhcp to work with.
672 * @param netif the netif for which to set the struct dhcp
673 * @param dhcp (uninitialised) dhcp struct allocated by the application
676 dhcp_set_struct(struct netif *netif, struct dhcp *dhcp)
679 LWIP_ASSERT("dhcp != NULL", dhcp != NULL);
680 LWIP_ASSERT("netif already has a struct dhcp set", netif_dhcp_data(netif) == NULL);
683 memset(dhcp, 0, sizeof(struct dhcp));
684 /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */
685 netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp);
690 * Removes a struct dhcp from a netif.
693 * struct dhcp since the memory is passed back to the heap.
695 * @param netif the netif from which to remove the struct dhcp
723 struct dhcp *dhcp;
728 dhcp = netif_dhcp_data(netif);
738 if (dhcp == NULL) {
740 dhcp = (struct dhcp *)mem_malloc(sizeof(struct dhcp));
741 if (dhcp == NULL) {
742 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not allocate dhcp\n"));
746 /* store this dhcp client in the netif */
747 netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp);
748 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp"));
752 LWIP_ASSERT("pbuf p_out wasn't freed", dhcp->p_out == NULL);
753 LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL );
755 if (dhcp->pcb_allocated != 0) {
758 /* dhcp is cleared below, no need to reset flag*/
762 memset(dhcp, 0, sizeof(struct dhcp));
763 /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */
770 dhcp->pcb_allocated = 1;
775 dhcp_set_state(dhcp, DHCP_STATE_INIT);
804 struct dhcp dhcp;
813 memset(&dhcp, 0, sizeof(struct dhcp));
814 dhcp_set_state(&dhcp, DHCP_STATE_INFORMING);
817 result = dhcp_create_msg(netif, &dhcp, DHCP_INFORM);
819 dhcp_option(&dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
820 dhcp_option_short(&dhcp, DHCP_MAX_MSG_LEN(netif));
822 dhcp_option_trailer(&dhcp);
824 pbuf_realloc(dhcp.p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp.options_out_len);
828 udp_sendto_if(dhcp_pcb, dhcp.p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
830 dhcp_delete_msg(&dhcp);
846 struct dhcp *dhcp = netif_dhcp_data(netif);
848 if (!dhcp)
850 switch (dhcp->state) {
855 dhcp->tries = 0;
866 if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
868 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
872 dhcp->tries = 0;
889 struct dhcp *dhcp;
892 dhcp = netif_dhcp_data(netif);
895 if ((dhcp != NULL) && (dhcp->state == DHCP_STATE_CHECKING)) {
900 if (ip4_addr_cmp(addr, &dhcp->offered_ip_addr)) {
921 struct dhcp *dhcp = netif_dhcp_data(netif);
925 dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF);
927 result = dhcp_create_msg(netif, dhcp, DHCP_DECLINE);
929 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
930 dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
932 dhcp_option_trailer(dhcp);
934 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
937 udp_sendto_if_src(dhcp_pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif, IP4_ADDR_ANY);
938 dhcp_delete_msg(dhcp);
944 if (dhcp->tries < 255) {
945 dhcp->tries++;
948 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
963 struct dhcp *dhcp = netif_dhcp_data(netif);
968 ip4_addr_set_any(&dhcp->offered_ip_addr);
969 dhcp_set_state(dhcp, DHCP_STATE_SELECTING);
971 result = dhcp_create_msg(netif, dhcp, DHCP_DISCOVER);
975 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
976 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
978 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
980 dhcp_option_byte(dhcp, dhcp_discover_request_options[i]);
982 dhcp_option_trailer(dhcp);
985 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
988 udp_sendto_if_src(dhcp_pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif, IP4_ADDR_ANY);
990 dhcp_delete_msg(dhcp);
995 if (dhcp->tries < 255) {
996 dhcp->tries++;
999 if (dhcp->tries >= LWIP_DHCP_AUTOIP_COOP_TRIES && dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_OFF) {
1000 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_ON;
1004 msecs = (dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000;
1005 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1020 struct dhcp *dhcp;
1023 dhcp = netif_dhcp_data(netif);
1024 LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;);
1028 dhcp->lease_used = 0;
1030 if (dhcp->offered_t0_lease != 0xffffffffUL) {
1032 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t0 renewal timer %"U32_F" secs\n", dhcp->offered_t0_lease));
1033 timeout = (dhcp->offered_t0_lease + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
1037 dhcp->t0_timeout = (u16_t)timeout;
1038 if (dhcp->t0_timeout == 0) {
1039 dhcp->t0_timeout = 1;
1041 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t0_lease*1000));
1045 if (dhcp->offered_t1_renew != 0xffffffffUL) {
1047 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t1 renewal timer %"U32_F" secs\n", dhcp->offered_t1_renew));
1048 timeout = (dhcp->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
1052 dhcp->t1_timeout = (u16_t)timeout;
1053 if (dhcp->t1_timeout == 0) {
1054 dhcp->t1_timeout = 1;
1056 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew*1000));
1057 dhcp->t1_renew_time = dhcp->t1_timeout;
1060 if (dhcp->offered_t2_rebind != 0xffffffffUL) {
1061 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t2 rebind timer %"U32_F" secs\n", dhcp->offered_t2_rebind));
1062 timeout = (dhcp->offered_t2_rebind + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
1066 dhcp->t2_timeout = (u16_t)timeout;
1067 if (dhcp->t2_timeout == 0) {
1068 dhcp->t2_timeout = 1;
1070 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind*1000));
1071 dhcp->t2_rebind_time = dhcp->t2_timeout;
1075 if ((dhcp->t1_timeout >= dhcp->t2_timeout) && (dhcp->t2_timeout > 0)) {
1076 dhcp->t1_timeout = 0;
1079 if (dhcp->subnet_mask_given) {
1081 ip4_addr_copy(sn_mask, dhcp->offered_sn_mask);
1084 u8_t first_octet = ip4_addr1(&dhcp->offered_ip_addr);
1094 ip4_addr_copy(gw_addr, dhcp->offered_gw_addr);
1098 ip4_addr_get_network(&gw_addr, &dhcp->offered_ip_addr, &sn_mask);
1104 if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
1106 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
1111 ip4_addr_get_u32(&dhcp->offered_ip_addr), ip4_addr_get_u32(&sn_mask), ip4_addr_get_u32(&gw_addr)));
1114 dhcp_set_state(dhcp, DHCP_STATE_BOUND);
1116 netif_set_addr(netif, &dhcp->offered_ip_addr, &sn_mask, &gw_addr);
1129 struct dhcp *dhcp = netif_dhcp_data(netif);
1134 dhcp_set_state(dhcp, DHCP_STATE_RENEWING);
1137 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
1139 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
1140 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
1142 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
1144 dhcp_option_byte(dhcp, dhcp_discover_request_options[i]);
1148 dhcp_option_hostname(dhcp, netif);
1152 dhcp_option_trailer(dhcp);
1154 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1156 udp_sendto_if(dhcp_pcb, dhcp->p_out, &dhcp->server_ip_addr, DHCP_SERVER_PORT, netif);
1157 dhcp_delete_msg(dhcp);
1163 if (dhcp->tries < 255) {
1164 dhcp->tries++;
1167 msecs = dhcp->tries < 10 ? dhcp->tries * 2000 : 20 * 1000;
1168 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1181 struct dhcp *dhcp = netif_dhcp_data(netif);
1186 dhcp_set_state(dhcp, DHCP_STATE_REBINDING);
1189 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
1191 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
1192 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif));
1194 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
1196 dhcp_option_byte(dhcp, dhcp_discover_request_options[i]);
1200 dhcp_option_hostname(dhcp, netif);
1203 dhcp_option_trailer(dhcp);
1205 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1208 udp_sendto_if(dhcp_pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
1209 dhcp_delete_msg(dhcp);
1214 if (dhcp->tries < 255) {
1215 dhcp->tries++;
1217 msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000;
1218 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1231 struct dhcp *dhcp = netif_dhcp_data(netif);
1236 dhcp_set_state(dhcp, DHCP_STATE_REBOOTING);
1239 result = dhcp_create_msg(netif, dhcp, DHCP_REQUEST);
1241 dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
1242 dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN_MIN_REQUIRED);
1244 dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
1245 dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
1247 dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
1249 dhcp_option_byte(dhcp, dhcp_discover_request_options[i]);
1252 dhcp_option_trailer(dhcp);
1254 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1257 udp_sendto_if(dhcp_pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif);
1258 dhcp_delete_msg(dhcp);
1263 if (dhcp->tries < 255) {
1264 dhcp->tries++;
1266 msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000;
1267 dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
1282 struct dhcp *dhcp = netif_dhcp_data(netif);
1288 if (dhcp == NULL) {
1291 ip_addr_copy(server_ip_addr, dhcp->server_ip_addr);
1296 dhcp_set_state(dhcp, DHCP_STATE_OFF);
1298 ip_addr_set_zero_ip4(&dhcp->server_ip_addr);
1299 ip4_addr_set_zero(&dhcp->offered_ip_addr);
1300 ip4_addr_set_zero(&dhcp->offered_sn_mask);
1301 ip4_addr_set_zero(&dhcp->offered_gw_addr);
1303 ip4_addr_set_zero(&dhcp->offered_si_addr);
1305 dhcp->offered_t0_lease = dhcp->offered_t1_renew = dhcp->offered_t2_rebind = 0;
1306 dhcp->t1_renew_time = dhcp->t2_rebind_time = dhcp->lease_used = dhcp->t0_timeout = 0;
1309 /* don't issue release message when address is not dhcp-assigned */
1314 result = dhcp_create_msg(netif, dhcp, DHCP_RELEASE);
1316 dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
1317 dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr))));
1319 dhcp_option_trailer(dhcp);
1321 pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len);
1323 udp_sendto_if(dhcp_pcb, dhcp->p_out, &server_ip_addr, DHCP_SERVER_PORT, netif);
1324 dhcp_delete_msg(dhcp);
1327 /* sending release failed, but that's not a problem since the correct behaviour of dhcp does not rely on release */
1345 struct dhcp *dhcp;
1347 dhcp = netif_dhcp_data(netif);
1351 if (dhcp != NULL) {
1353 if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) {
1355 dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF;
1359 LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL);
1360 dhcp_set_state(dhcp, DHCP_STATE_OFF);
1362 if (dhcp->pcb_allocated != 0) {
1364 dhcp->pcb_allocated = 0;
1375 dhcp_set_state(struct dhcp *dhcp, u8_t new_state)
1377 if (new_state != dhcp->state) {
1378 dhcp->state = new_state;
1379 dhcp->tries = 0;
1380 dhcp->request_timeout = 0;
1390 dhcp_option(struct dhcp *dhcp, u8_t option_type, u8_t option_len)
1392 LWIP_ASSERT("dhcp_option: dhcp->options_out_len + 2 + option_len <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 2U + option_len <= DHCP_OPTIONS_LEN);
1393 dhcp->msg_out->options[dhcp->options_out_len++] = option_type;
1394 dhcp->msg_out->options[dhcp->options_out_len++] = option_len;
1401 dhcp_option_byte(struct dhcp *dhcp, u8_t value)
1403 LWIP_ASSERT("dhcp_option_byte: dhcp->options_out_len < DHCP_OPTIONS_LEN", dhcp->options_out_len < DHCP_OPTIONS_LEN);
1404 dhcp->msg_out->options[dhcp->options_out_len++] = value;
1408 dhcp_option_short(struct dhcp *dhcp, u16_t value)
1410 LWIP_ASSERT("dhcp_option_short: dhcp->options_out_len + 2 <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 2U <= DHCP_OPTIONS_LEN);
1411 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0xff00U) >> 8);
1412 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t) (value & 0x00ffU);
1416 dhcp_option_long(struct dhcp *dhcp, u32_t value)
1418 LWIP_ASSERT("dhcp_option_long: dhcp->options_out_len + 4 <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 4U <= DHCP_OPTIONS_LEN);
1419 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0xff000000UL) >> 24);
1420 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x00ff0000UL) >> 16);
1421 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x0000ff00UL) >> 8);
1422 dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x000000ffUL));
1427 dhcp_option_hostname(struct dhcp *dhcp, struct netif *netif)
1436 size_t available = DHCP_OPTIONS_LEN - dhcp->options_out_len - 3;
1440 dhcp_option(dhcp, DHCP_OPTION_HOSTNAME, (u8_t)len);
1442 dhcp_option_byte(dhcp, *p++);
1460 dhcp_parse_reply(struct dhcp *dhcp, struct pbuf *p)
1472 dhcp_clear_all_options(dhcp);
1477 dhcp->msg_in = (struct dhcp_msg *)p->payload;
1480 dhcp->boot_file_name[0] = 0;
1591 if (!dhcp_option_given(dhcp, decode_idx)) {
1599 dhcp_got_option(dhcp, decode_idx);
1600 dhcp_set_option_value(dhcp, decode_idx, lwip_htonl(value));
1611 dhcp_got_option(dhcp, decode_idx);
1612 dhcp_set_option_value(dhcp, decode_idx, value);
1629 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_OVERLOAD)) {
1630 u32_t overload = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_OVERLOAD);
1631 dhcp_clear_option(dhcp, DHCP_OPTION_IDX_OVERLOAD);
1648 if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) &&
1649 (dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) == DHCP_ACK))
1651 if (pbuf_copy_partial(p, dhcp->boot_file_name, DHCP_FILE_LEN-1, DHCP_FILE_OFS) != (DHCP_FILE_LEN-1)) {
1655 dhcp->boot_file_name[DHCP_FILE_LEN-1] = 0;
1681 struct dhcp *dhcp = netif_dhcp_data(netif);
1689 if ((dhcp == NULL) || (dhcp->pcb_allocated == 0)) {
1704 LWIP_ASSERT("reply wasn't freed", dhcp->msg_in == NULL);
1725 if (lwip_ntohl(reply_msg->xid) != dhcp->xid) {
1727 ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n",lwip_ntohl(reply_msg->xid),dhcp->xid));
1731 if (dhcp_parse_reply(dhcp, p) != ERR_OK) {
1739 if (!dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE)) {
1745 msg_type = (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE);
1750 if (dhcp->state == DHCP_STATE_REQUESTING) {
1766 else if ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REBINDING) ||
1767 (dhcp->state == DHCP_STATE_RENEWING)) {
1774 ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REQUESTING) ||
1775 (dhcp->state == DHCP_STATE_REBINDING) || (dhcp->state == DHCP_STATE_RENEWING ))) {
1780 else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_STATE_SELECTING)) {
1782 dhcp->request_timeout = 0;
1788 if (dhcp != NULL) {
1789 dhcp->msg_in = NULL;
1798 * @param dhcp dhcp control struct
1802 dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type)
1822 LWIP_ERROR("dhcp_create_msg: dhcp != NULL", (dhcp != NULL), return ERR_VAL;);
1823 LWIP_ASSERT("dhcp_create_msg: dhcp->p_out == NULL", dhcp->p_out == NULL);
1824 LWIP_ASSERT("dhcp_create_msg: dhcp->msg_out == NULL", dhcp->msg_out == NULL);
1825 dhcp->p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM);
1826 if (dhcp->p_out == NULL) {
1832 (dhcp->p_out->len >= sizeof(struct dhcp_msg)));
1837 if (dhcp->tries == 0) {
1844 dhcp->xid = xid;
1849 dhcp->msg_out = (struct dhcp_msg *)dhcp->p_out->payload;
1851 dhcp->msg_out->op = DHCP_BOOTREQUEST;
1853 dhcp->msg_out->htype = DHCP_HTYPE_ETH;
1854 dhcp->msg_out->hlen = netif->hwaddr_len;
1855 dhcp->msg_out->hops = 0;
1856 dhcp->msg_out->xid = lwip_htonl(dhcp->xid);
1857 dhcp->msg_out->secs = 0;
1860 dhcp->msg_out->flags = 0;
1861 ip4_addr_set_zero(&dhcp->msg_out->ciaddr);
1865 ((dhcp->state== DHCP_STATE_RENEWING) || dhcp->state== DHCP_STATE_REBINDING))) {
1866 ip4_addr_copy(dhcp->msg_out->ciaddr, *netif_ip4_addr(netif));
1868 ip4_addr_set_zero(&dhcp->msg_out->yiaddr);
1869 ip4_addr_set_zero(&dhcp->msg_out->siaddr);
1870 ip4_addr_set_zero(&dhcp->msg_out->giaddr);
1873 dhcp->msg_out->chaddr[i] = (i < netif->hwaddr_len && i < NETIF_MAX_HWADDR_LEN) ? netif->hwaddr[i] : 0/* pad byte*/;
1876 dhcp->msg_out->sname[i] = 0;
1879 dhcp->msg_out->file[i] = 0;
1881 dhcp->msg_out->cookie = PP_HTONL(DHCP_MAGIC_COOKIE);
1882 dhcp->options_out_len = 0;
1885 dhcp->msg_out->options[i] = (u8_t)i; /* for debugging only, no matter if truncated */
1888 dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN);
1889 dhcp_option_byte(dhcp, message_type);
1896 * @param dhcp the dhcp struct to free the request from
1899 dhcp_delete_msg(struct dhcp *dhcp)
1901 LWIP_ERROR("dhcp_delete_msg: dhcp != NULL", (dhcp != NULL), return;);
1902 LWIP_ASSERT("dhcp_delete_msg: dhcp->p_out != NULL", dhcp->p_out != NULL);
1903 LWIP_ASSERT("dhcp_delete_msg: dhcp->msg_out != NULL", dhcp->msg_out != NULL);
1904 if (dhcp->p_out != NULL) {
1905 pbuf_free(dhcp->p_out);
1907 dhcp->p_out = NULL;
1908 dhcp->msg_out = NULL;
1917 * @param dhcp DHCP state structure
1920 dhcp_option_trailer(struct dhcp *dhcp)
1922 LWIP_ERROR("dhcp_option_trailer: dhcp != NULL", (dhcp != NULL), return;);
1923 LWIP_ASSERT("dhcp_option_trailer: dhcp->msg_out != NULL\n", dhcp->msg_out != NULL);
1924 LWIP_ASSERT("dhcp_option_trailer: dhcp->options_out_len < DHCP_OPTIONS_LEN\n", dhcp->options_out_len < DHCP_OPTIONS_LEN);
1925 dhcp->msg_out->options[dhcp->options_out_len++] = DHCP_OPTION_END;
1927 while (((dhcp->options_out_len < DHCP_MIN_OPTIONS_LEN) || (dhcp->options_out_len & 3)) &&
1928 (dhcp->options_out_len < DHCP_OPTIONS_LEN)) {
1930 dhcp->msg_out->options[dhcp->options_out_len++] = 0;
1944 struct dhcp* dhcp = netif_dhcp_data(netif);
1945 return (dhcp->state == DHCP_STATE_BOUND) || (dhcp->state == DHCP_STATE_RENEWING);