1 /*
2  * SPDX-FileCopyrightText: 2019-2023 Espressif Systems (Shanghai) CO LTD
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  */
6 #include "sdkconfig.h"
7 #include "esp_wifi.h"
8 #include "esp_netif.h"
9 #include "esp_log.h"
10 #include "esp_private/wifi.h"
11 #include "esp_wifi_netif.h"
12 #include <string.h>
13 #include <inttypes.h>
14 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
15 #include "apps_private/wifi_apps_private.h"
16 #endif
17 
18 //
19 //  Purpose of this module is to provide basic wifi initialization setup for
20 //  default station and AP and to register default handles for these interfaces
21 //
22 static const char* TAG = "wifi_init_default";
23 
24 static esp_netif_t *s_wifi_netifs[MAX_WIFI_IFS] = { NULL };
25 static bool wifi_default_handlers_set = false;
26 
27 static esp_err_t disconnect_and_destroy(esp_netif_t* esp_netif);
28 
29 //
30 // Default event handlers
31 //
32 
33 /**
34  * @brief Wifi start action when station or AP get started
35  */
wifi_start(void * esp_netif,esp_event_base_t base,int32_t event_id,void * data)36 static void wifi_start(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data)
37 {
38     uint8_t mac[6];
39     esp_err_t ret;
40 
41     ESP_LOGD(TAG, "%s esp-netif:%p event-id%" PRId32 "", __func__, esp_netif, event_id);
42 
43     wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif);
44 
45     if ((ret = esp_wifi_get_if_mac(driver, mac)) != ESP_OK) {
46         ESP_LOGE(TAG, "esp_wifi_get_mac failed with %d", ret);
47         return;
48     }
49     ESP_LOGD(TAG, "WIFI mac address: %x %x %x %x %x %x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
50 
51     if (esp_wifi_is_if_ready_when_started(driver)) {
52         if ((ret = esp_wifi_register_if_rxcb(driver,  esp_netif_receive, esp_netif)) != ESP_OK) {
53             ESP_LOGE(TAG, "esp_wifi_register_if_rxcb for if=%p failed with %d", driver, ret);
54             return;
55         }
56     }
57 
58     if ((ret = esp_wifi_internal_reg_netstack_buf_cb(esp_netif_netstack_buf_ref, esp_netif_netstack_buf_free)) != ESP_OK) {
59         ESP_LOGE(TAG, "netstack cb reg failed with %d", ret);
60         return;
61     }
62     esp_netif_set_mac(esp_netif, mac);
63     esp_netif_action_start(esp_netif, base, event_id, data);
64 }
65 
66 /**
67  * @brief Wifi default handlers for specific events for station and APs
68  */
69 
wifi_default_action_sta_start(void * arg,esp_event_base_t base,int32_t event_id,void * data)70 static void wifi_default_action_sta_start(void *arg, esp_event_base_t base, int32_t event_id, void *data)
71 {
72     if (s_wifi_netifs[WIFI_IF_STA] != NULL) {
73         wifi_start(s_wifi_netifs[WIFI_IF_STA], base, event_id, data);
74     }
75 }
76 
wifi_default_action_sta_stop(void * arg,esp_event_base_t base,int32_t event_id,void * data)77 static void wifi_default_action_sta_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data)
78 {
79     if (s_wifi_netifs[WIFI_IF_STA] != NULL) {
80         esp_netif_action_stop(s_wifi_netifs[WIFI_IF_STA], base, event_id, data);
81     }
82 }
83 
wifi_default_action_sta_connected(void * arg,esp_event_base_t base,int32_t event_id,void * data)84 static void wifi_default_action_sta_connected(void *arg, esp_event_base_t base, int32_t event_id, void *data)
85 {
86     if (s_wifi_netifs[WIFI_IF_STA] != NULL) {
87         esp_err_t ret;
88         esp_netif_t *esp_netif = s_wifi_netifs[WIFI_IF_STA];
89         wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif);
90 
91         if (!esp_wifi_is_if_ready_when_started(driver)) {
92             // if interface not ready when started, rxcb to be registered on connection
93             if ((ret = esp_wifi_register_if_rxcb(driver,  esp_netif_receive, esp_netif)) != ESP_OK) {
94                 ESP_LOGE(TAG, "esp_wifi_register_if_rxcb for if=%p failed with %d", driver, ret);
95                 return;
96             }
97         }
98 
99         esp_netif_action_connected(s_wifi_netifs[WIFI_IF_STA], base, event_id, data);
100     }
101 }
102 
wifi_default_action_sta_disconnected(void * arg,esp_event_base_t base,int32_t event_id,void * data)103 static void wifi_default_action_sta_disconnected(void *arg, esp_event_base_t base, int32_t event_id, void *data)
104 {
105     if (s_wifi_netifs[WIFI_IF_STA] != NULL) {
106         esp_netif_action_disconnected(s_wifi_netifs[WIFI_IF_STA], base, event_id, data);
107     }
108 }
109 
110 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
wifi_default_action_ap_start(void * arg,esp_event_base_t base,int32_t event_id,void * data)111 static void wifi_default_action_ap_start(void *arg, esp_event_base_t base, int32_t event_id, void *data)
112 {
113     if (s_wifi_netifs[WIFI_IF_AP] != NULL) {
114         wifi_start(s_wifi_netifs[WIFI_IF_AP], base, event_id, data);
115     }
116 }
117 
wifi_default_action_ap_stop(void * arg,esp_event_base_t base,int32_t event_id,void * data)118 static void wifi_default_action_ap_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data)
119 {
120     if (s_wifi_netifs[WIFI_IF_AP] != NULL) {
121         esp_netif_action_stop(s_wifi_netifs[WIFI_IF_AP], base, event_id, data);
122     }
123 }
124 #endif
125 
wifi_default_action_sta_got_ip(void * arg,esp_event_base_t base,int32_t event_id,void * data)126 static void wifi_default_action_sta_got_ip(void *arg, esp_event_base_t base, int32_t event_id, void *data)
127 {
128     if (s_wifi_netifs[WIFI_IF_STA] != NULL) {
129         ESP_LOGD(TAG, "Got IP wifi default handler entered");
130         int ret = esp_wifi_internal_set_sta_ip();
131         if (ret != ESP_OK) {
132             ESP_LOGI(TAG, "esp_wifi_internal_set_sta_ip failed with %d", ret);
133         }
134         esp_netif_action_got_ip(s_wifi_netifs[WIFI_IF_STA], base, event_id, data);
135     }
136 }
137 
138 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
wifi_default_action_nan_started(void * arg,esp_event_base_t base,int32_t event_id,void * data)139 static void wifi_default_action_nan_started(void *arg, esp_event_base_t base, int32_t event_id, void *data)
140 {
141     if (s_wifi_netifs[WIFI_IF_NAN] != NULL) {
142         wifi_start(s_wifi_netifs[WIFI_IF_NAN], base, event_id, data);
143         esp_nan_action_start(s_wifi_netifs[WIFI_IF_NAN]);
144     }
145 }
146 
wifi_default_action_nan_stopped(void * arg,esp_event_base_t base,int32_t event_id,void * data)147 static void wifi_default_action_nan_stopped(void *arg, esp_event_base_t base, int32_t event_id, void *data)
148 {
149     if (s_wifi_netifs[WIFI_IF_NAN] != NULL) {
150         esp_netif_action_stop(s_wifi_netifs[WIFI_IF_NAN], base, event_id, data);
151         esp_nan_action_stop();
152     }
153 }
154 #endif
155 
156 /**
157  * @brief Clear default handlers
158  */
clear_default_wifi_handlers(void)159 static esp_err_t clear_default_wifi_handlers(void)
160 {
161     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_START, wifi_default_action_sta_start);
162     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_STOP, wifi_default_action_sta_stop);
163     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, wifi_default_action_sta_connected);
164     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, wifi_default_action_sta_disconnected);
165 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
166     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_START, wifi_default_action_ap_start);
167     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STOP, wifi_default_action_ap_stop);
168 #endif
169     esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_default_action_sta_got_ip);
170 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
171     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_NAN_STARTED, wifi_default_action_nan_started);
172     esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_NAN_STOPPED, wifi_default_action_nan_stopped);
173 #endif
174     esp_unregister_shutdown_handler((shutdown_handler_t)esp_wifi_stop);
175     wifi_default_handlers_set = false;
176     return ESP_OK;
177 }
178 
179 /**
180  * @brief Set default handlers
181  */
set_default_wifi_handlers(void)182 static esp_err_t set_default_wifi_handlers(void)
183 {
184     if (wifi_default_handlers_set) {
185         return ESP_OK;
186     }
187     esp_err_t err;
188 
189     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_START, wifi_default_action_sta_start, NULL);
190     if (err != ESP_OK) {
191         goto fail;
192     }
193 
194     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_STOP, wifi_default_action_sta_stop, NULL);
195     if (err != ESP_OK) {
196         goto fail;
197     }
198 
199     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, wifi_default_action_sta_connected, NULL);
200     if (err != ESP_OK) {
201         goto fail;
202     }
203 
204     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, wifi_default_action_sta_disconnected, NULL);
205     if (err != ESP_OK) {
206         goto fail;
207     }
208 
209 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
210     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_AP_START, wifi_default_action_ap_start, NULL);
211     if (err != ESP_OK) {
212         goto fail;
213     }
214 
215     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_AP_STOP, wifi_default_action_ap_stop, NULL);
216     if (err != ESP_OK) {
217         goto fail;
218     }
219 #endif
220 
221     err = esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_default_action_sta_got_ip, NULL);
222     if (err != ESP_OK) {
223         goto fail;
224     }
225 
226 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
227     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_NAN_STARTED, wifi_default_action_nan_started, NULL);
228     if (err != ESP_OK) {
229         goto fail;
230     }
231 
232     err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_NAN_STOPPED, wifi_default_action_nan_stopped, NULL);
233     if (err != ESP_OK) {
234         goto fail;
235     }
236 #endif
237 
238     err = esp_register_shutdown_handler((shutdown_handler_t)esp_wifi_stop);
239     if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
240         goto fail;
241     }
242     wifi_default_handlers_set = true;
243     return ESP_OK;
244 
245 fail:
246     clear_default_wifi_handlers();
247     return err;
248 }
249 
250 /**
251  * @brief Set default handlers for station (official API)
252  */
esp_wifi_set_default_wifi_sta_handlers(void)253 esp_err_t esp_wifi_set_default_wifi_sta_handlers(void)
254 {
255     return set_default_wifi_handlers();
256 }
257 
258 /**
259  * @brief Set default handlers for AP (official API)
260  */
esp_wifi_set_default_wifi_ap_handlers(void)261 esp_err_t esp_wifi_set_default_wifi_ap_handlers(void)
262 {
263     return set_default_wifi_handlers();
264 }
265 
266 /**
267  * @brief Set default handlers for NAN (official API)
268  */
esp_wifi_set_default_wifi_nan_handlers(void)269 esp_err_t esp_wifi_set_default_wifi_nan_handlers(void)
270 {
271     return set_default_wifi_handlers();
272 }
273 
274 /**
275  * @brief Clear default handlers and destroy appropriate objects (official API)
276  */
esp_wifi_clear_default_wifi_driver_and_handlers(void * esp_netif)277 esp_err_t esp_wifi_clear_default_wifi_driver_and_handlers(void *esp_netif)
278 {
279     int i;
280     for (i = 0; i< MAX_WIFI_IFS; ++i) {
281         // clear internal static pointers to netifs
282         if (s_wifi_netifs[i] == esp_netif) {
283             s_wifi_netifs[i] = NULL;
284         }
285     }
286     for (i = 0; i< MAX_WIFI_IFS; ++i) {
287         // check if all netifs are cleared to delete default handlers
288         if (s_wifi_netifs[i] != NULL) {
289             break;
290         }
291     }
292 
293     if (i == MAX_WIFI_IFS) { // if all wifi default netifs are null
294         ESP_LOGD(TAG, "Clearing wifi default handlers");
295         clear_default_wifi_handlers();
296     }
297     return disconnect_and_destroy(esp_netif);
298 }
299 
300 
301 //
302 // Object manipulation
303 //
304 
305 /**
306  * @brief Create and destroy objects
307  */
disconnect_and_destroy(esp_netif_t * esp_netif)308 static esp_err_t disconnect_and_destroy(esp_netif_t* esp_netif)
309 {
310     wifi_netif_driver_t driver = esp_netif_get_io_driver(esp_netif);
311     esp_netif_driver_ifconfig_t driver_ifconfig = { };
312     esp_err_t  ret = esp_netif_set_driver_config(esp_netif, &driver_ifconfig);
313     esp_wifi_destroy_if_driver(driver);
314     return ret;
315 }
316 
create_and_attach(wifi_interface_t wifi_if,esp_netif_t * esp_netif)317 static esp_err_t create_and_attach(wifi_interface_t wifi_if, esp_netif_t* esp_netif)
318 {
319     wifi_netif_driver_t driver = esp_wifi_create_if_driver(wifi_if);
320     if (driver == NULL) {
321         ESP_LOGE(TAG, "Failed to create wifi interface handle");
322         return ESP_FAIL;
323     }
324     return esp_netif_attach(esp_netif, driver);
325 }
326 
esp_netif_attach_wifi(esp_netif_t * esp_netif,wifi_interface_t wifi_if)327 static inline esp_err_t esp_netif_attach_wifi(esp_netif_t *esp_netif, wifi_interface_t wifi_if)
328 {
329     if (esp_netif == NULL || (wifi_if != WIFI_IF_STA
330 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
331     && wifi_if != WIFI_IF_AP
332 #endif
333 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
334     && wifi_if != WIFI_IF_NAN
335 #endif
336     )) {
337         return ESP_ERR_INVALID_ARG;
338     }
339     s_wifi_netifs[wifi_if] = esp_netif;
340     return create_and_attach(wifi_if, esp_netif);
341 }
342 
esp_netif_attach_wifi_station(esp_netif_t * esp_netif)343 esp_err_t esp_netif_attach_wifi_station(esp_netif_t *esp_netif)
344 {
345     return esp_netif_attach_wifi(esp_netif, WIFI_IF_STA);
346 }
347 
348 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
esp_netif_attach_wifi_ap(esp_netif_t * esp_netif)349 esp_err_t esp_netif_attach_wifi_ap(esp_netif_t *esp_netif)
350 {
351     return esp_netif_attach_wifi(esp_netif, WIFI_IF_AP);
352 }
353 #endif
354 
355 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
esp_netif_attach_wifi_nan(esp_netif_t * esp_netif)356 esp_err_t esp_netif_attach_wifi_nan(esp_netif_t *esp_netif)
357 {
358     return esp_netif_attach_wifi(esp_netif, WIFI_IF_NAN);
359 }
360 #endif
361 
362 
363 //
364 // Default WiFi creation from user code
365 //
366 
367 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
368 /**
369  * @brief User init default AP (official API)
370  */
esp_netif_create_default_wifi_ap(void)371 esp_netif_t* esp_netif_create_default_wifi_ap(void)
372 {
373     esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_AP();
374     esp_netif_t *netif = esp_netif_new(&cfg);
375     assert(netif);
376     ESP_ERROR_CHECK(esp_netif_attach_wifi_ap(netif));
377     ESP_ERROR_CHECK(esp_wifi_set_default_wifi_ap_handlers());
378     return netif;
379 }
380 #endif
381 
382 /**
383  * @brief User init default station (official API)
384  */
esp_netif_create_default_wifi_sta(void)385 esp_netif_t* esp_netif_create_default_wifi_sta(void)
386 {
387     esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_STA();
388     esp_netif_t *netif = esp_netif_new(&cfg);
389     assert(netif);
390     ESP_ERROR_CHECK(esp_netif_attach_wifi_station(netif));
391     ESP_ERROR_CHECK(esp_wifi_set_default_wifi_sta_handlers());
392     return netif;
393 }
394 
395 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
396 /**
397  * @brief User init default NAN (official API)
398  */
esp_netif_create_default_wifi_nan(void)399 esp_netif_t* esp_netif_create_default_wifi_nan(void)
400 {
401     esp_netif_config_t cfg = ESP_NETIF_DEFAULT_WIFI_NAN();
402     esp_netif_t *netif = esp_netif_new(&cfg);
403     assert(netif);
404     esp_netif_attach_wifi_nan(netif);
405     esp_wifi_set_default_wifi_nan_handlers();
406     return netif;
407 }
408 #endif
409 
410 /**
411  * @brief User init default wifi esp_netif object (official API)
412  */
esp_netif_destroy_default_wifi(void * esp_netif)413 void esp_netif_destroy_default_wifi(void *esp_netif)
414 {
415     if (esp_netif) {
416         esp_wifi_clear_default_wifi_driver_and_handlers(esp_netif);
417     }
418     esp_netif_destroy(esp_netif);
419 }
420 
421 /**
422  * @brief User init custom wifi interface
423  */
esp_netif_create_wifi(wifi_interface_t wifi_if,const esp_netif_inherent_config_t * esp_netif_config)424 esp_netif_t* esp_netif_create_wifi(wifi_interface_t wifi_if, const esp_netif_inherent_config_t *esp_netif_config)
425 {
426     esp_netif_config_t cfg = {
427         .base = esp_netif_config
428     };
429     if (wifi_if == WIFI_IF_STA) {
430         cfg.stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_STA;
431 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
432     } else if (wifi_if == WIFI_IF_AP) {
433         cfg.stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP;
434 #endif
435 #ifdef CONFIG_ESP_WIFI_NAN_ENABLE
436     } else if (wifi_if == WIFI_IF_NAN) {
437         cfg.stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_NAN;
438 #endif
439     } else {
440         return NULL;
441     }
442 
443     esp_netif_t *netif = esp_netif_new(&cfg);
444     assert(netif);
445     esp_netif_attach_wifi(netif, wifi_if);
446     return netif;
447 }
448 
449 #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT
450 /**
451  * @brief Creates mesh network interfaces based on default STA and AP,
452  * but without DHCP, this is to be enabled separately only on root node
453  */
esp_netif_create_default_wifi_mesh_netifs(esp_netif_t ** p_netif_sta,esp_netif_t ** p_netif_ap)454 esp_err_t esp_netif_create_default_wifi_mesh_netifs(esp_netif_t **p_netif_sta, esp_netif_t **p_netif_ap)
455 {
456     // Create "almost" default AP, with un-flagged DHCP server
457     esp_netif_inherent_config_t netif_cfg;
458     memcpy(&netif_cfg, ESP_NETIF_BASE_DEFAULT_WIFI_AP, sizeof(netif_cfg));
459     netif_cfg.flags &= ~ESP_NETIF_DHCP_SERVER;
460     esp_netif_config_t cfg_ap = {
461             .base = &netif_cfg,
462             .stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP,
463     };
464     esp_netif_t *netif_ap = esp_netif_new(&cfg_ap);
465     assert(netif_ap);
466     ESP_ERROR_CHECK(esp_netif_attach_wifi_ap(netif_ap));
467     ESP_ERROR_CHECK(esp_wifi_set_default_wifi_ap_handlers());
468 
469     // ...and stop DHCP server to keep the ESP_NETIF_DHCP_STOPPED state
470     ESP_ERROR_CHECK(esp_netif_dhcps_stop(netif_ap));
471 
472     // Create "almost" default station, but with un-flagged DHCP client
473     memcpy(&netif_cfg, ESP_NETIF_BASE_DEFAULT_WIFI_STA, sizeof(netif_cfg));
474     netif_cfg.flags &= ~ESP_NETIF_DHCP_CLIENT;
475     esp_netif_config_t cfg_sta = {
476             .base = &netif_cfg,
477             .stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_STA,
478     };
479     esp_netif_t *netif_sta = esp_netif_new(&cfg_sta);
480     assert(netif_sta);
481     ESP_ERROR_CHECK(esp_netif_attach_wifi_station(netif_sta));
482     ESP_ERROR_CHECK(esp_wifi_set_default_wifi_sta_handlers());
483 
484     // ...and stop DHCP client (to be started separately if the station were promoted to root)
485     ESP_ERROR_CHECK(esp_netif_dhcpc_stop(netif_sta));
486 
487     if (p_netif_sta) {
488         *p_netif_sta = netif_sta;
489     }
490     if (p_netif_ap) {
491         *p_netif_ap = netif_ap;
492     }
493     return ESP_OK;
494 }
495 #endif // CONFIG_ESP_WIFI_SOFTAP_SUPPORT
496