OVMS3-idf/components/wifi_provisioning/src/wifi_scan.c
Anurag Kar 9c0ee28670 wifi_provisioning : Added Wi-Fi Scan list feature to Provisioning Manager
List of changes in components/wifi_provisioning:
* Manager version is now v1.1
* .proto files and protocomm handler added for sending Wi-Fi scan command and receiving scan results
* Implemented handlers for wifi_scan protocomm endpoint
* Update manager context data structure to hold scan state and results
* scheme_softap now runs Wi-Fi in APSTA mode
* Wi-Fi is started in AP mode when provisioning is started. This is necessary for scan list to work
* Docs updates with information about new wifi_scan endpoint

List of changes in tools/esp_prov:
* Added functions for sending and receiving protobuf messages compatible with wifi_scan protocomm endpoint
* Added feature to display/refresh scan results and accept user selection at runtime
* New functions:
  * get_version() : only returns the protocol version string
  * has_capability() : check is a capability is present according to proto-ver response
* wifi_scan feature is provided only if the `wifi_scan` capability is present

Other changes:
* Replace recursive mutex with plain mutex
* assert on return value of mutex give / take calls
* replace all calls with macros ACQUIRE_LOCK and RELEASE_LOCK
* some checks added in scanning related private APIs
* free and nullify scanning context and state if service is stopped while ongoing scan
2019-06-26 05:24:20 +00:00

297 lines
10 KiB
C

// 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 <esp_log.h>
#include <string.h>
#include <esp_err.h>
#include <esp_wifi.h>
#include "wifi_scan.pb-c.h"
#include <wifi_provisioning/wifi_scan.h>
static const char *TAG = "proto_wifi_scan";
typedef struct wifi_prov_scan_cmd {
int cmd_num;
esp_err_t (*command_handler)(WiFiScanPayload *req,
WiFiScanPayload *resp, void *priv_data);
} wifi_prov_scan_cmd_t;
static esp_err_t cmd_scan_start_handler(WiFiScanPayload *req,
WiFiScanPayload *resp,
void *priv_data);
static esp_err_t cmd_scan_status_handler(WiFiScanPayload *req,
WiFiScanPayload *resp,
void *priv_data);
static esp_err_t cmd_scan_result_handler(WiFiScanPayload *req,
WiFiScanPayload *resp,
void *priv_data);
static wifi_prov_scan_cmd_t cmd_table[] = {
{
.cmd_num = WI_FI_SCAN_MSG_TYPE__TypeCmdScanStart,
.command_handler = cmd_scan_start_handler
},
{
.cmd_num = WI_FI_SCAN_MSG_TYPE__TypeCmdScanStatus,
.command_handler = cmd_scan_status_handler
},
{
.cmd_num = WI_FI_SCAN_MSG_TYPE__TypeCmdScanResult,
.command_handler = cmd_scan_result_handler
}
};
static esp_err_t cmd_scan_start_handler(WiFiScanPayload *req,
WiFiScanPayload *resp, void *priv_data)
{
wifi_prov_scan_handlers_t *h = (wifi_prov_scan_handlers_t *) priv_data;
if (!h) {
ESP_LOGE(TAG, "Command invoked without handlers");
return ESP_ERR_INVALID_STATE;
}
RespScanStart *resp_payload = (RespScanStart *) malloc(sizeof(RespScanStart));
if (!resp_payload) {
ESP_LOGE(TAG, "Error allocating memory");
return ESP_ERR_NO_MEM;
}
resp_scan_start__init(resp_payload);
resp->status = (h->scan_start(req->cmd_scan_start->blocking,
req->cmd_scan_start->passive,
req->cmd_scan_start->group_channels,
req->cmd_scan_start->period_ms,
&h->ctx) == ESP_OK ?
STATUS__Success : STATUS__InternalError);
resp->payload_case = WI_FI_SCAN_PAYLOAD__PAYLOAD_RESP_SCAN_START;
resp->resp_scan_start = resp_payload;
return ESP_OK;
}
static esp_err_t cmd_scan_status_handler(WiFiScanPayload *req,
WiFiScanPayload *resp, void *priv_data)
{
bool scan_finished = false;
uint16_t result_count = 0;
wifi_prov_scan_handlers_t *h = (wifi_prov_scan_handlers_t *) priv_data;
if (!h) {
ESP_LOGE(TAG, "Command invoked without handlers");
return ESP_ERR_INVALID_STATE;
}
RespScanStatus *resp_payload = (RespScanStatus *) malloc(sizeof(RespScanStatus));
if (!resp_payload) {
ESP_LOGE(TAG, "Error allocating memory");
return ESP_ERR_NO_MEM;
}
resp_scan_status__init(resp_payload);
resp->status = (h->scan_status(&scan_finished, &result_count, &h->ctx) == ESP_OK ?
STATUS__Success : STATUS__InternalError);
resp_payload->scan_finished = scan_finished;
resp_payload->result_count = result_count;
resp->payload_case = WI_FI_SCAN_PAYLOAD__PAYLOAD_RESP_SCAN_STATUS;
resp->resp_scan_status = resp_payload;
return ESP_OK;
}
static esp_err_t cmd_scan_result_handler(WiFiScanPayload *req,
WiFiScanPayload *resp, void *priv_data)
{
esp_err_t err;
wifi_prov_scan_result_t scan_result = {{0}, {0}, 0, 0, 0};
WiFiScanResult **results = NULL;
wifi_prov_scan_handlers_t *h = (wifi_prov_scan_handlers_t *) priv_data;
if (!h) {
ESP_LOGE(TAG, "Command invoked without handlers");
return ESP_ERR_INVALID_STATE;
}
RespScanResult *resp_payload = (RespScanResult *) malloc(sizeof(RespScanResult));
if (!resp_payload) {
ESP_LOGE(TAG, "Error allocating memory");
return ESP_ERR_NO_MEM;
}
resp_scan_result__init(resp_payload);
resp->status = STATUS__Success;
resp->payload_case = WI_FI_SCAN_PAYLOAD__PAYLOAD_RESP_SCAN_RESULT;
resp->resp_scan_result = resp_payload;
results = (WiFiScanResult **) calloc(req->cmd_scan_result->count,
sizeof(WiFiScanResult *));
if (!results) {
ESP_LOGE(TAG, "Failed to allocate memory for results array");
return ESP_ERR_NO_MEM;
}
resp_payload->entries = results;
resp_payload->n_entries = req->cmd_scan_result->count;
for (uint16_t i = 0; i < req->cmd_scan_result->count; i++) {
err = h->scan_result(i + req->cmd_scan_result->start_index,
&scan_result, &h->ctx);
if (err != ESP_OK) {
resp->status = STATUS__InternalError;
break;
}
results[i] = (WiFiScanResult *) malloc(sizeof(WiFiScanResult));
if (!results[i]) {
ESP_LOGE(TAG, "Failed to allocate memory for result entry");
return ESP_ERR_NO_MEM;
}
wi_fi_scan_result__init(results[i]);
results[i]->ssid.len = strnlen(scan_result.ssid, 32);
results[i]->ssid.data = (uint8_t *) strndup(scan_result.ssid, 32);
if (!results[i]->ssid.data) {
ESP_LOGE(TAG, "Failed to allocate memory for scan result entry SSID");
return ESP_ERR_NO_MEM;
}
results[i]->channel = scan_result.channel;
results[i]->rssi = scan_result.rssi;
results[i]->auth = scan_result.auth;
results[i]->bssid.len = sizeof(scan_result.bssid);
results[i]->bssid.data = malloc(results[i]->bssid.len);
if (!results[i]->bssid.data) {
ESP_LOGE(TAG, "Failed to allocate memory for scan result entry BSSID");
return ESP_ERR_NO_MEM;
}
memcpy(results[i]->bssid.data, scan_result.bssid, results[i]->bssid.len);
}
return ESP_OK;
}
static int lookup_cmd_handler(int cmd_id)
{
int i;
for (i = 0; i < sizeof(cmd_table)/sizeof(wifi_prov_scan_cmd_t); i++) {
if (cmd_table[i].cmd_num == cmd_id) {
return i;
}
}
return -1;
}
static void wifi_prov_scan_cmd_cleanup(WiFiScanPayload *resp, void *priv_data)
{
switch (resp->msg) {
case WI_FI_SCAN_MSG_TYPE__TypeRespScanStart:
{
free(resp->resp_scan_start);
}
break;
case WI_FI_SCAN_MSG_TYPE__TypeRespScanStatus:
{
free(resp->resp_scan_status);
}
break;
case WI_FI_SCAN_MSG_TYPE__TypeRespScanResult:
{
if (!resp->resp_scan_result) return;
if (resp->resp_scan_result->entries) {
for (uint16_t i = 0; i < resp->resp_scan_result->n_entries; i++) {
if (!resp->resp_scan_result->entries[i]) continue;
free(resp->resp_scan_result->entries[i]->ssid.data);
free(resp->resp_scan_result->entries[i]->bssid.data);
free(resp->resp_scan_result->entries[i]);
}
free(resp->resp_scan_result->entries);
}
free(resp->resp_scan_result);
}
break;
default:
ESP_LOGE(TAG, "Unsupported response type in cleanup_handler");
break;
}
return;
}
static esp_err_t wifi_prov_scan_cmd_dispatcher(WiFiScanPayload *req,
WiFiScanPayload *resp, void *priv_data)
{
esp_err_t ret;
ESP_LOGD(TAG, "In wifi_prov_scan_cmd_dispatcher Cmd=%d", req->msg);
int cmd_index = lookup_cmd_handler(req->msg);
if (cmd_index < 0) {
ESP_LOGE(TAG, "Invalid command handler lookup");
return ESP_FAIL;
}
ret = cmd_table[cmd_index].command_handler(req, resp, priv_data);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Error executing command handler");
return ESP_FAIL;
}
return ESP_OK;
}
esp_err_t wifi_prov_scan_handler(uint32_t session_id, const uint8_t *inbuf, ssize_t inlen,
uint8_t **outbuf, ssize_t *outlen, void *priv_data)
{
WiFiScanPayload *req;
WiFiScanPayload resp;
esp_err_t ret = ESP_OK;
req = wi_fi_scan_payload__unpack(NULL, inlen, inbuf);
if (!req) {
ESP_LOGE(TAG, "Unable to unpack scan message");
return ESP_ERR_INVALID_ARG;
}
wi_fi_scan_payload__init(&resp);
ret = wifi_prov_scan_cmd_dispatcher(req, &resp, priv_data);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Command dispatcher error %d", ret);
ret = ESP_FAIL;
goto exit;
}
resp.msg = req->msg + 1; /* Response is request + 1 */
*outlen = wi_fi_scan_payload__get_packed_size(&resp);
if (*outlen <= 0) {
ESP_LOGE(TAG, "Invalid encoding for response");
ret = ESP_FAIL;
goto exit;
}
*outbuf = (uint8_t *) malloc(*outlen);
if (!*outbuf) {
ESP_LOGE(TAG, "System out of memory");
ret = ESP_ERR_NO_MEM;
goto exit;
}
wi_fi_scan_payload__pack(&resp, *outbuf);
ESP_LOGD(TAG, "Response packet size : %d", *outlen);
exit:
wi_fi_scan_payload__free_unpacked(req, NULL);
wifi_prov_scan_cmd_cleanup(&resp, priv_data);
return ret;
}