mirror of
https://github.com/espressif/esp-idf.git
synced 2025-08-08 20:21:04 +00:00
ESP Local Control Feature Added
List of changes: * New component esp_local_ctrl added * Example added under examples/protocols/esp_local_ctrl * Documentation added under protocols/esp_local_ctrl * Demo client side app esp_local_ctrl.py added under examples/protocols/esp_local_ctrl/scripts * protocomm_ble : protocomm_ble_config_t given struct name for allowing forward declaration * esp_prov/transport_softap renamed to transport_http * transport_http module supports verification of server certificate * transport_http module performs name resolution before connection
This commit is contained in:
Anurag Kar
298
components/esp_local_ctrl/src/esp_local_ctrl_handler.c
Normal file
298
components/esp_local_ctrl/src/esp_local_ctrl_handler.c
Normal file
@@ -0,0 +1,298 @@
|
||||
// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <esp_err.h>
|
||||
#include <esp_log.h>
|
||||
|
||||
#include "esp_local_ctrl.h"
|
||||
#include "esp_local_ctrl_priv.h"
|
||||
#include "esp_local_ctrl.pb-c.h"
|
||||
|
||||
#define SAFE_ALLOCATION(type, var) \
|
||||
type *var = (type *) malloc(sizeof(type)); \
|
||||
if (!var) { \
|
||||
ESP_LOGE(TAG, "Error allocating memory"); \
|
||||
return ESP_ERR_NO_MEM; \
|
||||
}
|
||||
|
||||
static const char* TAG = "esp_local_ctrl_handler";
|
||||
|
||||
typedef struct esp_local_ctrl_cmd {
|
||||
int cmd_num;
|
||||
esp_err_t (*command_handler)(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx);
|
||||
} esp_local_ctrl_cmd_t;
|
||||
|
||||
static esp_err_t cmd_get_prop_count_handler(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx);
|
||||
|
||||
static esp_err_t cmd_get_prop_vals_handler(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx);
|
||||
|
||||
static esp_err_t cmd_set_prop_vals_handler(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx);
|
||||
|
||||
static esp_local_ctrl_cmd_t cmd_table[] = {
|
||||
{
|
||||
.cmd_num = LOCAL_CTRL_MSG_TYPE__TypeCmdGetPropertyCount,
|
||||
.command_handler = cmd_get_prop_count_handler
|
||||
},
|
||||
{
|
||||
.cmd_num = LOCAL_CTRL_MSG_TYPE__TypeCmdGetPropertyValues,
|
||||
.command_handler = cmd_get_prop_vals_handler
|
||||
},
|
||||
{
|
||||
.cmd_num = LOCAL_CTRL_MSG_TYPE__TypeCmdSetPropertyValues,
|
||||
.command_handler = cmd_set_prop_vals_handler
|
||||
}
|
||||
};
|
||||
|
||||
static uint16_t err_to_status(esp_err_t err)
|
||||
{
|
||||
uint16_t status;
|
||||
switch (err) {
|
||||
case ESP_OK:
|
||||
status = STATUS__Success;
|
||||
break;
|
||||
case ESP_ERR_INVALID_ARG:
|
||||
status = STATUS__InvalidArgument;
|
||||
break;
|
||||
case ESP_ERR_INVALID_STATE:
|
||||
status = STATUS__InvalidProto;
|
||||
break;
|
||||
default:
|
||||
status = STATUS__InternalError;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
static esp_err_t cmd_get_prop_count_handler(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx)
|
||||
{
|
||||
SAFE_ALLOCATION(RespGetPropertyCount, resp_payload);
|
||||
resp_get_property_count__init(resp_payload);
|
||||
|
||||
size_t prop_count = 0;
|
||||
resp_payload->status = err_to_status(esp_local_ctrl_get_prop_count(&prop_count));
|
||||
resp_payload->count = prop_count;
|
||||
resp->payload_case = LOCAL_CTRL_MESSAGE__PAYLOAD_RESP_GET_PROP_COUNT;
|
||||
resp->resp_get_prop_count = resp_payload;
|
||||
ESP_LOGD(TAG, "Got properties count %d", prop_count);
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
typedef void (*prop_val_free_fn_t)(void *val);
|
||||
|
||||
static esp_err_t cmd_get_prop_vals_handler(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx)
|
||||
{
|
||||
SAFE_ALLOCATION(RespGetPropertyValues, resp_payload);
|
||||
resp_get_property_values__init(resp_payload);
|
||||
|
||||
esp_local_ctrl_prop_val_t *vals = calloc(req->cmd_get_prop_vals->n_indices,
|
||||
sizeof(esp_local_ctrl_prop_val_t));
|
||||
esp_local_ctrl_prop_t *descs = calloc(req->cmd_get_prop_vals->n_indices,
|
||||
sizeof(esp_local_ctrl_prop_t));
|
||||
prop_val_free_fn_t *free_fns = calloc(req->cmd_get_prop_vals->n_indices,
|
||||
sizeof(prop_val_free_fn_t));
|
||||
resp_payload->props = calloc(req->cmd_get_prop_vals->n_indices,
|
||||
sizeof(PropertyInfo *));
|
||||
if (!vals || !descs || !free_fns || !resp_payload->props) {
|
||||
ESP_LOGE(TAG, "Failed to allocate memory for getting values");
|
||||
free(vals);
|
||||
free(descs);
|
||||
free(free_fns);
|
||||
free(resp_payload->props);
|
||||
free(resp_payload);
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
|
||||
esp_err_t ret = esp_local_ctrl_get_prop_values(req->cmd_get_prop_vals->n_indices,
|
||||
req->cmd_get_prop_vals->indices,
|
||||
descs, vals);
|
||||
resp_payload->status = err_to_status(ret);
|
||||
if (ret == ESP_OK) {
|
||||
resp_payload->n_props = 0;
|
||||
for (size_t i = 0; i < req->cmd_get_prop_vals->n_indices; i++) {
|
||||
resp_payload->props[i] = malloc(sizeof(PropertyInfo));
|
||||
if (!resp_payload->props[i]) {
|
||||
resp_payload->status = STATUS__InternalError;
|
||||
break;
|
||||
}
|
||||
resp_payload->n_props++;
|
||||
property_info__init(resp_payload->props[i]);
|
||||
resp_payload->props[i]->name = descs[i].name;
|
||||
resp_payload->props[i]->type = descs[i].type;
|
||||
resp_payload->props[i]->flags = descs[i].flags;
|
||||
resp_payload->props[i]->value.data = vals[i].data;
|
||||
resp_payload->props[i]->value.len = vals[i].size;
|
||||
free_fns[i] = vals[i].free_fn;
|
||||
}
|
||||
}
|
||||
resp->payload_case = LOCAL_CTRL_MESSAGE__PAYLOAD_RESP_GET_PROP_VALS;
|
||||
resp->resp_get_prop_vals = resp_payload;
|
||||
(*ctx) = (void *)free_fns;
|
||||
free(vals);
|
||||
free(descs);
|
||||
|
||||
/* Unless it's a fatal error, always return ESP_OK, otherwise
|
||||
* the underlying connection will be closed by protocomm */
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static esp_err_t cmd_set_prop_vals_handler(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp, void **ctx)
|
||||
{
|
||||
SAFE_ALLOCATION(RespSetPropertyValues, resp_payload);
|
||||
resp_set_property_values__init(resp_payload);
|
||||
|
||||
uint32_t *idxs = calloc(req->cmd_set_prop_vals->n_props, sizeof(uint32_t));
|
||||
esp_local_ctrl_prop_val_t *vals = calloc(req->cmd_set_prop_vals->n_props,
|
||||
sizeof(esp_local_ctrl_prop_val_t));
|
||||
if (!idxs || !vals) {
|
||||
ESP_LOGE(TAG, "Failed to allocate memory for setting values");
|
||||
free(idxs);
|
||||
free(vals);
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
for (size_t i = 0; i < req->cmd_set_prop_vals->n_props; i++) {
|
||||
idxs[i] = req->cmd_set_prop_vals->props[i]->index;
|
||||
vals[i].data = req->cmd_set_prop_vals->props[i]->value.data;
|
||||
vals[i].size = req->cmd_set_prop_vals->props[i]->value.len;
|
||||
}
|
||||
|
||||
esp_err_t ret = esp_local_ctrl_set_prop_values(req->cmd_set_prop_vals->n_props,
|
||||
idxs, vals);
|
||||
resp_payload->status = err_to_status(ret);
|
||||
resp->payload_case = LOCAL_CTRL_MESSAGE__PAYLOAD_RESP_SET_PROP_VALS;
|
||||
resp->resp_set_prop_vals = resp_payload;
|
||||
free(idxs);
|
||||
free(vals);
|
||||
|
||||
/* Unless it's a fatal error, always return ESP_OK, otherwise
|
||||
* the underlying connection will be closed by protocomm */
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static int lookup_cmd_handler(int cmd_id)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < sizeof(cmd_table)/sizeof(esp_local_ctrl_cmd_t); i++) {
|
||||
if (cmd_table[i].cmd_num == cmd_id) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void esp_local_ctrl_command_cleanup(LocalCtrlMessage *resp, void **ctx)
|
||||
{
|
||||
if (!resp) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch (resp->msg) {
|
||||
case LOCAL_CTRL_MSG_TYPE__TypeRespGetPropertyCount:
|
||||
free(resp->resp_get_prop_count);
|
||||
break;
|
||||
case LOCAL_CTRL_MSG_TYPE__TypeRespGetPropertyValues: {
|
||||
if (resp->resp_get_prop_vals) {
|
||||
prop_val_free_fn_t *free_fns = (prop_val_free_fn_t *)(*ctx);
|
||||
for (size_t i = 0; i < resp->resp_get_prop_vals->n_props; i++) {
|
||||
if (free_fns[i]) {
|
||||
free_fns[i](resp->resp_get_prop_vals->props[i]->value.data);
|
||||
}
|
||||
free(resp->resp_get_prop_vals->props[i]);
|
||||
}
|
||||
free(free_fns);
|
||||
free(resp->resp_get_prop_vals->props);
|
||||
free(resp->resp_get_prop_vals);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case LOCAL_CTRL_MSG_TYPE__TypeRespSetPropertyValues:
|
||||
free(resp->resp_set_prop_vals);
|
||||
break;
|
||||
default:
|
||||
ESP_LOGE(TAG, "Unsupported response type in cleanup_handler");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
static esp_err_t esp_local_ctrl_command_dispatcher(LocalCtrlMessage *req,
|
||||
LocalCtrlMessage *resp,
|
||||
void **ctx)
|
||||
{
|
||||
int cmd_index = lookup_cmd_handler(req->msg);
|
||||
if (cmd_index < 0) {
|
||||
ESP_LOGE(TAG, "Invalid command handler lookup");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
esp_err_t ret = cmd_table[cmd_index].command_handler(req, resp, ctx);
|
||||
if (ret != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Error executing command handler");
|
||||
return ret;
|
||||
}
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t esp_local_ctrl_data_handler(uint32_t session_id, const uint8_t *inbuf, ssize_t inlen,
|
||||
uint8_t **outbuf, ssize_t *outlen, void *priv_data)
|
||||
{
|
||||
void *temp_ctx = NULL;
|
||||
LocalCtrlMessage *req = local_ctrl_message__unpack(NULL, inlen, inbuf);
|
||||
if (!req) {
|
||||
ESP_LOGE(TAG, "Unable to unpack payload data");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
|
||||
LocalCtrlMessage resp;
|
||||
local_ctrl_message__init(&resp);
|
||||
resp.msg = req->msg + 1; /* Response is request + 1 */
|
||||
|
||||
esp_err_t ret = esp_local_ctrl_command_dispatcher(req, &resp, &temp_ctx);
|
||||
if (ret != ESP_OK) {
|
||||
ESP_LOGE(TAG, "command dispatcher failed");
|
||||
esp_local_ctrl_command_cleanup(&resp, &temp_ctx);
|
||||
local_ctrl_message__free_unpacked(req, NULL);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
local_ctrl_message__free_unpacked(req, NULL);
|
||||
|
||||
*outlen = local_ctrl_message__get_packed_size(&resp);
|
||||
if (*outlen <= 0) {
|
||||
ESP_LOGE(TAG, "Invalid encoding for response");
|
||||
esp_local_ctrl_command_cleanup(&resp, &temp_ctx);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
*outbuf = (uint8_t *) malloc(*outlen);
|
||||
if (!*outbuf) {
|
||||
ESP_LOGE(TAG, "System out of memory");
|
||||
esp_local_ctrl_command_cleanup(&resp, &temp_ctx);
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
|
||||
local_ctrl_message__pack(&resp, *outbuf);
|
||||
esp_local_ctrl_command_cleanup(&resp, &temp_ctx);
|
||||
ESP_LOG_BUFFER_HEX_LEVEL(TAG, *outbuf, *outlen, ESP_LOG_DEBUG);
|
||||
return ESP_OK;
|
||||
}
|
||||
Reference in New Issue
Block a user