alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Examples/network: Add security options to provision sta-wired example

Browse Source
This commit is contained in:
David Cermak 2023-06-05 10:48:49 +02:00
parent 6ac17b5020
commit 022ddb1106
7 changed files with 284 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
examples/network/sta_to_eth/main/Kconfig.projbuild
View File

@ -14,6 +14,49 @@ menu "Example Configuration"
prompt "Using unified provisioning"
endchoice
choice EXAMPLE_PROV_SECURITY_VERSION
bool "Protocomm security version"
depends on EXAMPLE_WIFI_CONFIGURATION_PROVISIONING
default EXAMPLE_PROV_SECURITY_VERSION_1
help
Wi-Fi provisioning component offers 3 security versions.
The example offers a choice between security version 1 and 2.
config EXAMPLE_PROV_SECURITY_VERSION_1
bool "Security version 1"
select ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1
config EXAMPLE_PROV_SECURITY_VERSION_2
bool "Security version 2"
select ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2
config EXAMPLE_PROV_SECURITY_VERSION_0
bool "Plain text communication -- not secure!"
select ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0
endchoice
choice EXAMPLE_PROV_MODE
bool "Security version 2 mode"
depends on EXAMPLE_PROV_SECURITY_VERSION_2
default EXAMPLE_PROV_SEC2_DEV_MODE
config EXAMPLE_PROV_SEC2_DEV_MODE
bool "Security version 2 development mode"
depends on EXAMPLE_PROV_SECURITY_VERSION_2
help
This enables the development mode for
security version 2.
Please note that this mode is NOT recommended for production purpose.
config EXAMPLE_PROV_SEC2_PROD_MODE
bool "Security version 2 production mode"
depends on EXAMPLE_PROV_SECURITY_VERSION_2
help
This enables the production mode for
security version 2.
endchoice
choice EXAMPLE_WIRED_INTERFACE
prompt "Choose the Wired interface"
default EXAMPLE_WIRED_INTERFACE_IS_ETHERNET

58
examples/network/sta_to_eth/main/ethernet_iface.c
View File

@ -39,26 +39,26 @@ void eth_event_handler(void *arg, esp_event_base_t event_base,
esp_eth_handle_t eth_handle = *(esp_eth_handle_t *)event_data;
switch (event_id) {
case ETHERNET_EVENT_CONNECTED:
esp_eth_ioctl(eth_handle, ETH_CMD_G_MAC_ADDR, mac_addr);
ESP_LOGI(TAG, "Ethernet Link Up");
ESP_LOGI(TAG, "Ethernet HW Addr %02x:%02x:%02x:%02x:%02x:%02x",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
s_ethernet_is_connected = true;
break;
case ETHERNET_EVENT_DISCONNECTED:
ESP_LOGI(TAG, "Ethernet Link Down");
s_ethernet_is_connected = false;
break;
case ETHERNET_EVENT_START:
ESP_LOGI(TAG, "Ethernet Started");
break;
case ETHERNET_EVENT_STOP:
ESP_LOGI(TAG, "Ethernet Stopped");
break;
default:
ESP_LOGI(TAG, "Default Event");
break;
case ETHERNET_EVENT_CONNECTED:
esp_eth_ioctl(eth_handle, ETH_CMD_G_MAC_ADDR, mac_addr);
ESP_LOGI(TAG, "Ethernet Link Up");
ESP_LOGI(TAG, "Ethernet HW Addr %02x:%02x:%02x:%02x:%02x:%02x",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
s_ethernet_is_connected = true;
break;
case ETHERNET_EVENT_DISCONNECTED:
ESP_LOGI(TAG, "Ethernet Link Down");
s_ethernet_is_connected = false;
break;
case ETHERNET_EVENT_START:
ESP_LOGI(TAG, "Ethernet Started");
break;
case ETHERNET_EVENT_STOP:
ESP_LOGI(TAG, "Ethernet Stopped");
break;
default:
ESP_LOGI(TAG, "Default Event");
break;
}
}
@ -178,7 +178,7 @@ void mac_spoof(mac_spoof_direction_t direction, uint8_t *buffer, uint16_t len, u
static esp_err_t wired_recv(esp_eth_handle_t eth_handle, uint8_t *buffer, uint32_t len, void *priv)
{
esp_err_t ret = s_rx_cb(buffer,len, buffer);
esp_err_t ret = s_rx_cb(buffer, len, buffer);
free(buffer);
return ret;
}
@ -235,7 +235,7 @@ esp_err_t wired_send(void *buffer, uint16_t len, void *buff_free_arg)
* From the PC's NIC perspective the board acts as a separate network with it's own IP and MAC address
* (this network's MAC address is the native ESP32's Ethernet interface MAC)
*/
static void l2_free(void *h, void* buffer)
static void l2_free(void *h, void *buffer)
{
free(buffer);
}
@ -281,9 +281,9 @@ esp_err_t wired_netif_init(void)
base_cfg.if_desc = "ethernet config device";
// 2) Use static config for driver's config pointing only to static transmit and free functions
esp_netif_driver_ifconfig_t driver_cfg = {
.handle = (void*)1, // will be replaced by the driver pointer only tinyusb_net supports ti
.transmit = netif_transmit,
.driver_free_rx_buffer = l2_free
.handle = (void *)1, // will be replaced by the driver pointer only tinyusb_net supports ti
.transmit = netif_transmit,
.driver_free_rx_buffer = l2_free
};
// Config the esp-netif with:
@ -291,10 +291,10 @@ esp_err_t wired_netif_init(void)
// 2) driver's config (connection to IO functions -- usb)
// 3) stack config (using lwip IO functions -- derive from eth)
esp_netif_config_t cfg = {
.base = &base_cfg,
.driver = &driver_cfg,
// 3) use ethernet style of lwip netif settings
.stack = ESP_NETIF_NETSTACK_DEFAULT_ETH
.base = &base_cfg,
.driver = &driver_cfg,
// 3) use ethernet style of lwip netif settings
.stack = ESP_NETIF_NETSTACK_DEFAULT_ETH
};
s_netif = esp_netif_new(&cfg);

26
examples/network/sta_to_eth/main/manual_config.c
View File

@ -37,7 +37,7 @@ static esp_err_t http_get_handler(httpd_req_t *req)
"Password: <input type=\"text\" id=\"password\" name=\"password\"><br><br>\n"
" <input type=\"submit\" value=\"Connect\">"
"</form>";
char* buf = NULL;
char *buf = NULL;
size_t buf_len;
buf_len = httpd_req_get_url_query_len(req) + 1;
if (buf_len > 1) {
@ -49,27 +49,27 @@ static esp_err_t http_get_handler(httpd_req_t *req)
if (httpd_query_key_value(buf, "ssid", param, sizeof(param)) == ESP_OK) {
ESP_LOGI(TAG, "ssid=%s", param);
strncpy((char*)wifi_cfg.sta.ssid, param, sizeof(wifi_cfg.sta.ssid));
strncpy((char *)wifi_cfg.sta.ssid, param, sizeof(wifi_cfg.sta.ssid));
}
if (httpd_query_key_value(buf, "password", param, sizeof(param)) == ESP_OK) {
ESP_LOGI(TAG, "password=%s", param);
strncpy((char*)wifi_cfg.sta.password, param, sizeof(wifi_cfg.sta.password));
strncpy((char *)wifi_cfg.sta.password, param, sizeof(wifi_cfg.sta.password));
}
if (strlen((char*)wifi_cfg.sta.ssid) > 0 && strlen((char*)wifi_cfg.sta.password)) {
const char wifi_configured[] = "<h1>Connecting...</h1>";
if (strlen((char *)wifi_cfg.sta.ssid) > 0 && strlen((char *)wifi_cfg.sta.password)) {
httpd_resp_set_type(req, "text/html");
esp_wifi_set_mode(WIFI_MODE_STA);
if (esp_wifi_set_storage(WIFI_STORAGE_FLASH) == ESP_OK &&
esp_wifi_set_config(WIFI_IF_STA, &wifi_cfg) == ESP_OK) {
esp_wifi_set_config(WIFI_IF_STA, &wifi_cfg) == ESP_OK) {
const char wifi_configured[] = "<h1>Connecting...</h1>";
ESP_LOGI(TAG, "WiFi settings accepted!");
httpd_resp_send(req, wifi_configured, strlen(wifi_configured));
} else {
const char wifi_config_failed[] = "<h1>Failed to configure WiFi settings</h1>";
ESP_LOGE(TAG, "Failed to set WiFi config to flash");
httpd_resp_send(req, wifi_config_failed, strlen(wifi_config_failed));
}
//
// esp_wifi_set_config(WIFI_IF_STA, &wifi_cfg);
httpd_resp_set_type(req, "text/html");
httpd_resp_send(req, wifi_configured, strlen(wifi_configured));
free(buf);
if (s_flags) {
xEventGroupSetBits(*s_flags, s_success_bit);
@ -87,9 +87,9 @@ static esp_err_t http_get_handler(httpd_req_t *req)
}
static const httpd_uri_t root = {
.uri = "/",
.method = HTTP_GET,
.handler = http_get_handler,
.uri = "/",
.method = HTTP_GET,
.handler = http_get_handler,
};
static void start_webserver(void)

178
examples/network/sta_to_eth/main/provisioning.c
View File

@ -13,6 +13,74 @@
static const char *TAG = "NCM_provisioning";
#if CONFIG_EXAMPLE_PROV_SECURITY_VERSION_2
#if CONFIG_EXAMPLE_PROV_SEC2_DEV_MODE
#define EXAMPLE_PROV_SEC2_USERNAME "wifiprov"
#define EXAMPLE_PROV_SEC2_PWD "abcd1234"
/* This salt,verifier has been generated for username = "wifiprov" and password = "abcd1234"
* IMPORTANT NOTE: For production cases, this must be unique to every device
* and should come from device manufacturing partition.*/
static const char sec2_salt[] = {
0x03, 0x6e, 0xe0, 0xc7, 0xbc, 0xb9, 0xed, 0xa8, 0x4c, 0x9e, 0xac, 0x97, 0xd9, 0x3d, 0xec, 0xf4
};
static const char sec2_verifier[] = {
0x7c, 0x7c, 0x85, 0x47, 0x65, 0x08, 0x94, 0x6d, 0xd6, 0x36, 0xaf, 0x37, 0xd7, 0xe8, 0x91, 0x43,
0x78, 0xcf, 0xfd, 0x61, 0x6c, 0x59, 0xd2, 0xf8, 0x39, 0x08, 0x12, 0x72, 0x38, 0xde, 0x9e, 0x24,
0xa4, 0x70, 0x26, 0x1c, 0xdf, 0xa9, 0x03, 0xc2, 0xb2, 0x70, 0xe7, 0xb1, 0x32, 0x24, 0xda, 0x11,
0x1d, 0x97, 0x18, 0xdc, 0x60, 0x72, 0x08, 0xcc, 0x9a, 0xc9, 0x0c, 0x48, 0x27, 0xe2, 0xae, 0x89,
0xaa, 0x16, 0x25, 0xb8, 0x04, 0xd2, 0x1a, 0x9b, 0x3a, 0x8f, 0x37, 0xf6, 0xe4, 0x3a, 0x71, 0x2e,
0xe1, 0x27, 0x86, 0x6e, 0xad, 0xce, 0x28, 0xff, 0x54, 0x46, 0x60, 0x1f, 0xb9, 0x96, 0x87, 0xdc,
0x57, 0x40, 0xa7, 0xd4, 0x6c, 0xc9, 0x77, 0x54, 0xdc, 0x16, 0x82, 0xf0, 0xed, 0x35, 0x6a, 0xc4,
0x70, 0xad, 0x3d, 0x90, 0xb5, 0x81, 0x94, 0x70, 0xd7, 0xbc, 0x65, 0xb2, 0xd5, 0x18, 0xe0, 0x2e,
0xc3, 0xa5, 0xf9, 0x68, 0xdd, 0x64, 0x7b, 0xb8, 0xb7, 0x3c, 0x9c, 0xfc, 0x00, 0xd8, 0x71, 0x7e,
0xb7, 0x9a, 0x7c, 0xb1, 0xb7, 0xc2, 0xc3, 0x18, 0x34, 0x29, 0x32, 0x43, 0x3e, 0x00, 0x99, 0xe9,
0x82, 0x94, 0xe3, 0xd8, 0x2a, 0xb0, 0x96, 0x29, 0xb7, 0xdf, 0x0e, 0x5f, 0x08, 0x33, 0x40, 0x76,
0x52, 0x91, 0x32, 0x00, 0x9f, 0x97, 0x2c, 0x89, 0x6c, 0x39, 0x1e, 0xc8, 0x28, 0x05, 0x44, 0x17,
0x3f, 0x68, 0x02, 0x8a, 0x9f, 0x44, 0x61, 0xd1, 0xf5, 0xa1, 0x7e, 0x5a, 0x70, 0xd2, 0xc7, 0x23,
0x81, 0xcb, 0x38, 0x68, 0xe4, 0x2c, 0x20, 0xbc, 0x40, 0x57, 0x76, 0x17, 0xbd, 0x08, 0xb8, 0x96,
0xbc, 0x26, 0xeb, 0x32, 0x46, 0x69, 0x35, 0x05, 0x8c, 0x15, 0x70, 0xd9, 0x1b, 0xe9, 0xbe, 0xcc,
0xa9, 0x38, 0xa6, 0x67, 0xf0, 0xad, 0x50, 0x13, 0x19, 0x72, 0x64, 0xbf, 0x52, 0xc2, 0x34, 0xe2,
0x1b, 0x11, 0x79, 0x74, 0x72, 0xbd, 0x34, 0x5b, 0xb1, 0xe2, 0xfd, 0x66, 0x73, 0xfe, 0x71, 0x64,
0x74, 0xd0, 0x4e, 0xbc, 0x51, 0x24, 0x19, 0x40, 0x87, 0x0e, 0x92, 0x40, 0xe6, 0x21, 0xe7, 0x2d,
0x4e, 0x37, 0x76, 0x2f, 0x2e, 0xe2, 0x68, 0xc7, 0x89, 0xe8, 0x32, 0x13, 0x42, 0x06, 0x84, 0x84,
0x53, 0x4a, 0xb3, 0x0c, 0x1b, 0x4c, 0x8d, 0x1c, 0x51, 0x97, 0x19, 0xab, 0xae, 0x77, 0xff, 0xdb,
0xec, 0xf0, 0x10, 0x95, 0x34, 0x33, 0x6b, 0xcb, 0x3e, 0x84, 0x0f, 0xb9, 0xd8, 0x5f, 0xb8, 0xa0,
0xb8, 0x55, 0x53, 0x3e, 0x70, 0xf7, 0x18, 0xf5, 0xce, 0x7b, 0x4e, 0xbf, 0x27, 0xce, 0xce, 0xa8,
0xb3, 0xbe, 0x40, 0xc5, 0xc5, 0x32, 0x29, 0x3e, 0x71, 0x64, 0x9e, 0xde, 0x8c, 0xf6, 0x75, 0xa1,
0xe6, 0xf6, 0x53, 0xc8, 0x31, 0xa8, 0x78, 0xde, 0x50, 0x40, 0xf7, 0x62, 0xde, 0x36, 0xb2, 0xba
};
#endif
static esp_err_t example_get_sec2_salt(const char **salt, uint16_t *salt_len)
{
#if CONFIG_EXAMPLE_PROV_SEC2_DEV_MODE
ESP_LOGI(TAG, "Development mode: using hard coded salt");
*salt = sec2_salt;
*salt_len = sizeof(sec2_salt);
return ESP_OK;
#elif CONFIG_EXAMPLE_PROV_SEC2_PROD_MODE
ESP_LOGE(TAG, "Not implemented!");
return ESP_FAIL;
#endif
}
static esp_err_t example_get_sec2_verifier(const char **verifier, uint16_t *verifier_len)
{
#if CONFIG_EXAMPLE_PROV_SEC2_DEV_MODE
ESP_LOGI(TAG, "Development mode: using hard coded verifier");
*verifier = sec2_verifier;
*verifier_len = sizeof(sec2_verifier);
return ESP_OK;
#elif CONFIG_EXAMPLE_PROV_SEC2_PROD_MODE
/* This code needs to be updated with appropriate implementation to provide verifier */
ESP_LOGE(TAG, "Not implemented!");
return ESP_FAIL;
#endif
}
#endif // CONFIG_EXAMPLE_PROV_SECURITY_VERSION_2
struct events {
EventGroupHandle_t *flags;
int success_bit;
@ -25,39 +93,39 @@ static void event_handler(void *arg, esp_event_base_t event_base,
{
struct events *handler_args = arg;
switch (event_id) {
case WIFI_PROV_START:
ESP_LOGI(TAG, "Provisioning started");
break;
case WIFI_PROV_CRED_RECV: {
wifi_sta_config_t *wifi_sta_cfg = (wifi_sta_config_t *) event_data;
ESP_LOGI(TAG, "Received Wi-Fi credentials"
"\n\tSSID : %s\n\tPassword : %s",
(const char *) wifi_sta_cfg->ssid,
(const char *) wifi_sta_cfg->password);
break;
}
case WIFI_PROV_CRED_FAIL: {
wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *) event_data;
ESP_LOGE(TAG, "Provisioning failed!\n\tReason : %s"
"\n\tPlease reset to factory and retry provisioning",
(*reason == WIFI_PROV_STA_AUTH_ERROR) ?
"Wi-Fi station authentication failed" : "Wi-Fi access-point not found");
handler_args->success = false;
case WIFI_PROV_START:
ESP_LOGI(TAG, "Provisioning started");
break;
case WIFI_PROV_CRED_RECV: {
wifi_sta_config_t *wifi_sta_cfg = (wifi_sta_config_t *) event_data;
ESP_LOGI(TAG, "Received Wi-Fi credentials"
"\n\tSSID : %s\n\tPassword : %s",
(const char *) wifi_sta_cfg->ssid,
(const char *) wifi_sta_cfg->password);
break;
}
case WIFI_PROV_CRED_FAIL: {
wifi_prov_sta_fail_reason_t *reason = (wifi_prov_sta_fail_reason_t *) event_data;
ESP_LOGE(TAG, "Provisioning failed!\n\tReason : %s"
"\n\tPlease reset to factory and retry provisioning",
(*reason == WIFI_PROV_STA_AUTH_ERROR) ?
"Wi-Fi station authentication failed" : "Wi-Fi access-point not found");
handler_args->success = false;
break;
}
case WIFI_PROV_CRED_SUCCESS:
ESP_LOGI(TAG, "Provisioning successful");
handler_args->success = true;
break;
case WIFI_PROV_END:
/* De-initialize manager once provisioning is finished */
wifi_prov_mgr_deinit();
xEventGroupSetBits(*handler_args->flags, handler_args->success ? handler_args->success_bit : handler_args->fail_bit);
free(handler_args);
break;
default:
break;
break;
}
case WIFI_PROV_CRED_SUCCESS:
ESP_LOGI(TAG, "Provisioning successful");
handler_args->success = true;
break;
case WIFI_PROV_END:
/* De-initialize manager once provisioning is finished */
wifi_prov_mgr_deinit();
xEventGroupSetBits(*handler_args->flags, handler_args->success ? handler_args->success_bit : handler_args->fail_bit);
free(handler_args);
break;
default:
break;
}
}
@ -75,16 +143,56 @@ esp_err_t start_provisioning(EventGroupHandle_t *flags, int success_bit, int fai
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_PROV_EVENT, ESP_EVENT_ANY_ID, event_handler, handler_args));
/* Configuration for the provisioning manager */
wifi_prov_mgr_config_t config = {
.scheme = wifi_prov_scheme_httpd,
.scheme = wifi_prov_scheme_httpd,
};
/* Initialize provisioning manager with the
* configuration parameters set above */
ESP_ERROR_CHECK(wifi_prov_mgr_init(config));
/* TODO: Add more security options to menuconfig
/* What is the security level that we want (0, 1, 2):
* - WIFI_PROV_SECURITY_0 is simply plain text communication.
* - WIFI_PROV_SECURITY_1 is secure communication which consists of secure handshake
* - WIFI_PROV_SECURITY_2 SRP6a based authentication and key exchange
* Please check unified provisioning documentation for more details
*/
ESP_ERROR_CHECK(wifi_prov_mgr_start_provisioning(WIFI_PROV_SECURITY_0, NULL, NULL, NULL));
#ifdef CONFIG_EXAMPLE_PROV_SECURITY_VERSION_0
wifi_prov_security_t security = WIFI_PROV_SECURITY_0;
#elif CONFIG_EXAMPLE_PROV_SECURITY_VERSION_1
wifi_prov_security_t security = WIFI_PROV_SECURITY_1;
const char *pop = "abcd1234"; /* Proof of possession */
wifi_prov_security1_params_t *sec_params = pop;
#elif CONFIG_EXAMPLE_PROV_SECURITY_VERSION_2
wifi_prov_security_t security = WIFI_PROV_SECURITY_2;
/* The username must be the same one, which has been used in the generation of salt and verifier */
#if CONFIG_EXAMPLE_PROV_SEC2_DEV_MODE
/* This pop field represents the password that will be used to generate salt and verifier.
* The field is present here in order to generate the QR code containing password.
* In production this password field shall not be stored on the device */
const char *username = EXAMPLE_PROV_SEC2_USERNAME;
const char *pop = EXAMPLE_PROV_SEC2_PWD;
#elif CONFIG_EXAMPLE_PROV_SEC2_PROD_MODE
/* The username and password shall not be embedded in the firmware */
const char *username = NULL;
const char *pop = NULL;
#endif
/* This is the structure for passing security parameters
* for the protocomm security 2.
* If dynamically allocated, sec2_params pointer and its content
* must be valid till WIFI_PROV_END event is triggered.
*/
wifi_prov_security2_params_t sec2_params = {};
ESP_ERROR_CHECK(example_get_sec2_salt(&sec2_params.salt, &sec2_params.salt_len));
ESP_ERROR_CHECK(example_get_sec2_verifier(&sec2_params.verifier, &sec2_params.verifier_len));
wifi_prov_security2_params_t *sec_params = &sec2_params;
#endif // CONFIG_EXAMPLE_PROV_SECURITY_VERSION_0 (VERSION_1, VERSION_2)
ESP_ERROR_CHECK(wifi_prov_mgr_start_provisioning(security, (const void *) sec_params, NULL, NULL)); // service name and key could be NULL
return ESP_OK;
}

22
examples/network/sta_to_eth/main/scheme_generic_httpd.c
View File

@ -25,9 +25,9 @@ static esp_err_t prov_start(protocomm_t *pc, void *config)
return ESP_ERR_INVALID_ARG;
}
protocomm_httpd_config_t default_config = {
.data = {
.config = PROTOCOMM_HTTPD_DEFAULT_CONFIG()
}
.data = {
.config = PROTOCOMM_HTTPD_DEFAULT_CONFIG()
}
};
/* Start protocomm server on top of HTTP */
@ -60,7 +60,7 @@ static esp_err_t prov_stop(protocomm_t *pc)
*/
static void *new_config(void)
{
return (void*)1;
return (void *)1;
}
static void delete_config(void *config)
@ -81,11 +81,11 @@ static esp_err_t set_config_endpoint(void *config, const char *endpoint_name, ui
* @brief Creating a generic HTTPD scheme
*/
const wifi_prov_scheme_t wifi_prov_scheme_httpd = {
.prov_start = prov_start,
.prov_stop = prov_stop,
.new_config = new_config,
.delete_config = delete_config,
.set_config_service = set_config_service,
.set_config_endpoint = set_config_endpoint,
.wifi_mode = WIFI_MODE_STA
.prov_start = prov_start,
.prov_stop = prov_stop,
.new_config = new_config,
.delete_config = delete_config,
.set_config_service = set_config_service,
.set_config_endpoint = set_config_endpoint,
.wifi_mode = WIFI_MODE_STA
};

20
examples/network/sta_to_eth/main/sta2wired_main.c
View File

@ -35,7 +35,7 @@ const int PROV_FAIL_BIT = BIT4;
/**
* WiFi -- Wired packet path
*/
static esp_err_t wired_recv_callback(void *buffer, uint16_t len, void* ctx)
static esp_err_t wired_recv_callback(void *buffer, uint16_t len, void *ctx)
{
if (s_wifi_is_connected) {
mac_spoof(FROM_WIRED, buffer, len, s_sta_mac);
@ -46,7 +46,7 @@ static esp_err_t wired_recv_callback(void *buffer, uint16_t len, void* ctx)
return ESP_OK;
}
static void wifi_buff_free(void* buffer, void* ctx)
static void wifi_buff_free(void *buffer, void *ctx)
{
esp_wifi_internal_free_rx_buffer(buffer);
}
@ -62,7 +62,7 @@ static esp_err_t wifi_recv_callback(void *buffer, uint16_t len, void *eb)
}
static void event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void *event_data)
int32_t event_id, void *event_data)
{
if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
ESP_LOGI(TAG, "Wi-Fi STA disconnected");
@ -93,7 +93,7 @@ static esp_err_t connect_wifi(void)
return ESP_FAIL;
}
esp_wifi_connect();
EventBits_t status = xEventGroupWaitBits(s_event_flags, CONNECTED_BIT, 0, 1, 10000/portTICK_PERIOD_MS);
EventBits_t status = xEventGroupWaitBits(s_event_flags, CONNECTED_BIT, 0, 1, 10000 / portTICK_PERIOD_MS);
if (status & CONNECTED_BIT) {
ESP_LOGI(TAG, "WiFi station connected successfully");
return ESP_OK;
@ -108,7 +108,7 @@ static esp_err_t connect_wifi(void)
#define GPIO_INPUT CONFIG_EXAMPLE_RECONFIGURE_BUTTON
#define GPIO_LONG_PUSH_US 2000000 /* push for 2 seconds to reconfigure */
static void IRAM_ATTR gpio_isr_handler(void* arg)
static void IRAM_ATTR gpio_isr_handler(void *arg)
{
static int64_t last_pushed = -1;
if (gpio_get_level(GPIO_INPUT) == 0) {
@ -129,9 +129,10 @@ static void IRAM_ATTR gpio_isr_handler(void* arg)
static void gpio_init(void)
{
gpio_config_t io_conf = { .intr_type = GPIO_INTR_ANYEDGE,
.pin_bit_mask = (1ULL<<GPIO_INPUT),
.mode = GPIO_MODE_INPUT,
.pull_up_en = 1 };
.pin_bit_mask = (1ULL << GPIO_INPUT),
.mode = GPIO_MODE_INPUT,
.pull_up_en = 1
};
gpio_config(&io_conf);
gpio_install_isr_service(0);
//hook isr handler for specific gpio pin
@ -178,8 +179,7 @@ void app_main(void)
/* Start the application in configuration mode (to perform provisioning)
* or in a bridge mode (already provisioned) */
if (do_provision || !is_provisioned())
{
if (do_provision || !is_provisioned()) {
ESP_LOGI(TAG, "Starting provisioning");
ESP_ERROR_CHECK(esp_netif_init());
// needed to complete provisioning with getting a valid IP event

58
examples/network/sta_to_eth/main/usb_ncm_iface.c
View File

@ -15,6 +15,7 @@
#include "tinyusb_net.h"
#include "wired_iface.h"
#include "dhcpserver/dhcpserver_options.h"
#include "lwip/esp_netif_net_stack.h"
#include "esp_mac.h"
static const char *TAG = "example_wired_tusb_ncm";
@ -44,13 +45,13 @@ void mac_spoof(mac_spoof_direction_t direction, uint8_t *buffer, uint16_t len, u
esp_err_t wired_bridge_init(wired_rx_cb_t rx_cb, wired_free_cb_t free_cb)
{
const tinyusb_config_t tusb_cfg = {
.external_phy = false,
.external_phy = false,
};
ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));
tinyusb_net_config_t net_config = {
.on_recv_callback = rx_cb,
.free_tx_buffer = free_cb,
.on_recv_callback = rx_cb,
.free_tx_buffer = free_cb,
};
esp_read_mac(net_config.mac_addr, ESP_MAC_WIFI_STA);
@ -69,7 +70,7 @@ esp_err_t wired_send(void *buffer, uint16_t len, void *buff_free_arg)
return tinyusb_net_send_sync(buffer, len, buff_free_arg, pdMS_TO_TICKS(100));
}
static void l2_free(void *h, void* buffer)
static void l2_free(void *h, void *buffer)
{
free(buffer);
}
@ -82,7 +83,7 @@ static esp_err_t netif_transmit (void *h, void *buffer, size_t len)
return ESP_OK;
}
static esp_err_t netif_recv_callback(void *buffer, uint16_t len, void* ctx)
static esp_err_t netif_recv_callback(void *buffer, uint16_t len, void *ctx)
{
if (s_netif) {
void *buf_copy = malloc(len);
@ -113,15 +114,15 @@ static esp_err_t netif_recv_callback(void *buffer, uint16_t len, void* ctx)
esp_err_t wired_netif_init(void)
{
const tinyusb_config_t tusb_cfg = {
.external_phy = false,
.external_phy = false,
};
ESP_ERROR_CHECK(tinyusb_driver_install(&tusb_cfg));
const tinyusb_net_config_t net_config = {
// locally administrated address for the ncm device as it's going to be used internally
// for configuration only
.mac_addr = {0x02, 0x02, 0x11, 0x22, 0x33, 0x01},
.on_recv_callback = netif_recv_callback,
// locally administrated address for the ncm device as it's going to be used internally
// for configuration only
.mac_addr = {0x02, 0x02, 0x11, 0x22, 0x33, 0x01},
.on_recv_callback = netif_recv_callback,
};
esp_err_t ret = tinyusb_net_init(TINYUSB_USBDEV_0, &net_config);
@ -132,18 +133,30 @@ esp_err_t wired_netif_init(void)
// with OUI range MAC to create a virtual netif running http server
// this needs to be different to usb_interface_mac (==client)
uint8_t lwip_addr[6]= {0x02, 0x02, 0x11, 0x22, 0x33, 0x02};
uint8_t lwip_addr[6] = {0x02, 0x02, 0x11, 0x22, 0x33, 0x02};
// 1) Derive the base config from the default AP (using DHCP server)
esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_WIFI_AP();
base_cfg.if_key = "wired";
base_cfg.if_desc = "usb ncm config device";
// Definition of
// 1) Derive the base config (very similar to IDF's default WiFi AP with DHCP server)
esp_netif_inherent_config_t base_cfg = {
.flags = ESP_NETIF_DHCP_SERVER | ESP_NETIF_FLAG_AUTOUP, // Run DHCP server; set the netif "ip" immediately
.ip_info = &_g_esp_netif_soft_ap_ip, // Use the same IP ranges as IDF's soft AP
.if_key = "wired", // Set mame, key, priority
.if_desc = "usb ncm config device",
.route_prio = 10
};
// 2) Use static config for driver's config pointing only to static transmit and free functions
esp_netif_driver_ifconfig_t driver_cfg = {
.handle = (void*)1, // will be replaced by the driver pointer only tinyusb_net supports ti
.transmit = netif_transmit,
.driver_free_rx_buffer = l2_free
.handle = (void *)1, // not using an instance, USB-NCM is a static singleton (must be != NULL)
.transmit = netif_transmit, // point to static Tx function
.driver_free_rx_buffer = l2_free // point to Free Rx buffer function
};
// 3) USB-NCM is an Ethernet netif from lwip perspective, we already have IO definitions for that:
struct esp_netif_netstack_config lwip_netif_config = {
.lwip = {
.init_fn = ethernetif_init,
.input_fn = ethernetif_input
}
};
// Config the esp-netif with:
@ -151,10 +164,9 @@ esp_err_t wired_netif_init(void)
// 2) driver's config (connection to IO functions -- usb)
// 3) stack config (using lwip IO functions -- derive from eth)
esp_netif_config_t cfg = {
.base = &base_cfg,
.driver = &driver_cfg,
// 3) use ethernet style of lwip netif settings
.stack = ESP_NETIF_NETSTACK_DEFAULT_ETH
.base = &base_cfg,
.driver = &driver_cfg,
.stack = &lwip_netif_config
};
s_netif = esp_netif_new(&cfg);