P4 fixes
This commit is contained in:
iranl
23
resources/espressif__esp_wifi_remote/eppp/eppp_init.c
Normal file
23
resources/espressif__esp_wifi_remote/eppp/eppp_init.c
Normal file
@@ -0,0 +1,23 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include "esp_log.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "eppp_link.h"
|
||||
|
||||
__attribute__((weak)) esp_netif_t *wifi_remote_eppp_init(eppp_type_t role)
|
||||
{
|
||||
uint32_t our_ip = role == EPPP_SERVER ? EPPP_DEFAULT_SERVER_IP() : EPPP_DEFAULT_CLIENT_IP();
|
||||
uint32_t their_ip = role == EPPP_SERVER ? EPPP_DEFAULT_CLIENT_IP() : EPPP_DEFAULT_SERVER_IP();
|
||||
eppp_config_t config = EPPP_DEFAULT_CONFIG(our_ip, their_ip);
|
||||
// We currently support only UART transport
|
||||
config.transport = EPPP_TRANSPORT_UART;
|
||||
config.uart.tx_io = CONFIG_ESP_WIFI_REMOTE_EPPP_UART_TX_PIN;
|
||||
config.uart.rx_io = CONFIG_ESP_WIFI_REMOTE_EPPP_UART_RX_PIN;
|
||||
config.uart.port = CONFIG_ESP_WIFI_REMOTE_EPPP_UART_PORT;
|
||||
config.ppp.netif_description = CONFIG_ESP_WIFI_REMOTE_EPPP_NETIF_DESCRIPTION;
|
||||
config.ppp.netif_prio = CONFIG_ESP_WIFI_REMOTE_EPPP_NETIF_PRIORITY;
|
||||
return eppp_open(role, &config, portMAX_DELAY);
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include <netdb.h>
|
||||
#include <memory>
|
||||
#include <cinttypes>
|
||||
#include "esp_log.h"
|
||||
#include "esp_tls.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_check.h"
|
||||
#include "wifi_remote_rpc_impl.hpp"
|
||||
#include "eppp_link.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/event_groups.h"
|
||||
#include "wifi_remote_rpc_params.h"
|
||||
|
||||
extern "C" esp_netif_t *wifi_remote_eppp_init(eppp_type_t role);
|
||||
|
||||
namespace eppp_rpc {
|
||||
|
||||
namespace client {
|
||||
const char *TAG = "rpc_client";
|
||||
|
||||
const unsigned char ca_crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_CA "\n-----END CERTIFICATE-----";
|
||||
const unsigned char crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_CRT "\n-----END CERTIFICATE-----";
|
||||
const unsigned char key[] = "-----BEGIN PRIVATE KEY-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_KEY "\n-----END PRIVATE KEY-----";
|
||||
// TODO: Add option to supply keys and certs via a global symbol (file)
|
||||
|
||||
}
|
||||
|
||||
using namespace client;
|
||||
|
||||
class Sync {
|
||||
friend class RpcInstance;
|
||||
public:
|
||||
void lock()
|
||||
{
|
||||
xSemaphoreTake(mutex, portMAX_DELAY);
|
||||
}
|
||||
void unlock()
|
||||
{
|
||||
xSemaphoreGive(mutex);
|
||||
}
|
||||
esp_err_t init()
|
||||
{
|
||||
mutex = xSemaphoreCreateMutex();
|
||||
events = xEventGroupCreate();
|
||||
return mutex == nullptr || events == nullptr ? ESP_ERR_NO_MEM : ESP_OK;
|
||||
}
|
||||
esp_err_t wait_for(EventBits_t bits, uint32_t timeout = portMAX_DELAY)
|
||||
{
|
||||
return (xEventGroupWaitBits(events, bits, pdTRUE, pdTRUE, timeout) & bits) == bits ? ESP_OK : ESP_FAIL;
|
||||
}
|
||||
esp_err_t notify(EventBits_t bits)
|
||||
{
|
||||
xEventGroupSetBits(events, bits);
|
||||
return ESP_OK;
|
||||
}
|
||||
~Sync()
|
||||
{
|
||||
if (mutex) {
|
||||
vSemaphoreDelete(mutex);
|
||||
}
|
||||
if (events) {
|
||||
vEventGroupDelete(events);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
SemaphoreHandle_t mutex{nullptr};
|
||||
EventGroupHandle_t events{nullptr};
|
||||
|
||||
const int request = 1;
|
||||
const int resp_header = 2;
|
||||
const int resp_payload = 4;
|
||||
const int restart = 8;
|
||||
};
|
||||
|
||||
class RpcInstance {
|
||||
friend class Sync;
|
||||
public:
|
||||
|
||||
template<typename T>
|
||||
esp_err_t send(api_id id, T *t)
|
||||
{
|
||||
pending_resp = id;
|
||||
ESP_RETURN_ON_ERROR(sync.notify(sync.request), TAG, "failed to notify req");
|
||||
ESP_RETURN_ON_ERROR(rpc.send<T>(id, t), TAG, "Failed to send request");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
// overload of the templated method (used for functions with no arguments)
|
||||
esp_err_t send(api_id id)
|
||||
{
|
||||
pending_resp = id;
|
||||
ESP_RETURN_ON_ERROR(sync.notify(sync.request), TAG, "failed to notify req");
|
||||
ESP_RETURN_ON_ERROR(rpc.send(id), TAG, "Failed to send request");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T get_resp(api_id id)
|
||||
{
|
||||
sync.wait_for(sync.resp_header);
|
||||
auto ret = rpc.template get_payload<T>(id, pending_header);
|
||||
sync.notify(sync.resp_payload);
|
||||
return ret;
|
||||
}
|
||||
esp_err_t init()
|
||||
{
|
||||
ESP_RETURN_ON_FALSE(netif = wifi_remote_eppp_init(EPPP_CLIENT), ESP_FAIL, TAG, "Failed to connect to EPPP server");
|
||||
ESP_RETURN_ON_ERROR(esp_event_handler_register(IP_EVENT, IP_EVENT_PPP_GOT_IP, got_ip, this), TAG, "Failed to register event");
|
||||
ESP_RETURN_ON_ERROR(sync.init(), TAG, "Failed to init sync primitives");
|
||||
ESP_RETURN_ON_ERROR(rpc.init(), TAG, "Failed to init RPC engine");
|
||||
return xTaskCreate(task, "client", 8192, this, 5, nullptr) == pdTRUE ? ESP_OK : ESP_FAIL;
|
||||
}
|
||||
RpcEngine rpc{eppp_rpc::role::CLIENT};
|
||||
Sync sync;
|
||||
private:
|
||||
api_id pending_resp{api_id::UNDEF};
|
||||
RpcHeader pending_header{};
|
||||
esp_err_t process_ip_event(RpcHeader &header)
|
||||
{
|
||||
auto event = rpc.get_payload<esp_wifi_remote_eppp_ip_event>(api_id::IP_EVENT, header);
|
||||
// Now bypass network layers with EPPP interface
|
||||
ESP_RETURN_ON_ERROR(esp_netif_set_dns_info(netif, ESP_NETIF_DNS_MAIN, &event.dns), TAG, "Failed to set DNS info");
|
||||
ESP_RETURN_ON_ERROR(esp_netif_set_default_netif(netif), TAG, "Failed to set default netif to EPPP");
|
||||
ip_event_got_ip_t evt = {
|
||||
.esp_netif = netif,
|
||||
.ip_info = {},
|
||||
.ip_changed = true,
|
||||
};
|
||||
esp_netif_get_ip_info(netif, &evt.ip_info);
|
||||
ESP_RETURN_ON_ERROR(esp_event_post(IP_EVENT, IP_EVENT_STA_GOT_IP, &evt, sizeof(evt), 0), TAG, "Failed to post IP event");
|
||||
ESP_LOGI(TAG, "Main DNS:" IPSTR, IP2STR(&event.dns.ip.u_addr.ip4));
|
||||
ESP_LOGI(TAG, "EPPP IP:" IPSTR, IP2STR(&event.ppp_ip.ip));
|
||||
ESP_LOGI(TAG, "WIFI IP:" IPSTR, IP2STR(&event.wifi_ip.ip));
|
||||
ESP_LOGI(TAG, "WIFI GW:" IPSTR, IP2STR(&event.wifi_ip.gw));
|
||||
ESP_LOGI(TAG, "WIFI mask:" IPSTR, IP2STR(&event.wifi_ip.netmask));
|
||||
return ESP_OK;
|
||||
}
|
||||
esp_err_t process_wifi_event(RpcHeader &header)
|
||||
{
|
||||
auto event_id = rpc.get_payload<int32_t>(api_id::WIFI_EVENT, header);
|
||||
ESP_RETURN_ON_ERROR(esp_event_post(WIFI_EVENT, event_id, nullptr, 0, 0), TAG, "Failed to post WiFi event");
|
||||
return ESP_OK;
|
||||
}
|
||||
esp_err_t perform()
|
||||
{
|
||||
auto header = rpc.get_header();
|
||||
if (api_id(header.id) == api_id::ERROR) { // network error
|
||||
return ESP_FAIL;
|
||||
}
|
||||
if (api_id(header.id) == api_id::UNDEF) { // network timeout
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
if (api_id(header.id) == api_id::IP_EVENT) {
|
||||
return process_ip_event(header);
|
||||
}
|
||||
if (api_id(header.id) == api_id::WIFI_EVENT) {
|
||||
return process_wifi_event(header);
|
||||
}
|
||||
if (sync.wait_for(sync.request, 0) == ESP_OK && api_id(header.id) == pending_resp) {
|
||||
pending_header = header;
|
||||
pending_resp = api_id::UNDEF;
|
||||
sync.notify(sync.resp_header);
|
||||
sync.wait_for(sync.resp_payload);
|
||||
return ESP_OK;
|
||||
}
|
||||
ESP_LOGE(TAG, "Unexpected header %" PRIi32, static_cast<uint32_t>(header.id));
|
||||
return ESP_FAIL;
|
||||
|
||||
}
|
||||
static void task(void *ctx)
|
||||
{
|
||||
auto instance = static_cast<RpcInstance *>(ctx);
|
||||
do {
|
||||
while (instance->perform() == ESP_OK) {}
|
||||
} while (instance->restart() == ESP_OK);
|
||||
vTaskDelete(nullptr);
|
||||
}
|
||||
esp_err_t restart()
|
||||
{
|
||||
rpc.deinit();
|
||||
ESP_RETURN_ON_ERROR(sync.wait_for(sync.restart, pdMS_TO_TICKS(10000)), TAG, "Didn't receive EPPP address in time");
|
||||
return rpc.init();
|
||||
}
|
||||
static void got_ip(void *ctx, esp_event_base_t base, int32_t id, void *data)
|
||||
{
|
||||
auto instance = static_cast<RpcInstance *>(ctx);
|
||||
instance->sync.notify(instance->sync.restart);
|
||||
}
|
||||
esp_netif_t *netif{nullptr};
|
||||
};
|
||||
|
||||
|
||||
namespace client {
|
||||
constinit RpcInstance instance;
|
||||
} // namespace client
|
||||
|
||||
RpcInstance *RpcEngine::init_client()
|
||||
{
|
||||
char host[4 * 4 + 1] = {}; // IPv4: 4 x (3 numbers + '.') + \0
|
||||
esp_ip4_addr_t ip = { .addr = EPPP_DEFAULT_SERVER_IP() };
|
||||
if (esp_ip4addr_ntoa(&ip, host, sizeof(host)) == nullptr) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
esp_tls_cfg_t cfg = {};
|
||||
cfg.cacert_buf = client::ca_crt;
|
||||
cfg.cacert_bytes = sizeof(client::ca_crt);
|
||||
cfg.clientcert_buf = client::crt;
|
||||
cfg.clientcert_bytes = sizeof(client::crt);
|
||||
cfg.clientkey_buf = client::key;
|
||||
cfg.clientkey_bytes = sizeof(client::key);
|
||||
cfg.common_name = "espressif.local";
|
||||
|
||||
ESP_RETURN_ON_FALSE(tls_ = esp_tls_init(), nullptr, TAG, "Failed to create ESP-TLS instance");
|
||||
int retries = 0;
|
||||
while (esp_tls_conn_new_sync(host, strlen(host), rpc_port, &cfg, tls_) <= 0) {
|
||||
esp_tls_conn_destroy(tls_);
|
||||
tls_ = nullptr;
|
||||
ESP_RETURN_ON_FALSE(retries++ < 3, nullptr, TAG, "Failed to open connection to %s", host);
|
||||
ESP_LOGW(TAG, "Connection to RPC server failed! Will retry in %d second(s)", retries);
|
||||
vTaskDelay(pdMS_TO_TICKS(1000 * retries));
|
||||
ESP_RETURN_ON_FALSE(tls_ = esp_tls_init(), nullptr, TAG, "Failed to create ESP-TLS instance");
|
||||
}
|
||||
return &client::instance;
|
||||
}
|
||||
} // namespace eppp_rpc
|
||||
|
||||
//
|
||||
// esp_wifi_remote API implementation
|
||||
//
|
||||
using namespace eppp_rpc;
|
||||
using namespace client;
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config)
|
||||
{
|
||||
// Here we initialize this client's RPC
|
||||
ESP_RETURN_ON_ERROR(instance.init(), TAG, "Failed to initialize eppp-rpc");
|
||||
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::INIT, config), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::INIT);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf)
|
||||
{
|
||||
esp_wifi_remote_config params = { .interface = interface, .conf = {} };
|
||||
memcpy(¶ms.conf, conf, sizeof(wifi_config_t));
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::SET_CONFIG, ¶ms), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::SET_CONFIG);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_start(void)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::START), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::START);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_stop(void)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::STOP), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::STOP);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_connect(void)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::CONNECT), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::CONNECT);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6])
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::GET_MAC, &ifx), TAG, "Failed to send request");
|
||||
auto ret = instance.get_resp<esp_wifi_remote_mac_t>(api_id::GET_MAC);
|
||||
ESP_LOG_BUFFER_HEXDUMP("MAC", ret.mac, 6, ESP_LOG_DEBUG);
|
||||
memcpy(mac, ret.mac, 6);
|
||||
return ret.err;
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::SET_MODE, &mode), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::SET_MODE);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_deinit(void)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::DEINIT), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::DEINIT);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_disconnect(void)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::DISCONNECT), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::DISCONNECT);
|
||||
}
|
||||
|
||||
extern "C" esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage)
|
||||
{
|
||||
std::lock_guard<Sync> lock(instance.sync);
|
||||
ESP_RETURN_ON_ERROR(instance.send(api_id::SET_STORAGE, &storage), TAG, "Failed to send request");
|
||||
return instance.get_resp<esp_err_t>(api_id::SET_STORAGE);
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
#include <cstring>
|
||||
#include <cerrno>
|
||||
|
||||
namespace eppp_rpc {
|
||||
|
||||
static constexpr int rpc_port = 3333;
|
||||
|
||||
/**
|
||||
* @brief Currently supported RPC commands/events
|
||||
*/
|
||||
enum class api_id : uint32_t {
|
||||
ERROR,
|
||||
UNDEF,
|
||||
INIT,
|
||||
DEINIT,
|
||||
SET_MODE,
|
||||
SET_CONFIG,
|
||||
START,
|
||||
STOP,
|
||||
CONNECT,
|
||||
DISCONNECT,
|
||||
GET_MAC,
|
||||
SET_STORAGE,
|
||||
WIFI_EVENT,
|
||||
IP_EVENT,
|
||||
};
|
||||
|
||||
enum class role {
|
||||
SERVER,
|
||||
CLIENT,
|
||||
};
|
||||
|
||||
struct RpcHeader {
|
||||
api_id id;
|
||||
uint32_t size;
|
||||
} __attribute((__packed__));
|
||||
|
||||
/**
|
||||
* @brief Structure holding the outgoing or incoming parameter
|
||||
*/
|
||||
template<typename T>
|
||||
struct RpcData {
|
||||
RpcHeader head;
|
||||
T value_{};
|
||||
explicit RpcData(api_id id) : head{id, sizeof(T)} {}
|
||||
|
||||
uint8_t *value()
|
||||
{
|
||||
return (uint8_t *) &value_;
|
||||
}
|
||||
|
||||
uint8_t *marshall(T *t, size_t &size)
|
||||
{
|
||||
size = head.size + sizeof(RpcHeader);
|
||||
memcpy(value(), t, sizeof(T));
|
||||
return (uint8_t *) this;
|
||||
}
|
||||
} __attribute((__packed__));
|
||||
|
||||
/**
|
||||
* @brief Singleton holding the static data for either the client or server side
|
||||
*/
|
||||
class RpcInstance;
|
||||
|
||||
/**
|
||||
* @brief Engine that implements a simple RPC mechanism
|
||||
*/
|
||||
class RpcEngine {
|
||||
public:
|
||||
constexpr explicit RpcEngine(role r) : tls_(nullptr), role_(r) {}
|
||||
|
||||
esp_err_t init()
|
||||
{
|
||||
if (tls_ != nullptr) {
|
||||
return ESP_OK;
|
||||
}
|
||||
if (role_ == role::CLIENT) {
|
||||
instance = init_client();
|
||||
}
|
||||
if (role_ == role::SERVER) {
|
||||
instance = init_server();
|
||||
}
|
||||
return instance == nullptr ? ESP_FAIL : ESP_OK;
|
||||
}
|
||||
|
||||
void deinit()
|
||||
{
|
||||
if (tls_ == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (role_ == role::CLIENT) {
|
||||
esp_tls_conn_destroy(tls_);
|
||||
} else if (role_ == role::SERVER) {
|
||||
esp_tls_server_session_delete(tls_);
|
||||
}
|
||||
tls_ = nullptr;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
esp_err_t send(api_id id, T *t)
|
||||
{
|
||||
RpcData<T> req(id);
|
||||
size_t size;
|
||||
auto buf = req.marshall(t, size);
|
||||
ESP_LOGD("rpc", "Sending API id:%d", (int) id);
|
||||
ESP_LOG_BUFFER_HEXDUMP("rpc", buf, size, ESP_LOG_VERBOSE);
|
||||
int len = esp_tls_conn_write(tls_, buf, size);
|
||||
if (len <= 0) {
|
||||
ESP_LOGE("rpc", "Failed to write data to the connection");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t send(api_id id) // overload for (void)
|
||||
{
|
||||
RpcHeader head = {.id = id, .size = 0};
|
||||
int len = esp_tls_conn_write(tls_, &head, sizeof(head));
|
||||
if (len <= 0) {
|
||||
ESP_LOGE("rpc", "Failed to write data to the connection");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
int get_socket_fd()
|
||||
{
|
||||
int sock;
|
||||
if (esp_tls_get_conn_sockfd(tls_, &sock) != ESP_OK) {
|
||||
return -1;
|
||||
}
|
||||
return sock;
|
||||
}
|
||||
|
||||
RpcHeader get_header()
|
||||
{
|
||||
RpcHeader header{};
|
||||
int len = esp_tls_conn_read(tls_, (char *) &header, sizeof(header));
|
||||
if (len <= 0) {
|
||||
if (len < 0 && errno != EAGAIN) {
|
||||
ESP_LOGE("rpc", "Failed to read header data from the connection %d %s", errno, strerror(errno));
|
||||
return {.id = api_id::ERROR, .size = 0};
|
||||
}
|
||||
return {.id = api_id::UNDEF, .size = 0};
|
||||
}
|
||||
return header;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T get_payload(api_id id, RpcHeader &head)
|
||||
{
|
||||
RpcData<T> resp(id);
|
||||
if (head.id != id || head.size != resp.head.size) {
|
||||
ESP_LOGE("rpc", "unexpected header %d %d or sizes %" PRIu32 " %" PRIu32, (int)head.id, (int)id, head.size, resp.head.size);
|
||||
return {};
|
||||
}
|
||||
int len = esp_tls_conn_read(tls_, (char *) resp.value(), resp.head.size);
|
||||
if (len <= 0) {
|
||||
ESP_LOGE("rpc", "Failed to read data from the connection");
|
||||
return {};
|
||||
}
|
||||
return resp.value_;
|
||||
}
|
||||
|
||||
private:
|
||||
RpcInstance *init_server();
|
||||
RpcInstance *init_client();
|
||||
esp_tls_t *tls_;
|
||||
role role_;
|
||||
RpcInstance *instance{nullptr};
|
||||
};
|
||||
|
||||
};
|
||||
@@ -0,0 +1,23 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
struct esp_wifi_remote_config {
|
||||
wifi_interface_t interface;
|
||||
wifi_config_t conf;
|
||||
};
|
||||
|
||||
struct esp_wifi_remote_mac_t {
|
||||
esp_err_t err;
|
||||
uint8_t mac[6];
|
||||
};
|
||||
|
||||
struct esp_wifi_remote_eppp_ip_event {
|
||||
int32_t id;
|
||||
esp_netif_ip_info_t wifi_ip;
|
||||
esp_netif_ip_info_t ppp_ip;
|
||||
esp_netif_dns_info_t dns;
|
||||
};
|
||||
@@ -0,0 +1,383 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include <netdb.h>
|
||||
#include <memory>
|
||||
#include <cerrno>
|
||||
#include <sys/socket.h>
|
||||
#include "esp_log.h"
|
||||
#include "esp_check.h"
|
||||
#include "esp_tls.h"
|
||||
#include "esp_wifi.h"
|
||||
#include "wifi_remote_rpc_impl.hpp"
|
||||
#include "eppp_link.h"
|
||||
#include "wifi_remote_rpc_params.h"
|
||||
#include "lwip/apps/snmp.h"
|
||||
#include "esp_vfs.h"
|
||||
#include "esp_vfs_eventfd.h"
|
||||
|
||||
extern "C" esp_netif_t *wifi_remote_eppp_init(eppp_type_t role);
|
||||
|
||||
namespace eppp_rpc {
|
||||
|
||||
namespace server {
|
||||
const char *TAG = "rpc_server";
|
||||
|
||||
const unsigned char ca_crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_CA "\n-----END CERTIFICATE-----";
|
||||
const unsigned char crt[] = "-----BEGIN CERTIFICATE-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_CRT "\n-----END CERTIFICATE-----";
|
||||
const unsigned char key[] = "-----BEGIN PRIVATE KEY-----\n" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_KEY "\n-----END PRIVATE KEY-----";
|
||||
// TODO: Add option to supply keys and certs via a global symbol (file)
|
||||
|
||||
}
|
||||
|
||||
using namespace server;
|
||||
|
||||
struct Events {
|
||||
api_id type;
|
||||
int32_t id;
|
||||
esp_wifi_remote_eppp_ip_event *ip_data{nullptr};
|
||||
bool clean_ip_data{true};
|
||||
esp_err_t create_ip_data()
|
||||
{
|
||||
ip_data = new (std::nothrow) esp_wifi_remote_eppp_ip_event;
|
||||
return ip_data ? ESP_OK : ESP_ERR_NO_MEM;
|
||||
}
|
||||
~Events()
|
||||
{
|
||||
if (clean_ip_data) {
|
||||
delete ip_data;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class Sync {
|
||||
friend class RpcInstance;
|
||||
public:
|
||||
esp_err_t put(Events &ev)
|
||||
{
|
||||
ESP_RETURN_ON_FALSE(xQueueSend(queue, &ev, pdMS_TO_TICKS(queue_timeout)), ESP_FAIL, TAG, "Failed to queue event %" PRIi32, ev.id);
|
||||
ev.clean_ip_data = false; // IP data were successfully sent to the queue, will free manually after receiving from it
|
||||
uint64_t event_queued = 1;
|
||||
write(fd, &event_queued, sizeof(event_queued)); // trigger the wait loop that
|
||||
return ESP_OK;
|
||||
}
|
||||
Events get()
|
||||
{
|
||||
Events ev{};
|
||||
if (!xQueueReceive(queue, &ev, 0)) {
|
||||
ev.type = api_id::ERROR;
|
||||
}
|
||||
return ev;
|
||||
}
|
||||
esp_err_t init()
|
||||
{
|
||||
queue = xQueueCreate(max_items, sizeof(Events));
|
||||
esp_vfs_eventfd_config_t config = ESP_VFS_EVENTD_CONFIG_DEFAULT();
|
||||
esp_vfs_eventfd_register(&config);
|
||||
fd = eventfd(0, EFD_SUPPORT_ISR);
|
||||
return queue == nullptr || fd < 0 ? ESP_ERR_NO_MEM : ESP_OK;
|
||||
}
|
||||
~Sync()
|
||||
{
|
||||
if (queue) {
|
||||
vQueueDelete(queue);
|
||||
}
|
||||
if (fd >= 0) {
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
int fd{-1};
|
||||
// Used to trigger task by either an internal event or rpc command
|
||||
static const int NONE = 0;
|
||||
static const int ERROR = 1;
|
||||
static const int EVENT = 2;
|
||||
static const int RPC = 4;
|
||||
private:
|
||||
QueueHandle_t queue{nullptr};
|
||||
const int max_items = 15;
|
||||
const int queue_timeout = 200;
|
||||
};
|
||||
|
||||
class RpcInstance {
|
||||
friend class Sync;
|
||||
public:
|
||||
RpcEngine rpc{role::SERVER};
|
||||
int sock{-1};
|
||||
|
||||
esp_err_t init()
|
||||
{
|
||||
ESP_RETURN_ON_FALSE(netif = wifi_remote_eppp_init(EPPP_SERVER), ESP_FAIL, TAG, "Failed to init EPPP connection");
|
||||
ESP_RETURN_ON_ERROR(start_server(), TAG, "Failed to start RPC server");
|
||||
ESP_RETURN_ON_ERROR(rpc.init(), TAG, "Failed to init RPC engine");
|
||||
ESP_RETURN_ON_ERROR(esp_netif_napt_enable(netif), TAG, "Failed to enable NAPT");
|
||||
ESP_RETURN_ON_ERROR(sync.init(), TAG, "Failed to init event queue");
|
||||
ESP_RETURN_ON_ERROR(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, handler, this), TAG, "Failed to register event");
|
||||
ESP_RETURN_ON_ERROR(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, handler, this), TAG, "Failed to register event");
|
||||
return xTaskCreate(task, "server", 8192, this, 5, nullptr) == pdTRUE ? ESP_OK : ESP_FAIL;
|
||||
}
|
||||
Sync sync;
|
||||
private:
|
||||
esp_netif_t *netif{nullptr};
|
||||
static void task(void *ctx)
|
||||
{
|
||||
auto instance = static_cast<RpcInstance *>(ctx);
|
||||
while (instance->perform() == ESP_OK) {}
|
||||
esp_restart();
|
||||
}
|
||||
esp_err_t start_server()
|
||||
{
|
||||
struct sockaddr_in dest_addr = {};
|
||||
int ret;
|
||||
int opt = 1;
|
||||
dest_addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||
dest_addr.sin_family = AF_INET;
|
||||
dest_addr.sin_port = htons(rpc_port);
|
||||
int listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
|
||||
ESP_RETURN_ON_FALSE(listen_sock >= 0, ESP_FAIL, TAG, "Failed to create listening socket");
|
||||
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
||||
ret = bind(listen_sock, (struct sockaddr *) &dest_addr, sizeof(dest_addr));
|
||||
ESP_RETURN_ON_FALSE(ret == 0, ESP_FAIL, TAG, "Failed to bind the listening socket");
|
||||
ret = listen(listen_sock, 1);
|
||||
ESP_RETURN_ON_FALSE(ret == 0, ESP_FAIL, TAG, "Failed to start listening");
|
||||
struct sockaddr_storage source_addr {};
|
||||
socklen_t addr_len = sizeof(source_addr);
|
||||
sock = accept(listen_sock, (struct sockaddr *) &source_addr, &addr_len);
|
||||
ESP_RETURN_ON_FALSE(sock >= 0, ESP_FAIL, TAG, "Failed to accept connections: errno %d", errno);
|
||||
ESP_LOGI(TAG, "Socket accepted on: %s", inet_ntoa(((struct sockaddr_in *) &source_addr)->sin_addr));
|
||||
return ESP_OK;
|
||||
}
|
||||
esp_err_t wifi_event(int32_t id)
|
||||
{
|
||||
ESP_LOGI(TAG, "Received WIFI event %" PRIi32, id);
|
||||
Events ev{api_id::WIFI_EVENT, id, nullptr};
|
||||
ESP_RETURN_ON_ERROR(sync.put(ev), TAG, "Failed to queue WiFi event");
|
||||
return ESP_OK;
|
||||
}
|
||||
esp_err_t ip_event(int32_t id, ip_event_got_ip_t *ip_data)
|
||||
{
|
||||
ESP_LOGI(TAG, "Received IP event %" PRIi32, id);
|
||||
Events ev{api_id::IP_EVENT, id, nullptr};
|
||||
if (ip_data->esp_netif) {
|
||||
ESP_RETURN_ON_ERROR(ev.create_ip_data(), TAG, "Failed to allocate event data");
|
||||
ev.ip_data->id = id;
|
||||
ESP_RETURN_ON_ERROR(esp_netif_get_dns_info(ip_data->esp_netif, ESP_NETIF_DNS_MAIN, &ev.ip_data->dns), TAG, "Failed to get DNS info");
|
||||
ESP_LOGI(TAG, "Main DNS:" IPSTR, IP2STR(&ev.ip_data->dns.ip.u_addr.ip4));
|
||||
memcpy(&ev.ip_data->wifi_ip, &ip_data->ip_info, sizeof(ev.ip_data->wifi_ip));
|
||||
ESP_RETURN_ON_ERROR(esp_netif_get_ip_info(netif, &ev.ip_data->ppp_ip), TAG, "Failed to get IP info");
|
||||
ESP_LOGI(TAG, "IP address:" IPSTR, IP2STR(&ip_data->ip_info.ip));
|
||||
}
|
||||
ESP_RETURN_ON_ERROR(sync.put(ev), TAG, "Failed to queue IP event");
|
||||
return ESP_OK;
|
||||
}
|
||||
static void handler(void *ctx, esp_event_base_t base, int32_t id, void *data)
|
||||
{
|
||||
auto instance = static_cast<RpcInstance *>(ctx);
|
||||
if (base == WIFI_EVENT) {
|
||||
instance->wifi_event(id);
|
||||
} else if (base == IP_EVENT) {
|
||||
auto *ip_data = (ip_event_got_ip_t *)data;
|
||||
instance->ip_event(id, ip_data);
|
||||
}
|
||||
}
|
||||
int select()
|
||||
{
|
||||
struct timeval timeout = { .tv_sec = 1, .tv_usec = 0};
|
||||
int rpc_sock = rpc.get_socket_fd();
|
||||
|
||||
ESP_RETURN_ON_FALSE(rpc_sock != -1, Sync::ERROR, TAG, "failed ot get rpc socket");
|
||||
fd_set readset;
|
||||
fd_set errset;
|
||||
FD_ZERO(&readset);
|
||||
FD_ZERO(&errset);
|
||||
FD_SET(rpc_sock, &readset);
|
||||
FD_SET(sync.fd, &readset);
|
||||
FD_SET(rpc_sock, &errset);
|
||||
int ret = ::select(std::max(rpc_sock, 5) + 1, &readset, nullptr, &errset, &timeout);
|
||||
if (ret == 0) {
|
||||
ESP_LOGV(TAG, "poll_read: select - Timeout before any socket was ready!");
|
||||
return Sync::NONE;
|
||||
}
|
||||
if (ret < 0) {
|
||||
ESP_LOGE(TAG, "select error: %d", errno);
|
||||
return Sync::ERROR;
|
||||
}
|
||||
if (FD_ISSET(rpc_sock, &errset)) {
|
||||
int sock_errno = 0;
|
||||
uint32_t optlen = sizeof(sock_errno);
|
||||
getsockopt(rpc_sock, SOL_SOCKET, SO_ERROR, &sock_errno, &optlen);
|
||||
ESP_LOGE(TAG, "select failed, socket errno = %d", sock_errno);
|
||||
return Sync::ERROR;
|
||||
}
|
||||
int result = Sync::NONE;
|
||||
if (FD_ISSET(rpc_sock, &readset)) {
|
||||
result |= Sync::RPC;
|
||||
}
|
||||
if (FD_ISSET(sync.fd, &readset)) {
|
||||
result |= Sync::EVENT;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
esp_err_t marshall_events()
|
||||
{
|
||||
api_id type;
|
||||
do {
|
||||
Events ev = sync.get();
|
||||
type = ev.type;
|
||||
if (ev.type == api_id::WIFI_EVENT) {
|
||||
ESP_RETURN_ON_ERROR(rpc.send(api_id::WIFI_EVENT, &ev.id), TAG, "Failed to marshall WiFi event");
|
||||
} else if (ev.type == api_id::IP_EVENT && ev.ip_data) {
|
||||
ESP_RETURN_ON_ERROR(rpc.send(api_id::IP_EVENT, ev.ip_data), TAG, "Failed to marshal IP event");
|
||||
}
|
||||
} while (type != api_id::ERROR);
|
||||
return ESP_OK;
|
||||
}
|
||||
esp_err_t perform()
|
||||
{
|
||||
auto res = select();
|
||||
if (res == Sync::ERROR) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
if (res & Sync::EVENT) {
|
||||
uint64_t data;
|
||||
read(sync.fd, &data, sizeof(data));
|
||||
if (marshall_events() != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
}
|
||||
if (res & Sync::RPC) {
|
||||
if (handle_commands() != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t handle_commands()
|
||||
{
|
||||
auto header = rpc.get_header();
|
||||
ESP_LOGI(TAG, "Received header id %d", (int) header.id);
|
||||
switch (header.id) {
|
||||
case api_id::SET_MODE: {
|
||||
auto req = rpc.get_payload<wifi_mode_t>(api_id::SET_MODE, header);
|
||||
auto ret = esp_wifi_set_mode(req);
|
||||
if (rpc.send(api_id::SET_MODE, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::INIT: {
|
||||
auto req = rpc.get_payload<wifi_init_config_t>(api_id::INIT, header);
|
||||
req.osi_funcs = &g_wifi_osi_funcs;
|
||||
req.wpa_crypto_funcs = g_wifi_default_wpa_crypto_funcs;
|
||||
auto ret = esp_wifi_init(&req);
|
||||
if (rpc.send(api_id::INIT, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::SET_CONFIG: {
|
||||
auto req = rpc.get_payload<esp_wifi_remote_config>(api_id::SET_CONFIG, header);
|
||||
auto ret = esp_wifi_set_config(req.interface, &req.conf);
|
||||
if (rpc.send(api_id::SET_CONFIG, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::START: {
|
||||
if (header.size != 0) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
auto ret = esp_wifi_start();
|
||||
if (rpc.send(api_id::START, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::CONNECT: {
|
||||
if (header.size != 0) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
auto ret = esp_wifi_connect();
|
||||
if (rpc.send(api_id::CONNECT, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::DISCONNECT: {
|
||||
if (header.size != 0) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
auto ret = esp_wifi_disconnect();
|
||||
if (rpc.send(api_id::DISCONNECT, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::DEINIT: {
|
||||
if (header.size != 0) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
auto ret = esp_wifi_deinit();
|
||||
if (rpc.send(api_id::DEINIT, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::SET_STORAGE: {
|
||||
auto req = rpc.get_payload<wifi_storage_t>(api_id::SET_STORAGE, header);
|
||||
auto ret = esp_wifi_set_storage(req);
|
||||
if (rpc.send(api_id::SET_STORAGE, &ret) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case api_id::GET_MAC: {
|
||||
auto req = rpc.get_payload<wifi_interface_t>(api_id::GET_MAC, header);
|
||||
esp_wifi_remote_mac_t resp = {};
|
||||
resp.err = esp_wifi_get_mac(req, resp.mac);
|
||||
if (rpc.send(api_id::GET_MAC, &resp) != ESP_OK) {
|
||||
return ESP_FAIL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
namespace server {
|
||||
constinit RpcInstance instance;
|
||||
}
|
||||
|
||||
RpcInstance *RpcEngine::init_server()
|
||||
{
|
||||
esp_tls_cfg_server_t cfg = {};
|
||||
cfg.cacert_buf = server::ca_crt;
|
||||
cfg.cacert_bytes = sizeof(server::ca_crt);
|
||||
cfg.servercert_buf = server::crt;
|
||||
cfg.servercert_bytes = sizeof(server::crt);
|
||||
cfg.serverkey_buf = server::key;
|
||||
cfg.serverkey_bytes = sizeof(server::key);
|
||||
|
||||
ESP_RETURN_ON_FALSE(tls_ = esp_tls_init(), nullptr, TAG, "Failed to create ESP-TLS instance");
|
||||
ESP_RETURN_ON_FALSE(esp_tls_server_session_create(&cfg, server::instance.sock, tls_) == ESP_OK, nullptr, TAG, "Failed to create TLS session");
|
||||
return &server::instance;
|
||||
}
|
||||
|
||||
} // namespace eppp_rpc
|
||||
|
||||
using namespace eppp_rpc;
|
||||
|
||||
extern "C" esp_err_t server_init(void)
|
||||
{
|
||||
return server::instance.init();
|
||||
}
|
||||
Reference in New Issue
Block a user