tcpip_adapter: typedef clean up

components/esp32/event.c

@@ -80,16 +80,16 @@ static esp_err_t system_event_sta_gotip_default(system_event_t *event)
     WIFI_API_CALL_CHECK("esp_wifi_set_sta_ip", esp_wifi_set_sta_ip(), ESP_OK);
 
     printf("ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR "\n",
-            IP2STR(&event->event_info.got_ip.ip),
-            IP2STR(&event->event_info.got_ip.netmask),
-            IP2STR(&event->event_info.got_ip.gw));
+            IP2STR(&event->event_info.got_ip.ip_info.ip),
+            IP2STR(&event->event_info.got_ip.ip_info.netmask),
+            IP2STR(&event->event_info.got_ip.ip_info.gw));
 
     return ESP_OK;
 }
 
 esp_err_t system_event_ap_start_handle_default(system_event_t *event)
 {
-    struct ip_info ap_ip;
+    tcpip_adapter_ip_info_t ap_ip;
     uint8_t ap_mac[6];
 
     WIFI_API_CALL_CHECK("esp_wifi_reg_rxcb", esp_wifi_reg_rxcb(WIFI_IF_AP, (wifi_rxcb_t)tcpip_adapter_ap_input), ESP_OK);
@@ -112,7 +112,7 @@ esp_err_t system_event_ap_stop_handle_default(system_event_t *event)
 
 esp_err_t system_event_sta_start_handle_default(system_event_t *event)
 {
-    struct ip_info sta_ip;
+    tcpip_adapter_ip_info_t sta_ip;
     uint8_t sta_mac[6];
 
     WIFI_API_CALL_CHECK("esp_wifi_mac_get",  esp_wifi_get_mac(WIFI_IF_STA, sta_mac), ESP_OK);
@@ -142,16 +142,14 @@ esp_err_t system_event_sta_connected_handle_default(system_event_t *event)
     if (status == TCPIP_ADAPTER_DHCP_INIT) {
         tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
     } else if (status == TCPIP_ADAPTER_DHCP_STOPPED) {
-        struct ip_info ip_info;
+        tcpip_adapter_ip_info_t sta_ip;
         system_event_t evt;
 
-        tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip_info);
+        tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &sta_ip);
 
         //notify event
         evt.event_id = SYSTEM_EVENT_STA_GOTIP;
-        memcpy(&evt.event_info.got_ip.ip, &ip_info.ip, sizeof(evt.event_info.got_ip.ip));
-        memcpy(&evt.event_info.got_ip.netmask, &ip_info.netmask, sizeof(evt.event_info.got_ip.netmask));
-        memcpy(&evt.event_info.got_ip.gw, &ip_info.gw, sizeof(evt.event_info.got_ip.gw));
+        memcpy(&evt.event_info.got_ip.ip_info, &sta_ip, sizeof(tcpip_adapter_ip_info_t));
 
         esp_event_send(&evt);
     }
@@ -233,7 +231,7 @@ static esp_err_t esp_system_event_debug(system_event_t *event)
         }
         case SYSTEM_EVENT_STA_GOTIP:
         {
-            system_event_sta_gotip_t *got_ip;
+            system_event_sta_got_ip_t *got_ip;
             got_ip = &event->event_info.got_ip;
             WIFI_DEBUG("SYSTEM_EVENT_STA_GOTIP\n");
             break;

components/esp32/include/esp_event.h

@@ -21,6 +21,8 @@
 #include "esp_err.h"
 #include "esp_wifi.h"
 
+#include "tcpip_adapter.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -42,10 +44,6 @@ typedef enum {
     SYSTEM_EVENT_MAX
 } system_event_id_t;
 
-typedef struct {
-    uint32_t addr;
-} esp_ip_addr_t;
-
 typedef struct {
     uint32_t status;          /**< status of scanning APs*/
     uint8_t  number;
@@ -73,10 +71,8 @@ typedef struct {
 } system_event_sta_authmode_change_t;
 
 typedef struct {
-    esp_ip_addr_t ip;
-    esp_ip_addr_t netmask;
-    esp_ip_addr_t gw;
-} system_event_sta_gotip_t;
+    tcpip_adapter_ip_info_t ip_info;
+} system_event_sta_got_ip_t;
 
 typedef struct {
     uint8_t mac[6];           /**< MAC address of the station connected to ESP32 soft-AP */
@@ -98,7 +94,7 @@ typedef union {
     system_event_sta_disconnected_t            disconnected;       /**< ESP32 station disconnected to AP */
     system_event_sta_scan_done_t               scan_done;          /**< ESP32 station scan (APs) done */
     system_event_sta_authmode_change_t         auth_change;        /**< the auth mode of AP ESP32 station connected to changed */
-    system_event_sta_gotip_t                   got_ip;
+    system_event_sta_got_ip_t                  got_ip;
     system_event_ap_staconnected_t             sta_connected;      /**< a station connected to ESP32 soft-AP */
     system_event_ap_stadisconnected_t          sta_disconnected;   /**< a station disconnected to ESP32 soft-AP */
     system_event_ap_probe_req_rx_t             ap_probereqrecved;  /**< ESP32 softAP receive probe request packet */

components/lwip/apps/dhcpserver.c

@@ -266,9 +266,9 @@ static u8_t *add_offer_options(u8_t *optptr)
     *optptr++ = ip4_addr4(&ipadd);
 
     if (dhcps_router_enabled(dhcps_offer)) {
-        struct ip_info if_ip;
+        tcpip_adapter_ip_info_t if_ip;
         //bzero(&if_ip, sizeof(struct ip_info));
-        memset(&if_ip , 0x00, sizeof(struct ip_info));
+        memset(&if_ip , 0x00, sizeof(tcpip_adapter_ip_info_t));
 
         tcpip_adapter_get_ip_info(WIFI_IF_AP, &if_ip);
 
@@ -1024,18 +1024,17 @@ static void dhcps_poll_set(u32_t ip)
  *              : info  -- The current ip info
  * Returns      : none
 *******************************************************************************/
-void dhcps_start(struct netif *netif, struct ip_info *info)
+void dhcps_start(struct netif *netif, ip4_addr_t ip)
 {
     struct netif *apnetif = netif;
 
-
     if (apnetif->dhcps_pcb != NULL) {
         udp_remove(apnetif->dhcps_pcb);
     }
 
     pcb_dhcps = udp_new();
 
-    if (pcb_dhcps == NULL || info == NULL) {
+    if (pcb_dhcps == NULL || ip4_addr_isany_val(ip)) {
         printf("dhcps_start(): could not obtain pcb\n");
     }
 
@@ -1043,7 +1042,7 @@ void dhcps_start(struct netif *netif, struct ip_info *info)
 
     IP4_ADDR(&broadcast_dhcps, 255, 255, 255, 255);
 
-    server_address = info->ip;
+    server_address.addr = ip.addr;
     dhcps_poll_set(server_address.addr);
 
     client_address_plus.addr = dhcps_poll.start_ip.addr;

components/lwip/include/lwip/apps/dhcpserver.h

@@ -17,17 +17,6 @@
 #include "lwip/ip_addr.h"
 //#include "esp_common.h"
 #define USE_DNS
-/* Here for now until needed in other places in lwIP */
-#ifndef isprint
-#define in_range(c, lo, up)  ((u8_t)c >= lo && (u8_t)c <= up)
-#define isprint(c)           in_range(c, 0x20, 0x7f)
-#define isdigit(c)           in_range(c, '0', '9')
-#define isxdigit(c)          (isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))
-#define islower(c)           in_range(c, 'a', 'z')
-#define isspace(c)           (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v')
-#endif
-
-#ifdef LWIP_ESP8266
 
 typedef struct dhcps_state{
         s16_t state;
@@ -164,6 +153,12 @@ typedef enum
     CLASSLESS_ROUTE = 121,
 } dhcp_msg_option;
 
+/*   Defined in esp_misc.h */
+typedef struct {
+	bool enable;
+	ip4_addr_t start_ip;
+	ip4_addr_t end_ip;
+} dhcps_lease_t;
 
 enum dhcps_offer_option{
 	OFFER_START = 0x00,
@@ -188,22 +183,18 @@ typedef struct _list_node{
 typedef u32_t dhcps_time_t;
 typedef u8_t dhcps_offer_t;
 
-/* struct dhcps_lease defined in tcpip_adapter.h */
-typedef struct dhcps_lease dhcps_lease_t;
-
-typedef struct _dhcps_options{
+typedef struct {
 	dhcps_offer_t dhcps_offer;
 	dhcps_time_t  dhcps_time;
 	dhcps_lease_t dhcps_poll;
-}dhcps_options_t;
+} dhcps_options_t;
 
-#define   dhcps_router_enabled(offer)	((offer & OFFER_ROUTER) != 0)
-void dhcps_start(struct netif *netif, struct ip_info *info);
+#define dhcps_router_enabled(offer) ((offer & OFFER_ROUTER) != 0)
+
+void dhcps_start(struct netif *netif, ip4_addr_t ip);
 void dhcps_stop(struct netif *netif);
 void *dhcps_option_info(u8_t op_id, u32_t opt_len);
 bool dhcp_search_ip_on_mac(u8_t *mac, ip4_addr_t *ip);
 
 #endif
 
-#endif
-

components/tcpip_adapter/include/tcpip_adapter.h

@@ -26,6 +26,7 @@
 
 #if CONFIG_TCPIP_LWIP
 #include "lwip/ip_addr.h"
+#include "apps/dhcpserver.h"
 
 #define IP2STR(ipaddr) ip4_addr1_16(ipaddr), \
     ip4_addr2_16(ipaddr), \
@@ -34,22 +35,13 @@
 
 #define IPSTR "%d.%d.%d.%d"
 
-struct ip_info {
+typedef struct {
     ip4_addr_t ip;
     ip4_addr_t netmask;
     ip4_addr_t gw;
-};
-
-/* Also used by dhcpserver.h  */
-struct dhcps_lease {
-    bool enable;
-    ip4_addr_t start_ip;
-    ip4_addr_t end_ip;
-};
+} tcpip_adapter_ip_info_t;
 
-typedef struct dhcps_lease tcpip_adapter_dhcps_lease;
-
-#endif
+typedef dhcps_lease_t tcpip_adapter_dhcps_lease_t;
 
 #if CONFIG_DHCP_STA_LIST 
 struct station_list {
@@ -59,6 +51,8 @@ struct station_list {
 };
 #endif
 
+#endif
+
 #define ESP_ERR_TCPIP_ADAPTER_BASE      0x5000      // base should be moved to esp_err.h
 
 #define ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS        ESP_ERR_TCPIP_ADAPTER_BASE + 0x00
@@ -83,24 +77,23 @@ typedef enum {
     TCPIP_ADAPTER_DHCP_STATUS_MAX
 } tcpip_adapter_dhcp_status_t;
 
-/*op*/
 typedef enum{
     TCPIP_ADAPTER_OP_START = 0,
     TCPIP_ADAPTER_OP_SET,
     TCPIP_ADAPTER_OP_GET,
     TCPIP_ADAPTER_OP_MAX
-} tcpip_adapter_option_mode;
+} tcpip_adapter_option_mode_t;
 
 typedef enum{
-    TCPIP_ADAPTER_ROUTER_SOLICITATION_ADDRESS = 32,
-    TCPIP_ADAPTER_REQUESTED_IP_ADDRESS = 50,
-    TCPIP_ADAPTER_IP_ADDRESS_LEASE_TIME = 51,
-    TCPIP_ADAPTER_IP_REQUEST_RETRY_TIME = 52,
-} tcpip_adapter_option_id;
+    TCPIP_ADAPTER_ROUTER_SOLICITATION_ADDRESS   = 32,
+    TCPIP_ADAPTER_REQUESTED_IP_ADDRESS          = 50,
+    TCPIP_ADAPTER_IP_ADDRESS_LEASE_TIME         = 51,
+    TCPIP_ADAPTER_IP_REQUEST_RETRY_TIME         = 52,
+} tcpip_adapter_option_id_t;
 
 void tcpip_adapter_init(void);
 
-esp_err_t tcpip_adapter_start(tcpip_adapter_if_t tcpip_if, uint8_t *mac, struct ip_info *info);
+esp_err_t tcpip_adapter_start(tcpip_adapter_if_t tcpip_if, uint8_t *mac, tcpip_adapter_ip_info_t *ip_info);
 
 esp_err_t tcpip_adapter_stop(tcpip_adapter_if_t tcpip_if);
 
@@ -108,9 +101,9 @@ esp_err_t tcpip_adapter_up(tcpip_adapter_if_t tcpip_if);
 
 esp_err_t tcpip_adapter_down(tcpip_adapter_if_t tcpip_if);
 
-esp_err_t tcpip_adapter_get_ip_info(tcpip_adapter_if_t tcpip_if, struct ip_info *if_ip);
+esp_err_t tcpip_adapter_get_ip_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_ip_info_t *ip_info);
 
-esp_err_t tcpip_adapter_set_ip_info(tcpip_adapter_if_t tcpip_if, struct ip_info *if_ip);
+esp_err_t tcpip_adapter_set_ip_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_ip_info_t *ip_info);
 
 #if 0
 esp_err_t tcpip_adapter_get_mac(tcpip_adapter_if_t tcpip_if, uint8_t *mac);
@@ -119,23 +112,17 @@ esp_err_t tcpip_adapter_set_mac(tcpip_adapter_if_t tcpip_if, uint8_t *mac);
 #endif
 
 esp_err_t tcpip_adapter_dhcps_get_status(tcpip_adapter_if_t tcpip_if, tcpip_adapter_dhcp_status_t *status);
-esp_err_t tcpip_adapter_dhcps_option(tcpip_adapter_option_mode opt_op, tcpip_adapter_option_id opt_id, void *opt_val, uint32_t opt_len);
+esp_err_t tcpip_adapter_dhcps_option(tcpip_adapter_option_mode_t opt_op, tcpip_adapter_option_id_t opt_id, void *opt_val, uint32_t opt_len);
 esp_err_t tcpip_adapter_dhcps_start(tcpip_adapter_if_t tcpip_if);
 esp_err_t tcpip_adapter_dhcps_stop(tcpip_adapter_if_t tcpip_if);
 
 esp_err_t tcpip_adapter_dhcpc_get_status(tcpip_adapter_if_t tcpip_if, tcpip_adapter_dhcp_status_t *status);
-esp_err_t tcpip_adapter_dhcpc_option(tcpip_adapter_option_mode opt_op, tcpip_adapter_option_id opt_id, void *opt_val, uint32_t opt_len);
+esp_err_t tcpip_adapter_dhcpc_option(tcpip_adapter_option_mode_t opt_op, tcpip_adapter_option_id_t opt_id, void *opt_val, uint32_t opt_len);
 esp_err_t tcpip_adapter_dhcpc_start(tcpip_adapter_if_t tcpip_if);
 esp_err_t tcpip_adapter_dhcpc_stop(tcpip_adapter_if_t tcpip_if);
 
-esp_err_t tcpip_adapter_sta_input(void *buffer, uint16_t len, void* eb);
-esp_err_t tcpip_adapter_ap_input(void *buffer, uint16_t len, void* eb);
-
-#if 0
-//esp_err_t tcpip_dep_input(wifi_interface_t wifi_if, void *buffer, uint16 len);
-
-esp_err_t tcpip_adapter_output(tcpip_adapter_if_t tcpip_if, void *buffer, uint16_t len);
-#endif
+esp_err_t tcpip_adapter_sta_input(void *buffer, uint16_t len, void *eb);
+esp_err_t tcpip_adapter_ap_input(void *buffer, uint16_t len, void *eb);
 
 wifi_interface_t tcpip_adapter_get_wifi_if(void *dev);
 

components/tcpip_adapter/tcpip_adapter_lwip.c

@@ -31,7 +31,7 @@
 #include "esp_event.h"
 
 static struct netif *esp_netif[TCPIP_ADAPTER_IF_MAX];
-static struct ip_info esp_ip[TCPIP_ADAPTER_IF_MAX];
+static tcpip_adapter_ip_info_t esp_ip[TCPIP_ADAPTER_IF_MAX];
 
 static tcpip_adapter_dhcp_status_t dhcps_status = TCPIP_ADAPTER_DHCP_INIT;
 static tcpip_adapter_dhcp_status_t dhcpc_status = TCPIP_ADAPTER_DHCP_INIT;
@@ -53,9 +53,9 @@ void tcpip_adapter_init(void)
     }
 }
 
-esp_err_t tcpip_adapter_start(tcpip_adapter_if_t tcpip_if, uint8_t *mac, struct ip_info *info)
+esp_err_t tcpip_adapter_start(tcpip_adapter_if_t tcpip_if, uint8_t *mac, tcpip_adapter_ip_info_t *ip_info)
 {
-    if (tcpip_if >= TCPIP_ADAPTER_IF_MAX || mac == NULL || info == NULL) {
+    if (tcpip_if >= TCPIP_ADAPTER_IF_MAX || mac == NULL || ip_info == NULL) {
         return ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS;
     }
 
@@ -65,17 +65,17 @@ esp_err_t tcpip_adapter_start(tcpip_adapter_if_t tcpip_if, uint8_t *mac, struct
             return ESP_ERR_NO_MEM;
         }
         memcpy(esp_netif[tcpip_if]->hwaddr, mac, NETIF_MAX_HWADDR_LEN);
-        netif_add(esp_netif[tcpip_if], &info->ip, &info->netmask, &info->gw, NULL, wlanif_init, tcpip_input);
+        netif_add(esp_netif[tcpip_if], &ip_info->ip, &ip_info->netmask, &ip_info->gw, NULL, wlanif_init, tcpip_input);
     }
 
     if (tcpip_if == TCPIP_ADAPTER_IF_AP) {
         netif_set_up(esp_netif[tcpip_if]);
 
         if (dhcps_status == TCPIP_ADAPTER_DHCP_INIT) {
-            dhcps_start(esp_netif[tcpip_if], info);
+            dhcps_start(esp_netif[tcpip_if], ip_info->ip);
 
             printf("dhcp server start:(ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR ")\n",
-                    IP2STR(&info->ip), IP2STR(&info->netmask), IP2STR(&info->gw));
+                    IP2STR(&ip_info->ip), IP2STR(&ip_info->netmask), IP2STR(&ip_info->gw));
 
             dhcps_status = TCPIP_ADAPTER_DHCP_STARTED;
         }
@@ -164,37 +164,37 @@ esp_err_t tcpip_adapter_down(tcpip_adapter_if_t tcpip_if)
     return ESP_OK;
 }
 
-esp_err_t tcpip_adapter_get_ip_info(tcpip_adapter_if_t tcpip_if, struct ip_info *if_ip)
+esp_err_t tcpip_adapter_get_ip_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_ip_info_t *ip_info)
 {
     struct netif *p_netif;
 
-    if (tcpip_if >= TCPIP_ADAPTER_IF_MAX || if_ip == NULL) {
+    if (tcpip_if >= TCPIP_ADAPTER_IF_MAX || ip_info == NULL) {
         return ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS;
     }
 
     p_netif = esp_netif[tcpip_if];
 
     if (p_netif != NULL && netif_is_up(p_netif)) {
-        ip4_addr_set(&if_ip->ip, ip_2_ip4(&p_netif->ip_addr));
-        ip4_addr_set(&if_ip->netmask, ip_2_ip4(&p_netif->netmask));
-        ip4_addr_set(&if_ip->gw, ip_2_ip4(&p_netif->gw));
+        ip4_addr_set(&ip_info->ip, ip_2_ip4(&p_netif->ip_addr));
+        ip4_addr_set(&ip_info->netmask, ip_2_ip4(&p_netif->netmask));
+        ip4_addr_set(&ip_info->gw, ip_2_ip4(&p_netif->gw));
 
         return ESP_OK;
     }
 
-    ip4_addr_copy(if_ip->ip, esp_ip[tcpip_if].ip);
-    ip4_addr_copy(if_ip->gw, esp_ip[tcpip_if].gw);
-    ip4_addr_copy(if_ip->netmask, esp_ip[tcpip_if].netmask);
+    ip4_addr_copy(ip_info->ip, esp_ip[tcpip_if].ip);
+    ip4_addr_copy(ip_info->gw, esp_ip[tcpip_if].gw);
+    ip4_addr_copy(ip_info->netmask, esp_ip[tcpip_if].netmask);
 
     return ESP_OK;
 }
 
-esp_err_t tcpip_adapter_set_ip_info(tcpip_adapter_if_t tcpip_if, struct ip_info *if_ip)
+esp_err_t tcpip_adapter_set_ip_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_ip_info_t *ip_info)
 {
     struct netif *p_netif;
     tcpip_adapter_dhcp_status_t status;
 
-    if (tcpip_if >= TCPIP_ADAPTER_IF_MAX || if_ip == NULL) {
+    if (tcpip_if >= TCPIP_ADAPTER_IF_MAX || ip_info == NULL) {
         return ESP_ERR_TCPIP_ADAPTER_INVALID_PARAMS;
     }
 
@@ -212,14 +212,14 @@ esp_err_t tcpip_adapter_set_ip_info(tcpip_adapter_if_t tcpip_if, struct ip_info
         }
     }
 
-    ip4_addr_copy(esp_ip[tcpip_if].ip, if_ip->ip);
-    ip4_addr_copy(esp_ip[tcpip_if].gw, if_ip->gw);
-    ip4_addr_copy(esp_ip[tcpip_if].netmask, if_ip->netmask);
+    ip4_addr_copy(esp_ip[tcpip_if].ip, ip_info->ip);
+    ip4_addr_copy(esp_ip[tcpip_if].gw, ip_info->gw);
+    ip4_addr_copy(esp_ip[tcpip_if].netmask, ip_info->netmask);
 
     p_netif = esp_netif[tcpip_if];
 
     if (p_netif != NULL && netif_is_up(p_netif)) {
-        netif_set_addr(p_netif, &if_ip->ip, &if_ip->netmask, &if_ip->gw);
+        netif_set_addr(p_netif, &ip_info->ip, &ip_info->netmask, &ip_info->gw);
     }
 
     return ESP_OK;
@@ -265,7 +265,7 @@ esp_err_t tcpip_adapter_set_mac(tcpip_adapter_if_t tcpip_if, uint8_t mac[6])
 }
 #endif
 
-esp_err_t tcpip_adapter_dhcps_option(tcpip_adapter_option_mode opt_op, tcpip_adapter_option_id opt_id, void *opt_val, uint32_t opt_len)
+esp_err_t tcpip_adapter_dhcps_option(tcpip_adapter_option_mode_t opt_op, tcpip_adapter_option_id_t opt_id, void *opt_val, uint32_t opt_len)
 {
     void *opt_info = dhcps_option_info(opt_id, opt_len);
 
@@ -308,18 +308,18 @@ esp_err_t tcpip_adapter_dhcps_option(tcpip_adapter_option_mode opt_op, tcpip_ada
                 if (*(uint32_t*)opt_val != 0)
                     *(uint32_t*)opt_info = *(uint32_t*)opt_val;
                 else
-                    *(uint32_t*)opt_info = DHCPS_LEASE_TIME_DEF;    
+                    *(uint32_t*)opt_info = DHCPS_LEASE_TIME_DEF;
                 break;
             }
             case REQUESTED_IP_ADDRESS:
             {
-                struct ip_info info;
+                tcpip_adapter_ip_info_t info;
                 uint32_t softap_ip = 0;
                 uint32_t start_ip = 0;
                 uint32_t end_ip = 0;
-                struct dhcps_lease *poll = opt_val;
+                dhcps_lease_t *poll = opt_val;
 
-                memset(&info, 0x00, sizeof(struct ip_info));
+                memset(&info, 0x00, sizeof(tcpip_adapter_ip_info_t));
                 tcpip_adapter_get_ip_info(WIFI_IF_AP, &info);
                 softap_ip = htonl(info.ip.addr);
                 start_ip = htonl(poll->start_ip.addr);
@@ -377,9 +377,9 @@ esp_err_t tcpip_adapter_dhcps_start(tcpip_adapter_if_t tcpip_if)
         struct netif *p_netif = esp_netif[tcpip_if];
 
         if (p_netif != NULL && netif_is_up(p_netif)) {
-            struct ip_info default_ip;
+            tcpip_adapter_ip_info_t default_ip;
             tcpip_adapter_get_ip_info(WIFI_IF_AP, &default_ip);
-            dhcps_start(p_netif, &default_ip);
+            dhcps_start(p_netif, default_ip.ip);
             dhcps_status = TCPIP_ADAPTER_DHCP_STARTED;
             TCPIP_ADAPTER_DEBUG("dhcp server start successfully\n");
             return ESP_OK;
@@ -421,7 +421,7 @@ esp_err_t tcpip_adapter_dhcps_stop(tcpip_adapter_if_t tcpip_if)
     return ESP_OK;
 }
 
-esp_err_t tcpip_adapter_dhcpc_option(tcpip_adapter_option_mode opt_op, tcpip_adapter_option_id opt_id, void *opt_val, uint32_t opt_len)
+esp_err_t tcpip_adapter_dhcpc_option(tcpip_adapter_option_mode_t opt_op, tcpip_adapter_option_id_t opt_id, void *opt_val, uint32_t opt_len)
 {
     // TODO: when dhcp request timeout,change the retry count
     return ESP_OK;
@@ -430,7 +430,7 @@ esp_err_t tcpip_adapter_dhcpc_option(tcpip_adapter_option_mode opt_op, tcpip_ada
 static void tcpip_adapter_dhcpc_cb(void)
 {
     struct netif *netif = esp_netif[TCPIP_ADAPTER_IF_STA];
-    struct ip_info *ip_info = &esp_ip[TCPIP_ADAPTER_IF_STA];
+    tcpip_adapter_ip_info_t *ip_info = &esp_ip[TCPIP_ADAPTER_IF_STA];
     system_event_t evt;
 
     if (!netif) {
@@ -450,9 +450,7 @@ static void tcpip_adapter_dhcpc_cb(void)
 
             //notify event
             evt.event_id = SYSTEM_EVENT_STA_GOTIP;
-            memcpy(&evt.event_info.got_ip.ip, &ip_info->ip, sizeof(evt.event_info.got_ip.ip));
-            memcpy(&evt.event_info.got_ip.netmask, &ip_info->netmask, sizeof(evt.event_info.got_ip.netmask));
-            memcpy(&evt.event_info.got_ip.gw, &ip_info->gw, sizeof(evt.event_info.got_ip.gw));
+            memcpy(&evt.event_info.got_ip.ip_info, ip_info, sizeof(tcpip_adapter_ip_info_t));
 
             esp_event_send(&evt);
         } else {
@@ -541,13 +539,13 @@ esp_err_t tcpip_adapter_dhcpc_stop(tcpip_adapter_if_t tcpip_if)
     return ESP_OK;
 }
 
-esp_err_t tcpip_adapter_sta_input(void *buffer, uint16_t len, void* eb)
+esp_err_t tcpip_adapter_sta_input(void *buffer, uint16_t len, void *eb)
 {
     wlanif_input(esp_netif[TCPIP_ADAPTER_IF_STA], buffer, len, eb);
     return ESP_OK;
 }
 
-esp_err_t tcpip_adapter_ap_input(void *buffer, uint16_t len, void* eb)
+esp_err_t tcpip_adapter_ap_input(void *buffer, uint16_t len, void *eb)
 {
     wlanif_input(esp_netif[TCPIP_ADAPTER_IF_AP], buffer, len, eb);
     return ESP_OK;