alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-09 20:41:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

lwip/dhcps: Support for dynamic dhcp server instances

Browse Source
This commit is contained in:
David Cermak
2022-01-19 19:50:49 +01:00
parent bab051f450
commit c005b04d1c
8 changed files with 264 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
components/esp_netif/include/esp_netif_sta_list.h
View File

@@ -1,16 +1,8 @@
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD /*
// * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD
// Licensed under the Apache License, Version 2.0 (the "License"); *
// you may not use this file except in compliance with the License. * SPDX-License-Identifier: Apache-2.0
// You may obtain a copy of the License at */
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef _ESP_NETIF_STA_LIST_H_ #ifndef _ESP_NETIF_STA_LIST_H_
#define _ESP_NETIF_STA_LIST_H_ #define _ESP_NETIF_STA_LIST_H_
@@ -50,6 +42,8 @@ typedef struct {
/** /**
* @brief Get IP information for stations connected to the Wi-Fi AP interface * @brief Get IP information for stations connected to the Wi-Fi AP interface
* *
* @warning This API works only for the default Wi-Fi AP interface, i.e. esp-netif with key="WIFI_AP_DEF"
*
* @param[in] wifi_sta_list Wi-Fi station info list, returned from esp_wifi_ap_get_sta_list() * @param[in] wifi_sta_list Wi-Fi station info list, returned from esp_wifi_ap_get_sta_list()
* @param[out] netif_sta_list IP layer station info list, corresponding to MAC addresses provided in wifi_sta_list * @param[out] netif_sta_list IP layer station info list, corresponding to MAC addresses provided in wifi_sta_list
* *

36
components/esp_netif/lwip/esp_netif_lwip.c
View File

@@ -548,6 +548,13 @@ esp_netif_t *esp_netif_new(const esp_netif_config_t *esp_netif_config)
esp_netif_add_to_list(esp_netif); esp_netif_add_to_list(esp_netif);
#if ESP_DHCPS
// Create DHCP server structure
if (esp_netif_config->base->flags & ESP_NETIF_DHCP_SERVER) {
esp_netif->dhcps = dhcps_new();
}
#endif
// Configure the created object with provided configuration // Configure the created object with provided configuration
esp_err_t ret = esp_netif_init_configuration(esp_netif, esp_netif_config); esp_err_t ret = esp_netif_init_configuration(esp_netif, esp_netif_config);
if (ret != ESP_OK) { if (ret != ESP_OK) {
@@ -627,6 +634,9 @@ void esp_netif_destroy(esp_netif_t *esp_netif)
vSemaphoreDelete(esp_netif->transmit_mutex); vSemaphoreDelete(esp_netif->transmit_mutex);
#endif // CONFIG_ESP_NETIF_L2_TAP #endif // CONFIG_ESP_NETIF_L2_TAP
esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED); esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED);
#if ESP_DHCPS
dhcps_delete(esp_netif->dhcps);
#endif
free(esp_netif); free(esp_netif);
} }
} }
@@ -856,9 +866,9 @@ static esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg)
ip4_addr_t lwip_netmask; ip4_addr_t lwip_netmask;
memcpy(&lwip_ip, &default_ip->ip, sizeof(struct ip4_addr)); memcpy(&lwip_ip, &default_ip->ip, sizeof(struct ip4_addr));
memcpy(&lwip_netmask, &default_ip->netmask, sizeof(struct ip4_addr)); memcpy(&lwip_netmask, &default_ip->netmask, sizeof(struct ip4_addr));
dhcps_set_new_lease_cb(esp_netif_dhcps_cb); dhcps_set_new_lease_cb(esp_netif->dhcps, esp_netif_dhcps_cb);
dhcps_set_option_info(SUBNET_MASK, (void*)&lwip_netmask, sizeof(lwip_netmask)); dhcps_set_option_info(esp_netif->dhcps, SUBNET_MASK, (void*)&lwip_netmask, sizeof(lwip_netmask));
dhcps_start(p_netif, lwip_ip); dhcps_start(esp_netif->dhcps, p_netif, lwip_ip);
esp_netif->dhcps_status = ESP_NETIF_DHCP_STARTED; esp_netif->dhcps_status = ESP_NETIF_DHCP_STARTED;
ESP_LOGD(TAG, "DHCP server started successfully"); ESP_LOGD(TAG, "DHCP server started successfully");
esp_netif_update_default_netif(esp_netif, ESP_NETIF_STARTED); esp_netif_update_default_netif(esp_netif, ESP_NETIF_STARTED);
@@ -928,7 +938,7 @@ static esp_err_t esp_netif_stop_api(esp_netif_api_msg_t *msg)
if (esp_netif->flags & ESP_NETIF_DHCP_SERVER) { if (esp_netif->flags & ESP_NETIF_DHCP_SERVER) {
#if ESP_DHCPS #if ESP_DHCPS
dhcps_stop(lwip_netif); // TODO(IDF-1099): dhcps checks status by its self dhcps_stop(esp_netif->dhcps, lwip_netif); // TODO(IDF-1099): dhcps checks status by its self
if (ESP_NETIF_DHCP_STOPPED != esp_netif->dhcps_status) { if (ESP_NETIF_DHCP_STOPPED != esp_netif->dhcps_status) {
esp_netif->dhcps_status = ESP_NETIF_DHCP_INIT; esp_netif->dhcps_status = ESP_NETIF_DHCP_INIT;
} }
@@ -1303,9 +1313,9 @@ static esp_err_t esp_netif_dhcps_start_api(esp_netif_api_msg_t *msg)
ip4_addr_t lwip_netmask; ip4_addr_t lwip_netmask;
memcpy(&lwip_ip, &default_ip->ip, sizeof(struct ip4_addr)); memcpy(&lwip_ip, &default_ip->ip, sizeof(struct ip4_addr));
memcpy(&lwip_netmask, &default_ip->netmask, sizeof(struct ip4_addr)); memcpy(&lwip_netmask, &default_ip->netmask, sizeof(struct ip4_addr));
dhcps_set_new_lease_cb(esp_netif_dhcps_cb); dhcps_set_new_lease_cb(esp_netif->dhcps, esp_netif_dhcps_cb);
dhcps_set_option_info(SUBNET_MASK, (void*)&lwip_netmask, sizeof(lwip_netmask)); dhcps_set_option_info(esp_netif->dhcps, SUBNET_MASK, (void*)&lwip_netmask, sizeof(lwip_netmask));
dhcps_start(p_netif, lwip_ip); dhcps_start(esp_netif->dhcps, p_netif, lwip_ip);
esp_netif->dhcps_status = ESP_NETIF_DHCP_STARTED; esp_netif->dhcps_status = ESP_NETIF_DHCP_STARTED;
ESP_LOGD(TAG, "DHCP server started successfully"); ESP_LOGD(TAG, "DHCP server started successfully");
return ESP_OK; return ESP_OK;
@@ -1331,7 +1341,7 @@ static esp_err_t esp_netif_dhcps_stop_api(esp_netif_api_msg_t *msg)
struct netif *p_netif = esp_netif->lwip_netif; struct netif *p_netif = esp_netif->lwip_netif;
if (esp_netif->dhcps_status == ESP_NETIF_DHCP_STARTED) { if (esp_netif->dhcps_status == ESP_NETIF_DHCP_STARTED) {
if (p_netif != NULL) { if (p_netif != NULL) {
dhcps_stop(p_netif); dhcps_stop(esp_netif->dhcps, p_netif);
} else { } else {
ESP_LOGD(TAG, "dhcp server if not ready"); ESP_LOGD(TAG, "dhcp server if not ready");
return ESP_ERR_ESP_NETIF_IF_NOT_READY; return ESP_ERR_ESP_NETIF_IF_NOT_READY;
@@ -1648,7 +1658,7 @@ static esp_err_t esp_netif_set_dns_info_api(esp_netif_api_msg_t *msg)
ESP_LOGD(TAG, "set dns invalid type"); ESP_LOGD(TAG, "set dns invalid type");
return ESP_ERR_ESP_NETIF_INVALID_PARAMS; return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
} else { } else {
dhcps_dns_setserver(lwip_ip); dhcps_dns_setserver(esp_netif->dhcps, lwip_ip);
} }
#else #else
LOG_NETIF_DISABLED_AND_DO("DHCP Server", return ESP_ERR_NOT_SUPPORTED); LOG_NETIF_DISABLED_AND_DO("DHCP Server", return ESP_ERR_NOT_SUPPORTED);
@@ -1688,7 +1698,7 @@ static esp_err_t esp_netif_get_dns_info_api(esp_netif_api_msg_t *msg)
if (esp_netif->flags & ESP_NETIF_DHCP_SERVER) { if (esp_netif->flags & ESP_NETIF_DHCP_SERVER) {
#if ESP_DHCPS #if ESP_DHCPS
ip4_addr_t dns_ip = dhcps_dns_getserver(); ip4_addr_t dns_ip = dhcps_dns_getserver(esp_netif->dhcps);
memcpy(&dns->ip.u_addr.ip4, &dns_ip, sizeof(ip4_addr_t)); memcpy(&dns->ip.u_addr.ip4, &dns_ip, sizeof(ip4_addr_t));
#else #else
LOG_NETIF_DISABLED_AND_DO("DHCP Server", return ESP_ERR_NOT_SUPPORTED); LOG_NETIF_DISABLED_AND_DO("DHCP Server", return ESP_ERR_NOT_SUPPORTED);
@@ -1894,10 +1904,10 @@ int32_t esp_netif_get_event_id(esp_netif_t *esp_netif, esp_netif_ip_event_type_t
esp_err_t esp_netif_dhcps_option(esp_netif_t *esp_netif, esp_netif_dhcp_option_mode_t opt_op, esp_netif_dhcp_option_id_t opt_id, void *opt_val, esp_err_t esp_netif_dhcps_option(esp_netif_t *esp_netif, esp_netif_dhcp_option_mode_t opt_op, esp_netif_dhcp_option_id_t opt_id, void *opt_val,
uint32_t opt_len) uint32_t opt_len)
{ {
void *opt_info = dhcps_option_info(opt_id, opt_len); if (esp_netif == NULL || esp_netif->dhcps == NULL) {
if (esp_netif == NULL) {
return ESP_ERR_ESP_NETIF_IF_NOT_READY; return ESP_ERR_ESP_NETIF_IF_NOT_READY;
} }
void *opt_info = dhcps_option_info(esp_netif->dhcps, opt_id, opt_len);
esp_netif_dhcp_status_t dhcps_status = esp_netif->dhcps_status; esp_netif_dhcp_status_t dhcps_status = esp_netif->dhcps_status;
if (opt_info == NULL || opt_val == NULL) { if (opt_info == NULL || opt_val == NULL) {
@@ -2011,7 +2021,7 @@ esp_err_t esp_netif_dhcps_option(esp_netif_t *esp_netif, esp_netif_dhcp_option_m
default: default:
break; break;
} }
dhcps_set_option_info(opt_id, opt_info, opt_len); dhcps_set_option_info(esp_netif->dhcps, opt_id, opt_info, opt_len);
} else { } else {
return ESP_ERR_ESP_NETIF_INVALID_PARAMS; return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
} }

5
components/esp_netif/lwip/esp_netif_lwip_internal.h
View File

@@ -10,6 +10,7 @@
#include "esp_netif_ppp.h" #include "esp_netif_ppp.h"
#include "esp_netif_slip.h" #include "esp_netif_slip.h"
#include "lwip/netif.h" #include "lwip/netif.h"
#include "dhcpserver/dhcpserver.h"
#ifdef CONFIG_ESP_NETIF_TCPIP_LWIP #ifdef CONFIG_ESP_NETIF_TCPIP_LWIP
@@ -101,7 +102,9 @@ struct esp_netif_obj {
void (*lwip_input_fn)(void *input_netif_handle, void *buffer, size_t len, void *eb); void (*lwip_input_fn)(void *input_netif_handle, void *buffer, size_t len, void *eb);
void * netif_handle; // netif impl context (either vanilla lwip-netif or ppp_pcb) void * netif_handle; // netif impl context (either vanilla lwip-netif or ppp_pcb)
netif_related_data_t *related_data; // holds additional data for specific netifs netif_related_data_t *related_data; // holds additional data for specific netifs
#if ESP_DHCPS
dhcps_t *dhcps;
#endif
// io driver related // io driver related
void* driver_handle; void* driver_handle;
esp_err_t (*driver_transmit)(void *h, void *buffer, size_t len); esp_err_t (*driver_transmit)(void *h, void *buffer, size_t len);

27
components/esp_netif/lwip/esp_netif_sta_list.c
View File

@@ -1,19 +1,11 @@
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD /*
// * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD
// Licensed under the Apache License, Version 2.0 (the "License"); *
// you may not use this file except in compliance with the License. * SPDX-License-Identifier: Apache-2.0
// You may obtain a copy of the License at */
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <string.h> #include <string.h>
#include "esp_netif.h" #include "esp_netif_lwip_internal.h"
#include "esp_netif_sta_list.h" #include "esp_netif_sta_list.h"
#include "dhcpserver/dhcpserver.h" #include "dhcpserver/dhcpserver.h"
#include "esp_log.h" #include "esp_log.h"
@@ -29,12 +21,15 @@ esp_err_t esp_netif_get_sta_list(const wifi_sta_list_t *wifi_sta_list, esp_netif
if ((wifi_sta_list == NULL) || (netif_sta_list == NULL)) { if ((wifi_sta_list == NULL) || (netif_sta_list == NULL)) {
return ESP_ERR_ESP_NETIF_INVALID_PARAMS; return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
} }
esp_netif_t *ap = esp_netif_get_handle_from_ifkey("WIFI_AP_DEF");
if (ap == NULL) {
return ESP_ERR_ESP_NETIF_IF_NOT_READY;
}
memset(netif_sta_list, 0, sizeof(esp_netif_sta_list_t)); memset(netif_sta_list, 0, sizeof(esp_netif_sta_list_t));
netif_sta_list->num = wifi_sta_list->num; netif_sta_list->num = wifi_sta_list->num;
for (int i = 0; i < wifi_sta_list->num; i++) { for (int i = 0; i < wifi_sta_list->num; i++) {
memcpy(netif_sta_list->sta[i].mac, wifi_sta_list->sta[i].mac, 6); memcpy(netif_sta_list->sta[i].mac, wifi_sta_list->sta[i].mac, 6);
dhcp_search_ip_on_mac(netif_sta_list->sta[i].mac, (ip4_addr_t*)&netif_sta_list->sta[i].ip); dhcp_search_ip_on_mac(ap->dhcps, netif_sta_list->sta[i].mac, (ip4_addr_t*)&netif_sta_list->sta[i].ip);
} }
return ESP_OK; return ESP_OK;

359
components/lwip/apps/dhcpserver/dhcpserver.c
View File

@@ -6,12 +6,14 @@
//#include "esp_common.h" //#include "esp_common.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <lwip/dhcp.h>
#include "lwip/inet.h" #include "lwip/inet.h"
#include "lwip/err.h" #include "lwip/err.h"
#include "lwip/pbuf.h" #include "lwip/pbuf.h"
#include "lwip/udp.h" #include "lwip/udp.h"
#include "lwip/mem.h" #include "lwip/mem.h"
#include "lwip/ip_addr.h" #include "lwip/ip_addr.h"
#include "lwip/timeouts.h"
#include "dhcpserver/dhcpserver.h" #include "dhcpserver/dhcpserver.h"
#include "dhcpserver/dhcpserver_options.h" #include "dhcpserver/dhcpserver_options.h"
@@ -63,9 +65,16 @@
#define DHCPS_STATE_IDLE 5 #define DHCPS_STATE_IDLE 5
#define DHCPS_STATE_RELEASE 6 #define DHCPS_STATE_RELEASE 6
typedef struct _list_node { typedef enum {
DHCPS_HANDLE_CREATED = 0,
DHCPS_HANDLE_STARTED,
DHCPS_HANDLE_STOPPED,
DHCPS_HANDLE_DELETE_PENDING,
} dhcps_handle_state;
typedef struct list_node {
void *pnode; void *pnode;
struct _list_node *pnext; struct list_node *pnext;
} list_node; } list_node;
typedef struct { typedef struct {
@@ -77,29 +86,57 @@ typedef struct {
static const u32_t magic_cookie = 0x63538263; static const u32_t magic_cookie = 0x63538263;
static struct netif *dhcps_netif = NULL; struct dhcps_t {
static ip4_addr_t broadcast_dhcps; struct netif *dhcps_netif;
static ip4_addr_t server_address; ip4_addr_t broadcast_dhcps;
static ip4_addr_t dns_server = {0}; ip4_addr_t server_address;
static ip4_addr_t client_address; //added ip4_addr_t dns_server;
static ip4_addr_t client_address_plus; ip4_addr_t client_address;
static ip4_addr_t s_dhcps_mask = { ip4_addr_t client_address_plus;
ip4_addr_t dhcps_mask;
list_node *plist;
bool renew;
dhcps_lease_t dhcps_poll;
dhcps_time_t dhcps_lease_time;
dhcps_offer_t dhcps_offer;
dhcps_offer_t dhcps_dns;
dhcps_cb_t dhcps_cb;
struct udp_pcb *dhcps_pcb;
dhcps_handle_state state;
};
static void dhcps_tmr(void* arg);
dhcps_t *dhcps_new(void)
{
dhcps_t *dhcps = calloc(1, sizeof(dhcps_t));
if (dhcps == NULL) {
return NULL;
}
dhcps->dhcps_netif = NULL;
dhcps->dns_server.addr = 0;
#ifdef USE_CLASS_B_NET #ifdef USE_CLASS_B_NET
.addr = PP_HTONL(LWIP_MAKEU32(255, 240, 0, 0)) dhcps->dhcps_mask.addr = PP_HTONL(LWIP_MAKEU32(255, 240, 0, 0));
#else #else
.addr = PP_HTONL(LWIP_MAKEU32(255, 255, 255, 0)) dhcps->dhcps_mask.addr = PP_HTONL(LWIP_MAKEU32(255, 255, 255, 0));
#endif #endif
}; dhcps->plist = NULL;
dhcps->renew = false;
dhcps->dhcps_lease_time = DHCPS_LEASE_TIME_DEF; //minute
dhcps->dhcps_offer = 0xFF;
dhcps->dhcps_dns = 0x00;
dhcps->dhcps_pcb = NULL;
dhcps->state = DHCPS_HANDLE_CREATED;
sys_timeout(DHCP_COARSE_TIMER_MSECS, dhcps_tmr, dhcps);
return dhcps;
}
static list_node *plist = NULL; void dhcps_delete(dhcps_t *dhcps)
static bool renew = false; {
dhcps->state = DHCPS_HANDLE_DELETE_PENDING;
static dhcps_lease_t dhcps_poll; }
static dhcps_time_t dhcps_lease_time = DHCPS_LEASE_TIME_DEF; //minute
static dhcps_offer_t dhcps_offer = 0xFF;
static dhcps_offer_t dhcps_dns = 0x00;
static dhcps_cb_t dhcps_cb;
static struct udp_pcb *dhcps_pcb = NULL;
static void get_ip_info(struct netif * netif, ip_info_t *ip_info) static void get_ip_info(struct netif * netif, ip_info_t *ip_info)
{ {
@@ -117,41 +154,41 @@ static void get_ip_info(struct netif * netif, ip_info_t *ip_info)
* opt_len -- DHCP message option length * opt_len -- DHCP message option length
* Returns : DHCP message option addr * Returns : DHCP message option addr
*******************************************************************************/ *******************************************************************************/
void *dhcps_option_info(u8_t op_id, u32_t opt_len) void *dhcps_option_info(dhcps_t *dhcps, u8_t op_id, u32_t opt_len)
{ {
void *option_arg = NULL; void *option_arg = NULL;
switch (op_id) { switch (op_id) {
case IP_ADDRESS_LEASE_TIME: case IP_ADDRESS_LEASE_TIME:
if (opt_len == sizeof(dhcps_time_t)) { if (opt_len == sizeof(dhcps_time_t)) {
option_arg = &dhcps_lease_time; option_arg = &dhcps->dhcps_lease_time;
} }
break; break;
case REQUESTED_IP_ADDRESS: case REQUESTED_IP_ADDRESS:
if (opt_len == sizeof(dhcps_lease_t)) { if (opt_len == sizeof(dhcps_lease_t)) {
option_arg = &dhcps_poll; option_arg = &dhcps->dhcps_poll;
} }
break; break;
case ROUTER_SOLICITATION_ADDRESS: case ROUTER_SOLICITATION_ADDRESS:
if (opt_len == sizeof(dhcps_offer_t)) { if (opt_len == sizeof(dhcps_offer_t)) {
option_arg = &dhcps_offer; option_arg = &dhcps->dhcps_offer;
} }
break; break;
case DOMAIN_NAME_SERVER: case DOMAIN_NAME_SERVER:
if (opt_len == sizeof(dhcps_offer_t)) { if (opt_len == sizeof(dhcps_offer_t)) {
option_arg = &dhcps_dns; option_arg = &dhcps->dhcps_dns;
} }
break; break;
case SUBNET_MASK: case SUBNET_MASK:
if (opt_len == sizeof(s_dhcps_mask)) { if (opt_len == sizeof(dhcps->dhcps_mask)) {
option_arg = &s_dhcps_mask; option_arg = &dhcps->dhcps_mask;
} }
break; break;
@@ -170,7 +207,7 @@ void *dhcps_option_info(u8_t op_id, u32_t opt_len)
* opt_len -- DHCP message option length * opt_len -- DHCP message option length
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
void dhcps_set_option_info(u8_t op_id, void *opt_info, u32_t opt_len) void dhcps_set_option_info(dhcps_t *dhcps, u8_t op_id, void *opt_info, u32_t opt_len)
{ {
if (opt_info == NULL) { if (opt_info == NULL) {
return; return;
@@ -178,34 +215,34 @@ void dhcps_set_option_info(u8_t op_id, void *opt_info, u32_t opt_len)
switch (op_id) { switch (op_id) {
case IP_ADDRESS_LEASE_TIME: case IP_ADDRESS_LEASE_TIME:
if (opt_len == sizeof(dhcps_time_t)) { if (opt_len == sizeof(dhcps_time_t)) {
dhcps_lease_time = *(dhcps_time_t *)opt_info; dhcps->dhcps_lease_time = *(dhcps_time_t *)opt_info;
} }
break; break;
case REQUESTED_IP_ADDRESS: case REQUESTED_IP_ADDRESS:
if (opt_len == sizeof(dhcps_lease_t)) { if (opt_len == sizeof(dhcps_lease_t)) {
dhcps_poll = *(dhcps_lease_t *)opt_info; dhcps->dhcps_poll = *(dhcps_lease_t *)opt_info;
} }
break; break;
case ROUTER_SOLICITATION_ADDRESS: case ROUTER_SOLICITATION_ADDRESS:
if (opt_len == sizeof(dhcps_offer_t)) { if (opt_len == sizeof(dhcps_offer_t)) {
dhcps_offer = *(dhcps_offer_t *)opt_info; dhcps->dhcps_offer = *(dhcps_offer_t *)opt_info;
} }
break; break;
case DOMAIN_NAME_SERVER: case DOMAIN_NAME_SERVER:
if (opt_len == sizeof(dhcps_offer_t)) { if (opt_len == sizeof(dhcps_offer_t)) {
dhcps_dns = *(dhcps_offer_t *)opt_info; dhcps->dhcps_dns = *(dhcps_offer_t *)opt_info;
} }
break; break;
case SUBNET_MASK: case SUBNET_MASK:
if (opt_len == sizeof(s_dhcps_mask)) { if (opt_len == sizeof(dhcps->dhcps_mask)) {
s_dhcps_mask = *(ip4_addr_t *)opt_info; dhcps->dhcps_mask = *(ip4_addr_t *)opt_info;
} }
@@ -314,25 +351,25 @@ static u8_t *add_msg_type(u8_t *optptr, u8_t type)
* Parameters : optptr -- the addr of DHCP message option * Parameters : optptr -- the addr of DHCP message option
* Returns : the addr of DHCP message option * Returns : the addr of DHCP message option
*******************************************************************************/ *******************************************************************************/
static u8_t *add_offer_options(u8_t *optptr) static u8_t *add_offer_options(dhcps_t *dhcps, u8_t *optptr)
{ {
ip4_addr_t ipadd; ip4_addr_t ipadd;
ipadd.addr = *((u32_t *) &server_address); ipadd.addr = *((u32_t *) &dhcps->server_address);
*optptr++ = DHCP_OPTION_SUBNET_MASK; *optptr++ = DHCP_OPTION_SUBNET_MASK;
*optptr++ = 4; *optptr++ = 4;
*optptr++ = ip4_addr1(&s_dhcps_mask); *optptr++ = ip4_addr1(&dhcps->dhcps_mask);
*optptr++ = ip4_addr2(&s_dhcps_mask); *optptr++ = ip4_addr2(&dhcps->dhcps_mask);
*optptr++ = ip4_addr3(&s_dhcps_mask); *optptr++ = ip4_addr3(&dhcps->dhcps_mask);
*optptr++ = ip4_addr4(&s_dhcps_mask); *optptr++ = ip4_addr4(&dhcps->dhcps_mask);
*optptr++ = DHCP_OPTION_LEASE_TIME; *optptr++ = DHCP_OPTION_LEASE_TIME;
*optptr++ = 4; *optptr++ = 4;
*optptr++ = ((dhcps_lease_time * DHCPS_LEASE_UNIT) >> 24) & 0xFF; *optptr++ = ((dhcps->dhcps_lease_time * DHCPS_LEASE_UNIT) >> 24) & 0xFF;
*optptr++ = ((dhcps_lease_time * DHCPS_LEASE_UNIT) >> 16) & 0xFF; *optptr++ = ((dhcps->dhcps_lease_time * DHCPS_LEASE_UNIT) >> 16) & 0xFF;
*optptr++ = ((dhcps_lease_time * DHCPS_LEASE_UNIT) >> 8) & 0xFF; *optptr++ = ((dhcps->dhcps_lease_time * DHCPS_LEASE_UNIT) >> 8) & 0xFF;
*optptr++ = ((dhcps_lease_time * DHCPS_LEASE_UNIT) >> 0) & 0xFF; *optptr++ = ((dhcps->dhcps_lease_time * DHCPS_LEASE_UNIT) >> 0) & 0xFF;
*optptr++ = DHCP_OPTION_SERVER_ID; *optptr++ = DHCP_OPTION_SERVER_ID;
*optptr++ = 4; *optptr++ = 4;
@@ -341,9 +378,9 @@ static u8_t *add_offer_options(u8_t *optptr)
*optptr++ = ip4_addr3(&ipadd); *optptr++ = ip4_addr3(&ipadd);
*optptr++ = ip4_addr4(&ipadd); *optptr++ = ip4_addr4(&ipadd);
if (dhcps_router_enabled(dhcps_offer)) { if (dhcps_router_enabled(dhcps->dhcps_offer)) {
ip_info_t if_ip = { 0 }; ip_info_t if_ip = { 0 };
get_ip_info(dhcps_netif, &if_ip); get_ip_info(dhcps->dhcps_netif, &if_ip);
ip4_addr_t* gw_ip = (ip4_addr_t*)&if_ip.gw; ip4_addr_t* gw_ip = (ip4_addr_t*)&if_ip.gw;
@@ -359,11 +396,11 @@ static u8_t *add_offer_options(u8_t *optptr)
*optptr++ = DHCP_OPTION_DNS_SERVER; *optptr++ = DHCP_OPTION_DNS_SERVER;
*optptr++ = 4; *optptr++ = 4;
if (dhcps_dns_enabled(dhcps_dns)) { if (dhcps_dns_enabled(dhcps->dhcps_dns)) {
*optptr++ = ip4_addr1(&dns_server); *optptr++ = ip4_addr1(&dhcps->dns_server);
*optptr++ = ip4_addr2(&dns_server); *optptr++ = ip4_addr2(&dhcps->dns_server);
*optptr++ = ip4_addr3(&dns_server); *optptr++ = ip4_addr3(&dhcps->dns_server);
*optptr++ = ip4_addr4(&dns_server); *optptr++ = ip4_addr4(&dhcps->dns_server);
}else { }else {
*optptr++ = ip4_addr1(&ipadd); *optptr++ = ip4_addr1(&ipadd);
*optptr++ = ip4_addr2(&ipadd); *optptr++ = ip4_addr2(&ipadd);
@@ -371,7 +408,7 @@ static u8_t *add_offer_options(u8_t *optptr)
*optptr++ = ip4_addr4(&ipadd); *optptr++ = ip4_addr4(&ipadd);
} }
ip4_addr_t broadcast_addr = { .addr = (ipadd.addr & s_dhcps_mask.addr) | ~s_dhcps_mask.addr }; ip4_addr_t broadcast_addr = { .addr = (ipadd.addr & dhcps->dhcps_mask.addr) | ~dhcps->dhcps_mask.addr };
*optptr++ = DHCP_OPTION_BROADCAST_ADDRESS; *optptr++ = DHCP_OPTION_BROADCAST_ADDRESS;
*optptr++ = 4; *optptr++ = 4;
*optptr++ = ip4_addr1(&broadcast_addr); *optptr++ = ip4_addr1(&broadcast_addr);
@@ -419,12 +456,12 @@ static u8_t *add_end(u8_t *optptr)
* Parameters : m -- DHCP message info * Parameters : m -- DHCP message info
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static void create_msg(struct dhcps_msg *m) static void create_msg(dhcps_t *dhcps, struct dhcps_msg *m)
{ {
ip4_addr_t client; ip4_addr_t client;
client.addr = *((uint32_t *) &client_address); client.addr = *((uint32_t *) &dhcps->client_address);
m->op = DHCP_REPLY; m->op = DHCP_REPLY;
@@ -476,7 +513,7 @@ struct pbuf * dhcps_pbuf_alloc(u16_t len)
* Parameters : m -- DHCP message info * Parameters : m -- DHCP message info
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static void send_offer(struct dhcps_msg *m, u16_t len) static void send_offer(dhcps_t *dhcps, struct dhcps_msg *m, u16_t len)
{ {
u8_t *end; u8_t *end;
struct pbuf *p, *q; struct pbuf *p, *q;
@@ -486,10 +523,10 @@ static void send_offer(struct dhcps_msg *m, u16_t len)
#if DHCPS_DEBUG #if DHCPS_DEBUG
err_t SendOffer_err_t; err_t SendOffer_err_t;
#endif #endif
create_msg(m); create_msg(dhcps, m);
end = add_msg_type(&m->options[4], DHCPOFFER); end = add_msg_type(&m->options[4], DHCPOFFER);
end = add_offer_options(end); end = add_offer_options(dhcps, end);
end = add_end(end); end = add_end(end);
p = dhcps_pbuf_alloc(len); p = dhcps_pbuf_alloc(len);
@@ -532,12 +569,12 @@ static void send_offer(struct dhcps_msg *m, u16_t len)
} }
ip_addr_t ip_temp = IPADDR4_INIT(0x0); ip_addr_t ip_temp = IPADDR4_INIT(0x0);
ip4_addr_set(ip_2_ip4(&ip_temp), &broadcast_dhcps); ip4_addr_set(ip_2_ip4(&ip_temp), &dhcps->broadcast_dhcps);
#if DHCPS_DEBUG #if DHCPS_DEBUG
SendOffer_err_t = udp_sendto(pcb_dhcps, p, &ip_temp, DHCPS_CLIENT_PORT); SendOffer_err_t = udp_sendto(pcb_dhcps, p, &ip_temp, DHCPS_CLIENT_PORT);
DHCPS_LOG("dhcps: send_offer>>udp_sendto result %x\n", SendOffer_err_t); DHCPS_LOG("dhcps: send_offer>>udp_sendto result %x\n", SendOffer_err_t);
#else #else
udp_sendto(dhcps_pcb, p, &ip_temp, DHCPS_CLIENT_PORT); udp_sendto(dhcps->dhcps_pcb, p, &ip_temp, DHCPS_CLIENT_PORT);
#endif #endif
if (p->ref != 0) { if (p->ref != 0) {
@@ -554,7 +591,7 @@ static void send_offer(struct dhcps_msg *m, u16_t len)
* Parameters : m -- DHCP message info * Parameters : m -- DHCP message info
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static void send_nak(struct dhcps_msg *m, u16_t len) static void send_nak(dhcps_t *dhcps, struct dhcps_msg *m, u16_t len)
{ {
u8_t *end; u8_t *end;
struct pbuf *p, *q; struct pbuf *p, *q;
@@ -564,7 +601,7 @@ static void send_nak(struct dhcps_msg *m, u16_t len)
#if DHCPS_DEBUG #if DHCPS_DEBUG
err_t SendNak_err_t; err_t SendNak_err_t;
#endif #endif
create_msg(m); create_msg(dhcps, m);
end = add_msg_type(&m->options[4], DHCPNAK); end = add_msg_type(&m->options[4], DHCPNAK);
end = add_end(end); end = add_end(end);
@@ -609,12 +646,12 @@ static void send_nak(struct dhcps_msg *m, u16_t len)
} }
ip_addr_t ip_temp = IPADDR4_INIT(0x0); ip_addr_t ip_temp = IPADDR4_INIT(0x0);
ip4_addr_set(ip_2_ip4(&ip_temp), &broadcast_dhcps); ip4_addr_set(ip_2_ip4(&ip_temp), &dhcps->broadcast_dhcps);
#if DHCPS_DEBUG #if DHCPS_DEBUG
SendNak_err_t = udp_sendto(pcb_dhcps, p, &ip_temp, DHCPS_CLIENT_PORT); SendNak_err_t = udp_sendto(pcb_dhcps, p, &ip_temp, DHCPS_CLIENT_PORT);
DHCPS_LOG("dhcps: send_nak>>udp_sendto result %x\n", SendNak_err_t); DHCPS_LOG("dhcps: send_nak>>udp_sendto result %x\n", SendNak_err_t);
#else #else
udp_sendto(dhcps_pcb, p, &ip_temp, DHCPS_CLIENT_PORT); udp_sendto(dhcps->dhcps_pcb, p, &ip_temp, DHCPS_CLIENT_PORT);
#endif #endif
if (p->ref != 0) { if (p->ref != 0) {
@@ -631,7 +668,7 @@ static void send_nak(struct dhcps_msg *m, u16_t len)
* Parameters : m -- DHCP message info * Parameters : m -- DHCP message info
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static void send_ack(struct dhcps_msg *m, u16_t len) static void send_ack(dhcps_t *dhcps, struct dhcps_msg *m, u16_t len)
{ {
u8_t *end; u8_t *end;
struct pbuf *p, *q; struct pbuf *p, *q;
@@ -639,10 +676,10 @@ static void send_ack(struct dhcps_msg *m, u16_t len)
u16_t cnt = 0; u16_t cnt = 0;
u16_t i; u16_t i;
err_t SendAck_err_t; err_t SendAck_err_t;
create_msg(m); create_msg(dhcps, m);
end = add_msg_type(&m->options[4], DHCPACK); end = add_msg_type(&m->options[4], DHCPACK);
end = add_offer_options(end); end = add_offer_options(dhcps, end);
end = add_end(end); end = add_end(end);
p = dhcps_pbuf_alloc(len); p = dhcps_pbuf_alloc(len);
@@ -685,14 +722,14 @@ static void send_ack(struct dhcps_msg *m, u16_t len)
} }
ip_addr_t ip_temp = IPADDR4_INIT(0x0); ip_addr_t ip_temp = IPADDR4_INIT(0x0);
ip4_addr_set(ip_2_ip4(&ip_temp), &broadcast_dhcps); ip4_addr_set(ip_2_ip4(&ip_temp), &dhcps->broadcast_dhcps);
SendAck_err_t = udp_sendto(dhcps_pcb, p, &ip_temp, DHCPS_CLIENT_PORT); SendAck_err_t = udp_sendto(dhcps->dhcps_pcb, p, &ip_temp, DHCPS_CLIENT_PORT);
#if DHCPS_DEBUG #if DHCPS_DEBUG
DHCPS_LOG("dhcps: send_ack>>udp_sendto result %x\n", SendAck_err_t); DHCPS_LOG("dhcps: send_ack>>udp_sendto result %x\n", SendAck_err_t);
#endif #endif
if (SendAck_err_t == ERR_OK) { if (SendAck_err_t == ERR_OK) {
dhcps_cb(m->yiaddr, m->chaddr); dhcps->dhcps_cb(m->yiaddr, m->chaddr);
} }
if (p->ref != 0) { if (p->ref != 0) {
@@ -710,13 +747,13 @@ static void send_ack(struct dhcps_msg *m, u16_t len)
* len -- DHCP message option length * len -- DHCP message option length
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static u8_t parse_options(u8_t *optptr, s16_t len) static u8_t parse_options(dhcps_t *dhcps, u8_t *optptr, s16_t len)
{ {
ip4_addr_t client; ip4_addr_t client;
bool is_dhcp_parse_end = false; bool is_dhcp_parse_end = false;
struct dhcps_state s; struct dhcps_state s;
client.addr = *((uint32_t *) &client_address); client.addr = *((uint32_t *) &dhcps->client_address);
u8_t *end = optptr + len; u8_t *end = optptr + len;
u16_t type = 0; u16_t type = 0;
@@ -773,7 +810,7 @@ static u8_t parse_options(u8_t *optptr, s16_t len)
case DHCPREQUEST://3 case DHCPREQUEST://3
if (!(s.state == DHCPS_STATE_ACK || s.state == DHCPS_STATE_NAK)) { if (!(s.state == DHCPS_STATE_ACK || s.state == DHCPS_STATE_NAK)) {
if (renew == true) { if (dhcps->renew == true) {
s.state = DHCPS_STATE_ACK; s.state = DHCPS_STATE_ACK;
} else { } else {
s.state = DHCPS_STATE_NAK; s.state = DHCPS_STATE_NAK;
@@ -814,9 +851,9 @@ static u8_t parse_options(u8_t *optptr, s16_t len)
* len -- DHCP message length * len -- DHCP message length
* Returns : DHCP message type * Returns : DHCP message type
*******************************************************************************/ *******************************************************************************/
static s16_t parse_msg(struct dhcps_msg *m, u16_t len) static s16_t parse_msg(dhcps_t *dhcps, struct dhcps_msg *m, u16_t len)
{ {
u32_t lease_timer = (dhcps_lease_time * DHCPS_LEASE_UNIT)/DHCPS_COARSE_TIMER_SECS; u32_t lease_timer = (dhcps->dhcps_lease_time * DHCPS_LEASE_UNIT)/DHCPS_COARSE_TIMER_SECS;
if (memcmp((char *)m->options, &magic_cookie, sizeof(magic_cookie)) == 0) { if (memcmp((char *)m->options, &magic_cookie, sizeof(magic_cookie)) == 0) {
#if DHCPS_DEBUG #if DHCPS_DEBUG
@@ -830,28 +867,28 @@ static s16_t parse_msg(struct dhcps_msg *m, u16_t len)
ip4_addr_t first_address; ip4_addr_t first_address;
bool flag = false; bool flag = false;
first_address.addr = dhcps_poll.start_ip.addr; first_address.addr = dhcps->dhcps_poll.start_ip.addr;
client_address.addr = client_address_plus.addr; dhcps->client_address.addr = dhcps->client_address_plus.addr;
renew = false; dhcps->renew = false;
if (plist != NULL) { if (dhcps->plist != NULL) {
for (pback_node = plist; pback_node != NULL; pback_node = pback_node->pnext) { for (pback_node = dhcps->plist; pback_node != NULL; pback_node = pback_node->pnext) {
pdhcps_pool = pback_node->pnode; pdhcps_pool = pback_node->pnode;
if (memcmp(pdhcps_pool->mac, m->chaddr, sizeof(pdhcps_pool->mac)) == 0) { if (memcmp(pdhcps_pool->mac, m->chaddr, sizeof(pdhcps_pool->mac)) == 0) {
if (memcmp(&pdhcps_pool->ip.addr, m->ciaddr, sizeof(pdhcps_pool->ip.addr)) == 0) { if (memcmp(&pdhcps_pool->ip.addr, m->ciaddr, sizeof(pdhcps_pool->ip.addr)) == 0) {
renew = true; dhcps->renew = true;
} }
client_address.addr = pdhcps_pool->ip.addr; dhcps->client_address.addr = pdhcps_pool->ip.addr;
pdhcps_pool->lease_timer = lease_timer; pdhcps_pool->lease_timer = lease_timer;
pnode = pback_node; pnode = pback_node;
goto POOL_CHECK; goto POOL_CHECK;
} else if (pdhcps_pool->ip.addr == client_address_plus.addr) { } else if (pdhcps_pool->ip.addr == dhcps->client_address_plus.addr) {
addr_tmp.addr = htonl(client_address_plus.addr); addr_tmp.addr = htonl(dhcps->client_address_plus.addr);
addr_tmp.addr++; addr_tmp.addr++;
client_address_plus.addr = htonl(addr_tmp.addr); dhcps->client_address_plus.addr = htonl(addr_tmp.addr);
client_address.addr = client_address_plus.addr; dhcps->client_address.addr = dhcps->client_address_plus.addr;
} }
if (flag == false) { // search the fisrt unused ip if (flag == false) { // search the fisrt unused ip
@@ -865,22 +902,22 @@ static s16_t parse_msg(struct dhcps_msg *m, u16_t len)
} }
} }
} else { } else {
client_address.addr = dhcps_poll.start_ip.addr; dhcps->client_address.addr = dhcps->dhcps_poll.start_ip.addr;
} }
if (client_address_plus.addr > dhcps_poll.end_ip.addr) { if (dhcps->client_address_plus.addr > dhcps->dhcps_poll.end_ip.addr) {
client_address.addr = first_address.addr; dhcps->client_address.addr = first_address.addr;
} }
if (client_address.addr > dhcps_poll.end_ip.addr) { if (dhcps->client_address.addr > dhcps->dhcps_poll.end_ip.addr) {
client_address_plus.addr = dhcps_poll.start_ip.addr; dhcps->client_address_plus.addr = dhcps->dhcps_poll.start_ip.addr;
pdhcps_pool = NULL; pdhcps_pool = NULL;
pnode = NULL; pnode = NULL;
} else { } else {
pdhcps_pool = (struct dhcps_pool *)mem_malloc(sizeof(struct dhcps_pool)); pdhcps_pool = (struct dhcps_pool *)mem_malloc(sizeof(struct dhcps_pool));
memset(pdhcps_pool , 0x00 , sizeof(struct dhcps_pool)); memset(pdhcps_pool , 0x00 , sizeof(struct dhcps_pool));
pdhcps_pool->ip.addr = client_address.addr; pdhcps_pool->ip.addr = dhcps->client_address.addr;
memcpy(pdhcps_pool->mac, m->chaddr, sizeof(pdhcps_pool->mac)); memcpy(pdhcps_pool->mac, m->chaddr, sizeof(pdhcps_pool->mac));
pdhcps_pool->lease_timer = lease_timer; pdhcps_pool->lease_timer = lease_timer;
pnode = (list_node *)mem_malloc(sizeof(list_node)); pnode = (list_node *)mem_malloc(sizeof(list_node));
@@ -888,22 +925,22 @@ static s16_t parse_msg(struct dhcps_msg *m, u16_t len)
pnode->pnode = pdhcps_pool; pnode->pnode = pdhcps_pool;
pnode->pnext = NULL; pnode->pnext = NULL;
node_insert_to_list(&plist, pnode); node_insert_to_list(&dhcps->plist, pnode);
if (client_address.addr == dhcps_poll.end_ip.addr) { if (dhcps->client_address.addr == dhcps->dhcps_poll.end_ip.addr) {
client_address_plus.addr = dhcps_poll.start_ip.addr; dhcps->client_address_plus.addr = dhcps->dhcps_poll.start_ip.addr;
} else { } else {
addr_tmp.addr = htonl(client_address.addr); addr_tmp.addr = htonl(dhcps->client_address.addr);
addr_tmp.addr++; addr_tmp.addr++;
client_address_plus.addr = htonl(addr_tmp.addr); dhcps->client_address_plus.addr = htonl(addr_tmp.addr);
} }
} }
POOL_CHECK: POOL_CHECK:
if ((client_address.addr > dhcps_poll.end_ip.addr) || (ip4_addr_isany(&client_address))) { if ((dhcps->client_address.addr > dhcps->dhcps_poll.end_ip.addr) || (ip4_addr_isany(&dhcps->client_address))) {
if (pnode != NULL) { if (pnode != NULL) {
node_remove_from_list(&plist, pnode); node_remove_from_list(&dhcps->plist, pnode);
free(pnode); free(pnode);
pnode = NULL; pnode = NULL;
} }
@@ -916,11 +953,11 @@ POOL_CHECK:
return 4; return 4;
} }
s16_t ret = parse_options(&m->options[4], len);; s16_t ret = parse_options(dhcps, &m->options[4], len);;
if (ret == DHCPS_STATE_RELEASE || ret == DHCPS_STATE_NAK) { if (ret == DHCPS_STATE_RELEASE || ret == DHCPS_STATE_NAK) {
if (pnode != NULL) { if (pnode != NULL) {
node_remove_from_list(&plist, pnode); node_remove_from_list(&dhcps->plist, pnode);
free(pnode); free(pnode);
pnode = NULL; pnode = NULL;
} }
@@ -930,7 +967,7 @@ POOL_CHECK:
pdhcps_pool = NULL; pdhcps_pool = NULL;
} }
memset(&client_address, 0x0, sizeof(client_address)); memset(&dhcps->client_address, 0x0, sizeof(dhcps->client_address));
} }
#if DHCPS_DEBUG #if DHCPS_DEBUG
@@ -959,6 +996,7 @@ static void handle_dhcp(void *arg,
const ip_addr_t *addr, const ip_addr_t *addr,
u16_t port) u16_t port)
{ {
struct dhcps_t *dhcps = arg;
struct dhcps_msg *pmsg_dhcps = NULL; struct dhcps_msg *pmsg_dhcps = NULL;
s16_t tlen, malloc_len; s16_t tlen, malloc_len;
u16_t i; u16_t i;
@@ -1037,7 +1075,7 @@ static void handle_dhcp(void *arg,
DHCPS_LOG("dhcps: handle_dhcp-> parse_msg(p)\n"); DHCPS_LOG("dhcps: handle_dhcp-> parse_msg(p)\n");
#endif #endif
state = parse_msg(pmsg_dhcps, tlen - 240); state = parse_msg(dhcps, pmsg_dhcps, tlen - 240);
#ifdef LWIP_HOOK_DHCPS_POST_STATE #ifdef LWIP_HOOK_DHCPS_POST_STATE
state = LWIP_HOOK_DHCPS_POST_STATE(pmsg_dhcps, malloc_len, state); state = LWIP_HOOK_DHCPS_POST_STATE(pmsg_dhcps, malloc_len, state);
#endif /* LWIP_HOOK_DHCPS_POST_STATE */ #endif /* LWIP_HOOK_DHCPS_POST_STATE */
@@ -1047,21 +1085,21 @@ static void handle_dhcp(void *arg,
#if DHCPS_DEBUG #if DHCPS_DEBUG
DHCPS_LOG("dhcps: handle_dhcp-> DHCPD_STATE_OFFER\n"); DHCPS_LOG("dhcps: handle_dhcp-> DHCPD_STATE_OFFER\n");
#endif #endif
send_offer(pmsg_dhcps, malloc_len); send_offer(dhcps, pmsg_dhcps, malloc_len);
break; break;
case DHCPS_STATE_ACK://3 case DHCPS_STATE_ACK://3
#if DHCPS_DEBUG #if DHCPS_DEBUG
DHCPS_LOG("dhcps: handle_dhcp-> DHCPD_STATE_ACK\n"); DHCPS_LOG("dhcps: handle_dhcp-> DHCPD_STATE_ACK\n");
#endif #endif
send_ack(pmsg_dhcps, malloc_len); send_ack(dhcps, pmsg_dhcps, malloc_len);
break; break;
case DHCPS_STATE_NAK://4 case DHCPS_STATE_NAK://4
#if DHCPS_DEBUG #if DHCPS_DEBUG
DHCPS_LOG("dhcps: handle_dhcp-> DHCPD_STATE_NAK\n"); DHCPS_LOG("dhcps: handle_dhcp-> DHCPD_STATE_NAK\n");
#endif #endif
send_nak(pmsg_dhcps, malloc_len); send_nak(dhcps, pmsg_dhcps, malloc_len);
break; break;
default : default :
@@ -1082,32 +1120,32 @@ static void handle_dhcp(void *arg,
* Parameters : ip -- The current ip addr * Parameters : ip -- The current ip addr
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static void dhcps_poll_set(u32_t ip) static void dhcps_poll_set(dhcps_t *dhcps, u32_t ip)
{ {
u32_t softap_ip = 0, local_ip = 0; u32_t softap_ip = 0, local_ip = 0;
u32_t start_ip = 0; u32_t start_ip = 0;
u32_t end_ip = 0; u32_t end_ip = 0;
dhcps_lease_t *dhcps_poll = &dhcps->dhcps_poll;
if (dhcps_poll.enable == true) { if (dhcps_poll->enable == true) {
softap_ip = htonl(ip); softap_ip = htonl(ip);
start_ip = htonl(dhcps_poll.start_ip.addr); start_ip = htonl(dhcps_poll->start_ip.addr);
end_ip = htonl(dhcps_poll.end_ip.addr); end_ip = htonl(dhcps_poll->end_ip.addr);
/*config ip information can't contain local ip*/ /*config ip information can't contain local ip*/
if ((start_ip <= softap_ip) && (softap_ip <= end_ip)) { if ((start_ip <= softap_ip) && (softap_ip <= end_ip)) {
dhcps_poll.enable = false; dhcps_poll->enable = false;
} else { } else {
/*config ip information must be in the same segment as the local ip*/ /*config ip information must be in the same segment as the local ip*/
softap_ip >>= 8; softap_ip >>= 8;
if (((start_ip >> 8 != softap_ip) || (end_ip >> 8 != softap_ip)) if (((start_ip >> 8 != softap_ip) || (end_ip >> 8 != softap_ip))
|| (end_ip - start_ip > DHCPS_MAX_LEASE)) { || (end_ip - start_ip > DHCPS_MAX_LEASE)) {
dhcps_poll.enable = false; dhcps_poll->enable = false;
} }
} }
} }
if (dhcps_poll.enable == false) { if (dhcps_poll->enable == false) {
local_ip = softap_ip = htonl(ip); local_ip = softap_ip = htonl(ip);
softap_ip &= 0xFFFFFF00; softap_ip &= 0xFFFFFF00;
local_ip &= 0xFF; local_ip &= 0xFF;
@@ -1118,11 +1156,11 @@ static void dhcps_poll_set(u32_t ip)
local_ip ++; local_ip ++;
} }
bzero(&dhcps_poll, sizeof(dhcps_poll)); bzero(dhcps_poll, sizeof(*dhcps_poll));
dhcps_poll.start_ip.addr = softap_ip | local_ip; dhcps_poll->start_ip.addr = softap_ip | local_ip;
dhcps_poll.end_ip.addr = softap_ip | (local_ip + DHCPS_MAX_LEASE - 1); dhcps_poll->end_ip.addr = softap_ip | (local_ip + DHCPS_MAX_LEASE - 1);
dhcps_poll.start_ip.addr = htonl(dhcps_poll.start_ip.addr); dhcps_poll->start_ip.addr = htonl(dhcps_poll->start_ip.addr);
dhcps_poll.end_ip.addr = htonl(dhcps_poll.end_ip.addr); dhcps_poll->end_ip.addr = htonl(dhcps_poll->end_ip.addr);
} }
} }
@@ -1135,9 +1173,9 @@ static void dhcps_poll_set(u32_t ip)
* Parameters : cb -- callback for dhcp server * Parameters : cb -- callback for dhcp server
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
void dhcps_set_new_lease_cb(dhcps_cb_t cb) void dhcps_set_new_lease_cb(dhcps_t *dhcps, dhcps_cb_t cb)
{ {
dhcps_cb = cb; dhcps->dhcps_cb = cb;
} }
/****************************************************************************** /******************************************************************************
@@ -1147,28 +1185,29 @@ void dhcps_set_new_lease_cb(dhcps_cb_t cb)
* : info -- The current ip info * : info -- The current ip info
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
void dhcps_start(struct netif *netif, ip4_addr_t ip) void dhcps_start(dhcps_t *dhcps, struct netif *netif, ip4_addr_t ip)
{ {
dhcps_netif = netif; dhcps->dhcps_netif = netif;
if (dhcps_pcb != NULL) { if (dhcps->dhcps_pcb != NULL) {
udp_remove(dhcps_pcb); udp_remove(dhcps->dhcps_pcb);
} }
dhcps_pcb = udp_new(); dhcps->dhcps_pcb = udp_new();
if (dhcps_pcb == NULL || ip4_addr_isany_val(ip)) { if (dhcps->dhcps_pcb == NULL || ip4_addr_isany_val(ip)) {
printf("dhcps_start(): could not obtain pcb\n"); printf("dhcps_start(): could not obtain pcb\n");
} }
IP4_ADDR(&broadcast_dhcps, 255, 255, 255, 255); IP4_ADDR(&dhcps->broadcast_dhcps, 255, 255, 255, 255);
server_address.addr = ip.addr; dhcps->server_address.addr = ip.addr;
dhcps_poll_set(server_address.addr); dhcps_poll_set(dhcps, dhcps->server_address.addr);
client_address_plus.addr = dhcps_poll.start_ip.addr; dhcps->client_address_plus.addr = dhcps->dhcps_poll.start_ip.addr;
udp_bind(dhcps_pcb, &netif->ip_addr, DHCPS_SERVER_PORT); udp_bind(dhcps->dhcps_pcb, &netif->ip_addr, DHCPS_SERVER_PORT);
udp_recv(dhcps_pcb, handle_dhcp, NULL); udp_recv(dhcps->dhcps_pcb, handle_dhcp, dhcps);
dhcps->state = DHCPS_HANDLE_STARTED;
#if DHCPS_DEBUG #if DHCPS_DEBUG
DHCPS_LOG("dhcps:dhcps_start->udp_recv function Set a receive callback handle_dhcp for UDP_PCB pcb_dhcps\n"); DHCPS_LOG("dhcps:dhcps_start->udp_recv function Set a receive callback handle_dhcp for UDP_PCB pcb_dhcps\n");
#endif #endif
@@ -1181,32 +1220,33 @@ void dhcps_start(struct netif *netif, ip4_addr_t ip)
* Parameters : netif -- The current netif addr * Parameters : netif -- The current netif addr
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
void dhcps_stop(struct netif *netif) void dhcps_stop(dhcps_t *dhcps, struct netif *netif)
{ {
if (netif == NULL || dhcps_netif != netif->state) { if (netif == NULL || dhcps->dhcps_netif != netif) {
printf("dhcps_stop: netif is NULL or invalid\n"); printf("dhcps_stop: netif is NULL or invalid\n");
return; return;
} }
if (dhcps_pcb != NULL) { if (dhcps->dhcps_pcb != NULL) {
udp_disconnect(dhcps_pcb); udp_disconnect(dhcps->dhcps_pcb);
udp_remove(dhcps_pcb); udp_remove(dhcps->dhcps_pcb);
dhcps_pcb = NULL; dhcps->dhcps_pcb = NULL;
} }
list_node *pnode = NULL; list_node *pnode = NULL;
list_node *pback_node = NULL; list_node *pback_node = NULL;
pnode = plist; pnode = dhcps->plist;
while (pnode != NULL) { while (pnode != NULL) {
pback_node = pnode; pback_node = pnode;
pnode = pback_node->pnext; pnode = pback_node->pnext;
node_remove_from_list(&plist, pback_node); node_remove_from_list(&dhcps->plist, pback_node);
free(pback_node->pnode); free(pback_node->pnode);
pback_node->pnode = NULL; pback_node->pnode = NULL;
free(pback_node); free(pback_node);
pback_node = NULL; pback_node = NULL;
} }
dhcps->state = DHCPS_HANDLE_STOPPED;
} }
/****************************************************************************** /******************************************************************************
@@ -1215,12 +1255,12 @@ void dhcps_stop(struct netif *netif)
* Parameters : none * Parameters : none
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
static void kill_oldest_dhcps_pool(void) static void kill_oldest_dhcps_pool(dhcps_t *dhcps)
{ {
list_node *pre = NULL, *p = NULL; list_node *pre = NULL, *p = NULL;
list_node *minpre = NULL, *minp = NULL; list_node *minpre = NULL, *minp = NULL;
struct dhcps_pool *pdhcps_pool = NULL, *pmin_pool = NULL; struct dhcps_pool *pdhcps_pool = NULL, *pmin_pool = NULL;
pre = plist; pre = dhcps->plist;
assert(pre != NULL && pre->pnext != NULL); // Expect the list to have at least 2 nodes assert(pre != NULL && pre->pnext != NULL); // Expect the list to have at least 2 nodes
p = pre->pnext; p = pre->pnext;
minpre = pre; minpre = pre;
@@ -1252,13 +1292,24 @@ static void kill_oldest_dhcps_pool(void)
* Parameters : none * Parameters : none
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
void dhcps_coarse_tmr(void) static void dhcps_tmr(void *arg)
{ {
dhcps_t *dhcps = arg;
dhcps_handle_state state = dhcps->state;
if (state == DHCPS_HANDLE_DELETE_PENDING) {
free(dhcps);
return;
}
sys_timeout(DHCP_COARSE_TIMER_MSECS, dhcps_tmr, dhcps);
if (state != DHCPS_HANDLE_STARTED) {
return;
}
u8_t num_dhcps_pool = 0; u8_t num_dhcps_pool = 0;
list_node *pback_node = NULL; list_node *pback_node = NULL;
list_node *pnode = NULL; list_node *pnode = NULL;
struct dhcps_pool *pdhcps_pool = NULL; struct dhcps_pool *pdhcps_pool = NULL;
pnode = plist; pnode = dhcps->plist;
while (pnode != NULL) { while (pnode != NULL) {
pdhcps_pool = pnode->pnode; pdhcps_pool = pnode->pnode;
@@ -1267,7 +1318,7 @@ void dhcps_coarse_tmr(void)
if (pdhcps_pool->lease_timer == 0) { if (pdhcps_pool->lease_timer == 0) {
pback_node = pnode; pback_node = pnode;
pnode = pback_node->pnext; pnode = pback_node->pnext;
node_remove_from_list(&plist, pback_node); node_remove_from_list(&dhcps->plist, pback_node);
free(pback_node->pnode); free(pback_node->pnode);
pback_node->pnode = NULL; pback_node->pnode = NULL;
free(pback_node); free(pback_node);
@@ -1279,7 +1330,7 @@ void dhcps_coarse_tmr(void)
} }
if (num_dhcps_pool > MAX_STATION_NUM) { if (num_dhcps_pool > MAX_STATION_NUM) {
kill_oldest_dhcps_pool(); kill_oldest_dhcps_pool(dhcps);
} }
} }
@@ -1290,13 +1341,13 @@ void dhcps_coarse_tmr(void)
* ip -- The IP info * ip -- The IP info
* Returns : true or false * Returns : true or false
*******************************************************************************/ *******************************************************************************/
bool dhcp_search_ip_on_mac(u8_t *mac, ip4_addr_t *ip) bool dhcp_search_ip_on_mac(dhcps_t *dhcps, u8_t *mac, ip4_addr_t *ip)
{ {
struct dhcps_pool *pdhcps_pool = NULL; struct dhcps_pool *pdhcps_pool = NULL;
list_node *pback_node = NULL; list_node *pback_node = NULL;
bool ret = false; bool ret = false;
for (pback_node = plist; pback_node != NULL; pback_node = pback_node->pnext) { for (pback_node = dhcps->plist; pback_node != NULL; pback_node = pback_node->pnext) {
pdhcps_pool = pback_node->pnode; pdhcps_pool = pback_node->pnode;
if (memcmp(pdhcps_pool->mac, mac, sizeof(pdhcps_pool->mac)) == 0) { if (memcmp(pdhcps_pool->mac, mac, sizeof(pdhcps_pool->mac)) == 0) {
@@ -1316,12 +1367,12 @@ bool dhcp_search_ip_on_mac(u8_t *mac, ip4_addr_t *ip)
* Returns : none * Returns : none
*******************************************************************************/ *******************************************************************************/
void void
dhcps_dns_setserver(const ip_addr_t *dnsserver) dhcps_dns_setserver(dhcps_t *dhcps, const ip_addr_t *dnsserver)
{ {
if (dnsserver != NULL) { if (dnsserver != NULL) {
dns_server = *(ip_2_ip4(dnsserver)); dhcps->dns_server = *(ip_2_ip4(dnsserver));
} else { } else {
dns_server = *(ip_2_ip4(IP_ADDR_ANY)); dhcps->dns_server = *(ip_2_ip4(IP_ADDR_ANY));
} }
} }
@@ -1332,8 +1383,8 @@ dhcps_dns_setserver(const ip_addr_t *dnsserver)
* Returns : ip4_addr_t * Returns : ip4_addr_t
*******************************************************************************/ *******************************************************************************/
ip4_addr_t ip4_addr_t
dhcps_dns_getserver(void) dhcps_dns_getserver(dhcps_t *dhcps)
{ {
return dns_server; return dhcps->dns_server;
} }
#endif // ESP_DHCP #endif // ESP_DHCP

21
components/lwip/include/apps/dhcpserver/dhcpserver.h
View File

@@ -93,14 +93,19 @@ static inline bool dhcps_dns_enabled (dhcps_offer_t offer)
return (offer & OFFER_DNS) != 0; return (offer & OFFER_DNS) != 0;
} }
void dhcps_start(struct netif *netif, ip4_addr_t ip); typedef struct dhcps_t dhcps_t;
void dhcps_stop(struct netif *netif);
void *dhcps_option_info(u8_t op_id, u32_t opt_len); dhcps_t *dhcps_new(void);
void dhcps_set_option_info(u8_t op_id, void *opt_info, u32_t opt_len); void dhcps_delete(dhcps_t *dhcps);
bool dhcp_search_ip_on_mac(u8_t *mac, ip4_addr_t *ip);
void dhcps_dns_setserver(const ip_addr_t *dnsserver); void dhcps_start(dhcps_t *dhcps, struct netif *netif, ip4_addr_t ip);
ip4_addr_t dhcps_dns_getserver(void); void dhcps_stop(dhcps_t *dhcps, struct netif *netif);
void dhcps_set_new_lease_cb(dhcps_cb_t cb); void *dhcps_option_info(dhcps_t *dhcps, u8_t op_id, u32_t opt_len);
void dhcps_set_option_info(dhcps_t *dhcps, u8_t op_id, void *opt_info, u32_t opt_len);
bool dhcp_search_ip_on_mac(dhcps_t *dhcps, u8_t *mac, ip4_addr_t *ip);
void dhcps_dns_setserver(dhcps_t *dhcps, const ip_addr_t *dnsserver);
ip4_addr_t dhcps_dns_getserver(dhcps_t *dhcps);
void dhcps_set_new_lease_cb(dhcps_t *dhcps, dhcps_cb_t cb);
#ifdef __cplusplus #ifdef __cplusplus
} }

2
components/lwip/port/esp32/include/lwipopts.h
View File

@@ -1344,7 +1344,7 @@
*/ */
#ifdef CONFIG_LWIP_DHCPS #ifdef CONFIG_LWIP_DHCPS
#define ESP_DHCPS 1 #define ESP_DHCPS 1
#define ESP_DHCPS_TIMER 1 #define ESP_DHCPS_TIMER 0
#else #else
#define ESP_DHCPS 0 #define ESP_DHCPS 0
#define ESP_DHCPS_TIMER 0 #define ESP_DHCPS_TIMER 0

2
tools/ci/check_copyright_ignore.txt
View File

@@ -484,13 +484,11 @@ components/esp_local_ctrl/src/esp_local_ctrl_transport_ble.c
components/esp_local_ctrl/src/esp_local_ctrl_transport_httpd.c components/esp_local_ctrl/src/esp_local_ctrl_transport_httpd.c
components/esp_netif/include/esp_netif_ppp.h components/esp_netif/include/esp_netif_ppp.h
components/esp_netif/include/esp_netif_slip.h components/esp_netif/include/esp_netif_slip.h
components/esp_netif/include/esp_netif_sta_list.h
components/esp_netif/loopback/esp_netif_loopback.c components/esp_netif/loopback/esp_netif_loopback.c
components/esp_netif/lwip/esp_netif_lwip_defaults.c components/esp_netif/lwip/esp_netif_lwip_defaults.c
components/esp_netif/lwip/esp_netif_lwip_ppp.h components/esp_netif/lwip/esp_netif_lwip_ppp.h
components/esp_netif/lwip/esp_netif_lwip_slip.c components/esp_netif/lwip/esp_netif_lwip_slip.c
components/esp_netif/lwip/esp_netif_lwip_slip.h components/esp_netif/lwip/esp_netif_lwip_slip.h
components/esp_netif/lwip/esp_netif_sta_list.c
components/esp_netif/private_include/esp_netif_private.h components/esp_netif/private_include/esp_netif_private.h
components/esp_netif/test/test_esp_netif.c components/esp_netif/test/test_esp_netif.c
components/esp_netif/test_apps/component_ut_test.py components/esp_netif/test_apps/component_ut_test.py