fix(eppp_link): Fix stuff

Author: david-cermak

components/eppp_link/eppp_link.c

@@ -30,6 +30,7 @@ static EventGroupHandle_t s_event_group = NULL;
 static const char *TAG = "eppp_link";
 static int s_retry_num = 0;
 static int s_eppp_netif_count = 0; // used as a suffix for the netif key
+static eppp_channel_fn_t s_rx = NULL;
 
 struct eppp_handle {
 #if CONFIG_EPPP_LINK_DEVICE_SPI
@@ -52,8 +53,28 @@ struct eppp_handle {
 struct packet {
     size_t len;
     uint8_t *data;
+    int channel;
 };
 
+static esp_err_t transmit_channel(void *netif, void *buffer, size_t len)
+{
+    struct eppp_handle *h = esp_netif_get_io_driver(netif);
+    struct packet buf = { .len = len };
+    buf.channel = 1;
+    buf.data = malloc(len);
+    if (buf.data == NULL) {
+        ESP_LOGE(TAG, "Failed to allocate packet");
+        return ESP_FAIL;
+    }
+    memcpy(buf.data, buffer, len);
+    BaseType_t ret = xQueueSend(h->out_queue, &buf, pdMS_TO_TICKS(10));
+    if (ret != pdTRUE) {
+        ESP_LOGE(TAG, "Failed to queue packet to slave!");
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
 static esp_err_t transmit(void *h, void *buffer, size_t len)
 {
     struct eppp_handle *handle = h;
@@ -230,6 +251,10 @@ static void on_ip_event(void *arg, esp_event_base_t base, int32_t event_id, void
 {
     ip_event_got_ip_t *event = (ip_event_got_ip_t *)data;
     esp_netif_t *netif = event->esp_netif;
+    if (event_id == IP_EVENT_STA_GOT_IP) {
+        ESP_LOGI(TAG, "Got IPv4 event: Interface \"%s(%s)\" address: " IPSTR, esp_netif_get_desc(netif),
+                 esp_netif_get_ifkey(netif), IP2STR(&event->ip_info.ip));
+    }
     int netif_cnt = get_netif_num(netif);
     if (netif_cnt < 0) {
         return;
@@ -275,6 +300,7 @@ struct header {
         } __attribute__((packed));
     };
     uint8_t magic;
+    uint8_t channel;
     uint8_t checksum;
 } __attribute__((packed));
 
@@ -452,6 +478,13 @@ static esp_err_t perform_transaction_slave(union transaction *t, struct eppp_han
     return spi_slave_transmit(h->spi_host, &t->slave, portMAX_DELAY);
 }
 
+esp_err_t eppp_add_channel(int nr, eppp_channel_fn_t *tx, const eppp_channel_fn_t rx)
+{
+    *tx = transmit_channel;
+    s_rx = rx;
+    return ESP_OK;
+}
+
 esp_err_t eppp_perform(esp_netif_t *netif)
 {
     static WORD_ALIGNED_ATTR uint8_t out_buf[TRANSFER_SIZE] = {};
@@ -482,8 +515,10 @@ esp_err_t eppp_perform(esp_netif_t *netif)
     head->magic = FRAME_OUT_CTRL_EX;
     head->size = 0;
     head->checksum = 0;
+    head->channel = 0;
     BaseType_t tx_queue_stat = xQueueReceive(h->out_queue, &buf, 0);
     if (tx_queue_stat == pdTRUE && buf.data) {
+        head->channel = buf.channel;
         if (buf.len > SHORT_PAYLOAD) {
             head->magic = FRAME_OUT_CTRL;
             head->size = buf.len;
@@ -521,7 +556,14 @@ esp_err_t eppp_perform(esp_netif_t *netif)
         return ESP_FAIL;
     }
     if (head->magic == FRAME_IN_CTRL_EX && head->short_size > 0) {
-        esp_netif_receive(netif, in_buf + sizeof(struct header), head->short_size, NULL);
+        if (head->channel == 0) {
+            esp_netif_receive(netif, in_buf + sizeof(struct header), head->short_size, NULL);
+        } else {
+            ESP_LOGE(TAG, "Got channel %d size %d", head->channel, head->short_size);
+            if (s_rx != NULL) {
+                s_rx(netif, in_buf + sizeof(struct header), head->short_size);
+            }
+        }
     }
     size_t in_long_payload = 0;
     if (head->magic == FRAME_IN_CTRL) {
@@ -537,6 +579,7 @@ esp_err_t eppp_perform(esp_netif_t *netif)
     head->magic = FRAME_OUT_DATA;
     head->size = out_long_payload;
     head->checksum = 0;
+    head->channel = buf.channel;
     for (int i = 0; i < sizeof(struct header) - 1; ++i) {
         head->checksum += out_buf[i];
     }
@@ -570,7 +613,14 @@ esp_err_t eppp_perform(esp_netif_t *netif)
 
     if (head->size > 0) {
         ESP_LOG_BUFFER_HEXDUMP(TAG, in_buf + sizeof(struct header), head->size, ESP_LOG_VERBOSE);
-        esp_netif_receive(netif, in_buf + sizeof(struct header), head->size, NULL);
+        if (head->channel == 0) {
+            esp_netif_receive(netif, in_buf + sizeof(struct header), head->size, NULL);
+        } else {
+            ESP_LOGE(TAG, "Got channel %d size %d", head->channel, head->size);
+            if (s_rx != NULL) {
+                s_rx(netif, in_buf + sizeof(struct header), head->size);
+            }
+        }
     }
     return ESP_OK;
 }

components/eppp_link/examples/rpc/client/main/app_main.c

@@ -130,6 +130,59 @@ static void test_on_ping_end(esp_ping_handle_t hdl, void *args)
 }
 #endif // PING
 
+static esp_netif_t *s_wifi_netif;
+static esp_netif_t *s_ppp_netif;
+static eppp_channel_fn_t s_tx;
+
+static esp_err_t remote_wifi_receive(void *h, void *buffer, size_t len)
+{
+    if (s_wifi_netif) {
+        printf("recv %d\n", len);
+        return esp_netif_receive(s_wifi_netif, buffer, len, NULL);
+    }
+    return ESP_OK;
+}
+
+esp_err_t remote_wifi_transmit_wrap(void *h, void *buffer, size_t len, void *netstack_buffer)
+{
+    if (s_tx) {
+        printf("send %d\n", len);
+        return s_tx(s_ppp_netif, buffer, len);
+    }
+    return ESP_OK;
+}
+
+static esp_err_t remote_wifi_transmit(void *h, void *buffer, size_t len)
+{
+    if (s_tx) {
+        return s_tx(s_ppp_netif, buffer, len);
+    }
+    return ESP_OK;
+}
+
+static void wifi_free(void *h, void *buffer)
+{
+    printf("wifi_free %p\n", buffer);
+}
+
+static void remote_wifi_netif(void)
+{
+    esp_netif_driver_ifconfig_t driver_cfg = {
+        .handle = (void *)1,
+        .transmit = remote_wifi_transmit,
+        .transmit_wrap = remote_wifi_transmit_wrap,
+        .driver_free_rx_buffer = wifi_free
+
+    };
+    const esp_netif_driver_ifconfig_t *wifi_driver_cfg = &driver_cfg;
+    esp_netif_config_t netif_config = {
+        .base = ESP_NETIF_BASE_DEFAULT_WIFI_STA,
+        .driver = wifi_driver_cfg,
+        .stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP
+    };
+    s_wifi_netif = esp_netif_new(&netif_config);
+}
+
 void app_main(void)
 {
     ESP_LOGI(TAG, "[APP] Startup..");
@@ -152,14 +205,21 @@ void app_main(void)
     config.uart.rx_io = 11;
     config.uart.baud = 2000000;
 #endif
-    esp_netif_t *eppp_netif = eppp_connect(&config);
-    if (eppp_netif == NULL) {
+    s_ppp_netif = eppp_connect(&config);
+    if (s_ppp_netif == NULL) {
         ESP_LOGE(TAG, "Failed to connect");
         return ;
     }
+    eppp_add_channel(1, &s_tx, remote_wifi_receive);
+    remote_wifi_netif();
+    if (s_wifi_netif == NULL) {
+        ESP_LOGE(TAG, "Failed to create wifi netif");
+        return ;
+    }
 
     client_init();
 
+
     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
     ESP_LOG_BUFFER_HEXDUMP("cfg", &cfg, sizeof(cfg), ESP_LOG_WARN);
     ESP_ERROR_CHECK(esp_wifi_remote_init(&cfg));
@@ -176,8 +236,16 @@ void app_main(void)
     ESP_ERROR_CHECK(esp_wifi_remote_set_config(WIFI_IF_STA, &wifi_config) );
     ESP_ERROR_CHECK(esp_wifi_remote_start() );
     vTaskDelay(pdMS_TO_TICKS(1000));
+    uint8_t mac[6];
+    ESP_ERROR_CHECK(esp_wifi_remote_get_mac(WIFI_IF_STA, mac) );
+
+    esp_netif_set_mac(s_wifi_netif, mac);
+    vTaskDelay(pdMS_TO_TICKS(1000));
+
+    esp_netif_action_start(s_wifi_netif, 0, 0, 0);
     ESP_ERROR_CHECK(esp_wifi_remote_connect() );
 
+    esp_netif_action_connected(s_wifi_netif, 0, 0, 0);
 //    // Setup global DNS
 //    esp_netif_dns_info_t dns;
 //    dns.ip.u_addr.ip4.addr = esp_netif_htonl(CONFIG_EXAMPLE_GLOBAL_DNS);

components/eppp_link/examples/rpc/client/main/client.cpp

@@ -174,3 +174,19 @@ extern "C" esp_err_t esp_wifi_remote_connect(void)
     auto header = rpc.get_header();
     return rpc.get_payload<esp_err_t>(CONNECT, header);
 }
+
+extern "C" esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6])
+{
+    RpcEngine rpc(tls);
+
+    if (rpc.send(GET_MAC, &ifx) != ESP_OK) {
+        return ESP_FAIL;
+    }
+    auto header = rpc.get_header();
+    auto ret = rpc.get_payload<esp_wifi_remote_mac_t>(GET_MAC, header);
+    ESP_LOG_BUFFER_HEXDUMP("MAC", ret.mac, 6, ESP_LOG_INFO);
+
+    memcpy(mac, ret.mac, 6);
+    return ret.err;
+
+}

components/eppp_link/examples/rpc/client/sdkconfig.defaults

@@ -1,8 +1,14 @@
 # This file was generated using idf.py save-defconfig. It can be edited manually.
 # Espressif IoT Development Framework (ESP-IDF) 5.3.0 Project Minimal Configuration
 #
-CONFIG_UART_ISR_IN_IRAM=y
+CONFIG_IDF_TARGET="esp32s3"
+CONFIG_ESP_WIFI_SSID="Cermakowifi"
+CONFIG_ESP_WIFI_PASSWORD="MojeNovaUfka"
+CONFIG_ESP_TLS_INSECURE=y
+CONFIG_ESP_TLS_SKIP_SERVER_CERT_VERIFY=y
+CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
 CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_LWIP_PPP_SERVER_SUPPORT=y
 CONFIG_LWIP_PPP_VJ_HEADER_COMPRESSION=n
-CONFIG_LWIP_PPP_DEBUG_ON=y
 CONFIG_EPPP_LINK_DEVICE_SPI=y
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=4096

components/eppp_link/examples/rpc/common/esp_wifi_remote.h

@@ -16,6 +16,12 @@ struct esp_wifi_remote_config {
     wifi_config_t conf;
 };
 
+struct esp_wifi_remote_mac_t {
+    esp_err_t err;
+    uint8_t mac[6];
+};
+
+
 esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf);
 
 esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode);
@@ -26,6 +32,8 @@ esp_err_t esp_wifi_remote_start(void);
 
 esp_err_t esp_wifi_remote_connect(void);
 
+esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6]);
+
 #ifdef __cplusplus
 }
 #endif

components/eppp_link/examples/rpc/common/rpc.hpp

@@ -11,6 +11,7 @@ typedef enum api_id {
     SET_CONFIG,
     START,
     CONNECT,
+    GET_MAC
 } api_id_t;
 
 struct RpcHeader {

components/eppp_link/examples/rpc/server/main/server.cpp

@@ -119,9 +119,11 @@ static esp_err_t perform()
     }
     case INIT: {
         auto req = rpc.get_payload<wifi_init_config_t>(INIT, header);
-        ESP_LOG_BUFFER_HEXDUMP("cfg", &req, sizeof(req), ESP_LOG_WARN);
-        wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
-        ESP_LOG_BUFFER_HEXDUMP("cfg", &cfg, sizeof(cfg), ESP_LOG_WARN);
+        req.osi_funcs = &g_wifi_osi_funcs;
+        req.wpa_crypto_funcs = g_wifi_default_wpa_crypto_funcs;
+//        ESP_LOG_BUFFER_HEXDUMP("cfg", &req, sizeof(req), ESP_LOG_WARN);
+//        wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+//        ESP_LOG_BUFFER_HEXDUMP("cfg", &cfg, sizeof(cfg), ESP_LOG_WARN);
 
         auto ret = esp_wifi_init(&req);
         if (rpc.send(INIT, &ret) != ESP_OK) {
@@ -141,6 +143,7 @@ static esp_err_t perform()
         if (header.size != 0) {
             return ESP_FAIL;
         }
+
         auto ret = esp_wifi_start();
         if (rpc.send(START, &ret) != ESP_OK) {
             return ESP_FAIL;
@@ -151,12 +154,22 @@ static esp_err_t perform()
         if (header.size != 0) {
             return ESP_FAIL;
         }
+
         auto ret = esp_wifi_connect();
         if (rpc.send(CONNECT, &ret) != ESP_OK) {
             return ESP_FAIL;
         }
         break;
     }
+    case GET_MAC: {
+        auto req = rpc.get_payload<wifi_interface_t>(GET_MAC, header);
+        esp_wifi_remote_mac_t resp = {};
+        resp.err = esp_wifi_get_mac(req, resp.mac);
+        if (rpc.send(GET_MAC, &resp) != ESP_OK) {
+            return ESP_FAIL;
+        }
+        break;
+    }
 
 
     }

components/eppp_link/examples/rpc/server/main/station_example_main.c

@@ -5,6 +5,7 @@
  */
 
 #include <string.h>
+#include <esp_private/wifi.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/event_groups.h"
 #include "esp_system.h"
@@ -113,6 +114,29 @@ void wifi_init_sta(void)
 
 esp_err_t server_init(void);
 
+static eppp_channel_fn_t s_tx;
+static esp_netif_t *s_ppp_netif;
+
+static esp_err_t netif_recv(void *h, void *buffer, size_t len)
+{
+//    printf("recv %d\n", len);
+    ESP_LOG_BUFFER_HEXDUMP("cfg", buffer, len, ESP_LOG_WARN);
+    return esp_wifi_internal_tx(WIFI_IF_STA, buffer, len);
+}
+
+static esp_err_t wifi_recv(void *buffer, uint16_t len, void *eb)
+{
+    printf("send %d\n", len);
+    if (s_tx) {
+        printf("send %d\n", len);
+        esp_err_t ret = s_tx(s_ppp_netif, buffer, len);
+        esp_wifi_internal_free_rx_buffer(eb);
+        return ret;
+    }
+    return ESP_OK;
+}
+
+
 void app_main(void)
 {
 
@@ -129,11 +153,19 @@ void app_main(void)
     ESP_ERROR_CHECK(esp_event_loop_create_default());
     eppp_config_t config = EPPP_DEFAULT_SERVER_CONFIG();
     config.transport = EPPP_TRANSPORT_SPI;
-    esp_netif_t *eppp_netif = eppp_listen(&config);
-    if (eppp_netif == NULL) {
+    s_ppp_netif = eppp_listen(&config);
+    if (s_ppp_netif == NULL) {
         ESP_LOGE(TAG, "Failed to setup connection");
         return ;
     }
 
+//    esp_wifi_internal_reg_rxcb(WIFI_IF_STA, wifi_recv);
+//    esp_wifi_internal_reg_netstack_buf_cb(esp_netif_netstack_buf_ref, esp_netif_netstack_buf_free);
+    eppp_add_channel(1, &s_tx, netif_recv);
+
     server_init();
+    vTaskDelay(pdMS_TO_TICKS(10000));
+    esp_wifi_internal_reg_rxcb(WIFI_IF_STA, wifi_recv);
+    esp_wifi_internal_reg_netstack_buf_cb(esp_netif_netstack_buf_ref, esp_netif_netstack_buf_free);
+
 }