commit 55b2392a3435720f0f169ed5d2fe39b271beb0ce Author: PrincessPi3 Date: Fri Oct 10 16:25:46 2025 -0600 initial commit via gitinitshit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8055f6a --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +build +old +*.old* +*.tmp* +*.bak* +sdkconfig diff --git a/Links.md b/Links.md new file mode 100644 index 0000000..8ffb3af --- /dev/null +++ b/Links.md @@ -0,0 +1,47 @@ +# Links and Resources +## General +* [ESP-IDF Github (v5.5)](https://github.com/espressif/esp-idf/tree/release/v5.5) +* [ESP-IDF Examples (v5.5)](https://github.com/espressif/esp-idf/tree/release/v5.5/examples) +* [esp-idf-tools (master)](https://github.com/PrincessPi3/esp-idf-tools) + +## Devkit WT99P4C5-S1 +* [Product Page](https://en.wireless-tag.com/product-item-66.html) +* [Sale Page (Aliexpress)](https://www.aliexpress.us/item/3256809513099697.html) +* [Guide](assets/devkit/WT99P4C5-S1_Guide_en_v1.2.pdf) +* [Schematic](assets/devkit/WT99P4C5-S1_Guide_en_v1.2.pdf) +* [Github Examples](https://github.com/wireless-tag-com/DevBoard/tree/WT99P4C5-S1) + +## ESP32-C5 +* [Product Page](https://www.espressif.com/en/products/socs/esp32-c5) +* [ESP-IDF Docs (C5)](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32c5/index.html) + * esp-hosted docs + * esp-hosted slave docs + * esp-idf example slave +* [ESP32-C5 Datasheet (Pre-Release v0.6)](assets/esp32c5/esp32-c5-wroom-1_wroom-1u_datasheet_en.pdf) +* [ESP32-C5 Technical Reference (Pre-Release v0.2)](assets/esp32c5/esp32-c5_technical_reference_manual_en.pdf) + +## ESP32-P4 +* [Product Page](https://www.espressif.com/en/products/socs/esp32-p4) +* [ESP-IDF Docs (P4)](https://docs.espressif.com/projects/esp-idf/en/v5.5/esp32p4/index.html) + * [Remote Control Transceiver Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-reference/peripherals/rmt.html) + * [ESP-IDF Examples RMT](https://github.com/espressif/esp-idf/tree/release/v5.5/examples/peripherals/rmt) + * [Dedicated GPIO Docs](https://docs.espressif.com/projects/esp-idf/en/v5.5/esp32p4/api-reference/peripherals/dedic_gpio.html) + [ESP-IDF Examples Dedicated GPIO](https://github.com/espressif/esp-idf/tree/release/v5.5/examples/peripherals/dedicated_gpio) + * [ADC Continuous Mode Docs](https://docs.espressif.com/projects/esp-idf/en/v5.5/esp32p4/api-reference/peripherals/adc_continuous.html) + * [ESP-IDF Example ADC DMA](https://github.com/espressif/esp-idf/tree/v5.5/examples/peripherals/adc/continuous_read) + * [Console Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-reference/system/console.html) + * [ESP-IDF Examples Console](https://github.com/espressif/esp-idf/tree/02c5f2db/examples/system/console/) + * [FreeRTOS IDF Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-reference/system/freertos_idf.html) + * [ESP-IDF Examples FreeRTOS](https://github.com/espressif/esp-idf/tree/release/v5.5/examples/system/freertos) + * [Inter-Processor Call (IPC) Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-reference/system/ipc.html) + * [ESP-IDF Examples IPC RISCV](https://github.com/espressif/esp-idf/tree/release/v5.5/examples/system/ipc/ipc_isr/riscv) + * [Low Power Core (LP) Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-reference/system/ulp-lp-core.html) + * [ESP-IDf Examples LP](https://github.com/espressif/esp-idf/tree/release/v5.5/examples/system/ulp/lp_core) + * [PSRAM/SPI RAM/External RAM Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-guides/external-ram.html) + * [Execute In Place (XIP) Docs](https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32p4/api-guides/external-ram.html#external-ram-config-xip) + * [ESP-IDF Example XIP](https://github.com/espressif/esp-idf/tree/release/v5.5/examples/system/xip_from_psram) + * [ESP-Hosted-NG Docs](https://github.com/espressif/esp-hosted/blob/release/fg-v1.0.0.0.0/esp_hosted_ng/README.md) + * [ESP-Hosted-NG Github (release fg-v1.0.0.0.0)](https://github.com/espressif/esp-hosted/tree/release/fg-v1.0.0.0.0) + * ESP-Hosted-NG Host device +* [ESP32-P4 Datasheet (Pre-Release v0.5)](assets/esp32p4/esp32-p4_datasheet_en.pdf) +* [ESP32-P4 Technical Reference (Pre-Release v0.1)](assets/esp32p4/esp32-p4_technical_reference_manual_en.pdf) \ No newline at end of file diff --git a/Notes.md b/Notes.md new file mode 100644 index 0000000..e967c2d --- /dev/null +++ b/Notes.md @@ -0,0 +1,32 @@ +ESP-Hosted + slave is the device used for its wireless (esp) + host is the master device (linux or esp) +ESP-Hosted-MCU + esp to esp + uses esp-wifi-remote under the hood +ESP-Hosted-NG + esp to linux as native device +ESP-Hosted-FG + esp to linux with some shit +ESP-Wifi-Remote (old? different) + host p4/h2 to slave esp (goes on p4/h2/master/host) + https://github.com/espressif/esp-hosted-mcu/tree/main/host + +ESP-Hosted-MCU + host esp (p4/h2) using slave esp (c6/c61/c5) for wireless + https://github.com/espressif/esp-hosted-mcu/ + ESP-Hosted-MCU/host + goes on host p4/h2 + https://github.com/espressif/esp-hosted-mcu/tree/main/host + ESP-Hosted-MCU/slave + goes on slave esp + https://github.com/espressif/esp-hosted-mcu/tree/main/slave + ESP-Hosted-MCU/examples + test code + https://github.com/espressif/esp-hosted-mcu/tree/main/examples + + When flashing slave device, esp-prog is preferred + note io0 on devkit is boot on esp-prog + +devkis + c5 over sdio \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..091ef05 --- /dev/null +++ b/README.md @@ -0,0 +1,16 @@ +# SillyFilly Hardware Attack Tool (SFHAT) +## A hardware hacking tool made on the ESP32-P4+ESP32C5 stack + +## Software +1. [ESP-IDF v5.5](https://github.com/espressif/esp-idf/tree/release/v5.5) +2. [esp-idf-tools latest](https://github.com/PrincessPi3/esp-idf-tools) + +## Hardware +### Devkit WT99P4C5-S1 +* [Product Page](https://en.wireless-tag.com/product-item-66.html) +* [Sale Page (Aliexpress)](https://www.aliexpress.us/item/3256809513099697.html) + +## License + [![WTFPL](assets/wtfpl/wtfpl-badge-1.png)](http://www.wtfpl.net/) +Distributed under the [WTFPL Version 2](http://www.wtfpl.net/) +See [assets/COPYING.txt](assets/wtfpl/COPYING.txt) for text diff --git a/SillyFilly-Hardware-Attack-Tool/esp-hosted-mcu-git-commit-hash.txt b/SillyFilly-Hardware-Attack-Tool/esp-hosted-mcu-git-commit-hash.txt new file mode 100644 index 0000000..6c7dc5e --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/esp-hosted-mcu-git-commit-hash.txt @@ -0,0 +1 @@ +8119dac diff --git a/SillyFilly-Hardware-Attack-Tool/esp-idf-git-commit-hash.txt b/SillyFilly-Hardware-Attack-Tool/esp-idf-git-commit-hash.txt new file mode 100644 index 0000000..bfa7ea2 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/esp-idf-git-commit-hash.txt @@ -0,0 +1 @@ +3316e9d diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/CMakeLists.txt b/SillyFilly-Hardware-Attack-Tool/host_p4/CMakeLists.txt new file mode 100644 index 0000000..8b2efda --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/CMakeLists.txt @@ -0,0 +1,12 @@ +# The following lines of boilerplate have to be in your project's CMakeLists +# in this exact order for cmake to work correctly +cmake_minimum_required(VERSION 3.16) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) + +# for disable 80211 sanity check +add_link_options("-Wl,-z,muldefs") + +# "Trim" the build. Include the minimal set of components, main, and anything it depends on. +idf_build_set_property(MINIMAL_BUILD ON) +project(p4_host) diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/CMakeLists.txt b/SillyFilly-Hardware-Attack-Tool/host_p4/main/CMakeLists.txt new file mode 100644 index 0000000..ad4be79 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/CMakeLists.txt @@ -0,0 +1,6 @@ +idf_component_register(SRCS "itwt_main.c" + "wifi_stats_cmd.c" + "wifi_itwt_cmd.c" + "disable_ieee80211_raw_frame_sanity_check.c" + PRIV_REQUIRES lwip esp_wifi esp_timer esp_pm + INCLUDE_DIRS ".") diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/Kconfig.projbuild b/SillyFilly-Hardware-Attack-Tool/host_p4/main/Kconfig.projbuild new file mode 100644 index 0000000..6d2fc2d --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/Kconfig.projbuild @@ -0,0 +1,189 @@ +menu "P4 Host Configuration" + + config EXAMPLE_WIFI_SSID + string "WiFi SSID" + default "myssid" + help + SSID (network name) for the example to connect to. + + config EXAMPLE_WIFI_PASSWORD + string "WiFi Password" + default "mypassword" + help + WiFi password (WPA or WPA2) for the example to use. + + config EXAMPLE_ENABLE_STATIC_IP + bool "enable static ip" + default y + help + Enable static IP + config EXAMPLE_STATIC_IP_ADDR + string "Static IP address" + default "192.168.4.2" + depends on EXAMPLE_ENABLE_STATIC_IP + help + Set static IP address. + + config EXAMPLE_STATIC_NETMASK_ADDR + string "Static netmask address" + default "255.255.255.0" + depends on EXAMPLE_ENABLE_STATIC_IP + help + Set static netmask address. + + config EXAMPLE_STATIC_GW_ADDR + string "Static gateway address" + default "192.168.4.1" + depends on EXAMPLE_ENABLE_STATIC_IP + help + Set static gateway address. + + config EXAMPLE_TWT_ENABLE_KEEP_ALIVE_QOS_NULL + bool "enable keep alive qos null" + default n + help + Enable send QOS NULL to keep alive during TWT. + + menu "iTWT Configuration" + config EXAMPLE_ITWT_TRIGGER_ENABLE + bool "trigger-enabled" + default y + help + 0- a non-trigger-enabled TWT, 1-a trigger-enabled TWT + + config EXAMPLE_ITWT_ANNOUNCED + bool "announced" + default y + help + 0- an unannounced TWT, 1-an announced TWT + + config EXAMPLE_ITWT_MIN_WAKE_DURA + int "itwt minimum wake duration" + range 1 255 + default 255 + help + Nominal Minimum Wake Duration, indicates the minimum amount of time, in unit of 256 us, that the TWT + requesting STA expects that it needs to be awake. The value range is [1, 255]. + + config EXAMPLE_ITWT_WAKE_DURATION_UNIT + int "itwt wake duration unit" + range 0 1 + default 0 + help + TWT wake duration unit, 0: 256us 1: TU (TU = 1024us) + + config EXAMPLE_ITWT_WAKE_INVL_EXPN + int "itwt wake interval exponent" + range 0 31 + default 10 + help + TWT Wake Interval Exponent, in microseconds. The value range is [0, 31]. + + config EXAMPLE_ITWT_WAKE_INVL_MANT + int "itwt wake interval mantissa" + range 1 65535 + default 512 + help + TWT Wake Interval Mantissa, in microseconds. The value range is [1, 65535]. + + config EXAMPLE_ITWT_ID + int "itwt connection id" + range 0 32767 + default 0 + help + TWT Connection id. The value range is [0, 32767]. + + config EXAMPLE_ITWT_SETUP_TIMEOUT_TIME_MS + int "itwt setup timeout times" + range 100 65535 + default 5000 + help + TWT setup timeout time, in microseconds. The value range is [100, 65535]. + + endmenu + + choice EXAMPLE_MAX_CPU_FREQ + prompt "Maximum CPU frequency" + default EXAMPLE_MAX_CPU_FREQ_96 if IDF_TARGET_ESP32H2 + default EXAMPLE_MAX_CPU_FREQ_80 + depends on PM_ENABLE + help + Maximum CPU frequency to use for dynamic frequency scaling. + + config EXAMPLE_MAX_CPU_FREQ_96 + bool "96 MHz" + depends on IDF_TARGET_ESP32H2 + config EXAMPLE_MAX_CPU_FREQ_80 + bool "80 MHz" + depends on !IDF_TARGET_ESP32P4 + config EXAMPLE_MAX_CPU_FREQ_90 + bool "90 MHz" + depends on IDF_TARGET_ESP32P4 + config EXAMPLE_MAX_CPU_FREQ_120 + bool "120 MHz" + depends on IDF_TARGET_ESP32C2 + config EXAMPLE_MAX_CPU_FREQ_160 + bool "160 MHz" + depends on !IDF_TARGET_ESP32P4 + config EXAMPLE_MAX_CPU_FREQ_180 + bool "180 MHz" + depends on IDF_TARGET_ESP32P4 + config EXAMPLE_MAX_CPU_FREQ_240 + bool "240 MHz" + depends on IDF_TARGET_ESP32 || IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 || IDF_TARGET_ESP32C5 + endchoice + + config EXAMPLE_MAX_CPU_FREQ_MHZ + int + default 64 if EXAMPLE_MAX_CPU_FREQ_64 + default 80 if EXAMPLE_MAX_CPU_FREQ_80 + default 90 if EXAMPLE_MAX_CPU_FREQ_90 + default 96 if EXAMPLE_MAX_CPU_FREQ_96 + default 120 if EXAMPLE_MAX_CPU_FREQ_120 + default 160 if EXAMPLE_MAX_CPU_FREQ_160 + default 180 if EXAMPLE_MAX_CPU_FREQ_180 + default 240 if EXAMPLE_MAX_CPU_FREQ_240 + + choice EXAMPLE_MIN_CPU_FREQ + prompt "Minimum CPU frequency" + default EXAMPLE_MIN_CPU_FREQ_10M if !IDF_TARGET_ESP32C5 + default EXAMPLE_MIN_CPU_FREQ_12M if IDF_TARGET_ESP32C5 + depends on PM_ENABLE + help + Minimum CPU frequency to use for dynamic frequency scaling. + Should be set to XTAL frequency or XTAL frequency divided by integer. + + config EXAMPLE_MIN_CPU_FREQ_40M + bool "40 MHz (use with 40MHz XTAL)" + depends on XTAL_FREQ_40 || XTAL_FREQ_AUTO + config EXAMPLE_MIN_CPU_FREQ_20M + bool "20 MHz (use with 40MHz XTAL)" + depends on XTAL_FREQ_40 || XTAL_FREQ_AUTO + config EXAMPLE_MIN_CPU_FREQ_16M + bool "16 MHz (use with 32MHz XTAL)" + depends on XTAL_FREQ_32 || XTAL_FREQ_AUTO + config EXAMPLE_MIN_CPU_FREQ_12M + bool "12 MHz (use with 48MHz XTAL)" + depends on XTAL_FREQ_48 || XTAL_FREQ_AUTO + config EXAMPLE_MIN_CPU_FREQ_10M + bool "10 MHz (use with 40MHz XTAL)" + depends on XTAL_FREQ_40 || XTAL_FREQ_AUTO + config EXAMPLE_MIN_CPU_FREQ_26M + bool "26 MHz (use with 26MHz XTAL)" + depends on XTAL_FREQ_26 || XTAL_FREQ_AUTO + config EXAMPLE_MIN_CPU_FREQ_13M + bool "13 MHz (use with 26MHz XTAL)" + depends on XTAL_FREQ_26 || XTAL_FREQ_AUTO + endchoice + + config EXAMPLE_MIN_CPU_FREQ_MHZ + int + default 40 if EXAMPLE_MIN_CPU_FREQ_40M + default 20 if EXAMPLE_MIN_CPU_FREQ_20M + default 10 if EXAMPLE_MIN_CPU_FREQ_10M + default 26 if EXAMPLE_MIN_CPU_FREQ_26M + default 16 if EXAMPLE_MIN_CPU_FREQ_16M + default 13 if EXAMPLE_MIN_CPU_FREQ_13M + default 12 if EXAMPLE_MIN_CPU_FREQ_12M + +endmenu diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/disable_ieee80211_raw_frame_sanity_check.c b/SillyFilly-Hardware-Attack-Tool/host_p4/main/disable_ieee80211_raw_frame_sanity_check.c new file mode 100644 index 0000000..ae7ad56 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/disable_ieee80211_raw_frame_sanity_check.c @@ -0,0 +1,8 @@ +// For disabling int ieee80211_raw_frame_sanity_check +// Adapted from justcallmekoko's method +// also requires add_link_options("-Wl,-z,muldefs") addded to main project CMakeLists.txt +#include + +int ieee80211_raw_frame_sanity_check(int32_t arg, int32_t arg2, int32_t arg3) { + return 0; +} diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/disable_ieee80211_raw_frame_sanity_check.h b/SillyFilly-Hardware-Attack-Tool/host_p4/main/disable_ieee80211_raw_frame_sanity_check.h new file mode 100644 index 0000000..94673e7 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/disable_ieee80211_raw_frame_sanity_check.h @@ -0,0 +1,4 @@ +// For disabling int ieee80211_raw_frame_sanity_check +// Adapted from justcallmekoko's method +// also requires add_link_options("-Wl,-z,muldefs") addded to main project CMakeLists.txt +int ieee80211_raw_frame_sanity_check(int32_t arg, int32_t arg2, int32_t arg3); diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/idf_component.yml b/SillyFilly-Hardware-Attack-Tool/host_p4/main/idf_component.yml new file mode 100644 index 0000000..834e3fc --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/idf_component.yml @@ -0,0 +1,13 @@ +dependencies: + cmd_system: + path: ${IDF_PATH}/examples/system/console/advanced/components/cmd_system + cmd_nvs: + path: ${IDF_PATH}/examples/system/console/advanced/components/cmd_nvs + espressif/esp_wifi_remote: + version: ">=0.10,<2.0" + rules: + - if: "target in [esp32p4, esp32h2]" + espressif/esp_hosted: + version: "*" + rules: + - if: "target in [esp32p4, esp32h2]" diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/itwt_main.c b/SillyFilly-Hardware-Attack-Tool/host_p4/main/itwt_main.c new file mode 100644 index 0000000..260198c --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/itwt_main.c @@ -0,0 +1,391 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +/* itwt Example + + This example code is in the Public Domain (or CC0 licensed, at your option.) + + Unless required by applicable law or agreed to in writing, this + software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + CONDITIONS OF ANY KIND, either express or implied. +*/ + +/* + this example shows how to use itwt + set a router or a AP using the same SSID&PASSWORD as configuration of this example. + start esp32c6 and when it connected to AP it will setup itwt. +*/ +#include +#include "freertos/FreeRTOS.h" +#include "freertos/event_groups.h" +#include "esp_wifi.h" +#include "esp_log.h" +#include "esp_event.h" +#include "nvs_flash.h" +#include "esp_console.h" +#include "cmd_system.h" +#include "esp_wifi_he.h" +#include "esp_pm.h" +#include "esp_timer.h" +#include "esp_idf_version.h" +#include "wifi_cmd.h" + +// For disabling int ieee80211_raw_frame_sanity_check +// Adapted from justcallmekoko's method +// also requires add_link_options("-Wl,-z,muldefs") addded to main project CMakeLists.txt +#include "disable_ieee80211_raw_frame_sanity_check.h" + +/******************************************************* + * Constants + *******************************************************/ +static const char *TAG = "itwt"; + +/******************************************************* + * Structures + *******************************************************/ + +/******************************************************* + * Variable Definitions + *******************************************************/ +/*set the ssid and password via "idf.py menuconfig"*/ +#define DEFAULT_SSID CONFIG_EXAMPLE_WIFI_SSID +#define DEFAULT_PWD CONFIG_EXAMPLE_WIFI_PASSWORD +#define ITWT_SETUP_SUCCESS 1 + +#if CONFIG_EXAMPLE_TWT_ENABLE_KEEP_ALIVE_QOS_NULL +bool keep_alive_enabled = true; +#else +bool keep_alive_enabled = false; +#endif + +#if CONFIG_EXAMPLE_ITWT_TRIGGER_ENABLE +uint8_t trigger_enabled = 1; +#else +uint8_t trigger_enabled = 0; +#endif + +#if CONFIG_EXAMPLE_ITWT_ANNOUNCED +uint8_t flow_type_announced = 1; +#else +uint8_t flow_type_announced = 0; +#endif + +esp_netif_t *netif_sta = NULL; +const int CONNECTED_BIT = BIT0; +const int DISCONNECTED_BIT = BIT1; +EventGroupHandle_t wifi_event_group; + +/******************************************************* + * Function Declarations + *******************************************************/ + +/******************************************************* + * Function Definitions + *******************************************************/ + +static void example_set_static_ip(esp_netif_t *netif) +{ +#if CONFIG_EXAMPLE_ENABLE_STATIC_IP + if (esp_netif_dhcpc_stop(netif) != ESP_OK) { + ESP_LOGE(TAG, "Failed to stop dhcp client"); + return; + } + esp_netif_ip_info_t ip; + memset(&ip, 0 , sizeof(esp_netif_ip_info_t)); + ip.ip.addr = ipaddr_addr(CONFIG_EXAMPLE_STATIC_IP_ADDR); + ip.netmask.addr = ipaddr_addr(CONFIG_EXAMPLE_STATIC_NETMASK_ADDR); + ip.gw.addr = ipaddr_addr(CONFIG_EXAMPLE_STATIC_GW_ADDR); + if (esp_netif_set_ip_info(netif, &ip) != ESP_OK) { + ESP_LOGE(TAG, "Failed to set ip info"); + return; + } + ESP_LOGI(TAG, "Success to set static ip: %s, netmask: %s, gw: %s", + CONFIG_EXAMPLE_STATIC_IP_ADDR, CONFIG_EXAMPLE_STATIC_NETMASK_ADDR, CONFIG_EXAMPLE_STATIC_GW_ADDR); +#endif +} + +static const char *itwt_probe_status_to_str(wifi_itwt_probe_status_t status) +{ + switch (status) { + case ITWT_PROBE_FAIL: return "itwt probe fail"; + case ITWT_PROBE_SUCCESS: return "itwt probe success"; + case ITWT_PROBE_TIMEOUT: return "itwt probe timeout"; + case ITWT_PROBE_STA_DISCONNECTED: return "Sta disconnected"; + default: return "Unknown status"; + } +} + +static void got_ip_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + xEventGroupClearBits(wifi_event_group, DISCONNECTED_BIT); + xEventGroupSetBits(wifi_event_group, CONNECTED_BIT); + + /* setup a trigger-based announce individual TWT agreement. */ + wifi_phy_mode_t phymode; + wifi_config_t sta_cfg = { 0, }; + esp_wifi_get_config(WIFI_IF_STA, &sta_cfg); + esp_wifi_sta_get_negotiated_phymode(&phymode); + if (phymode == WIFI_PHY_MODE_HE20) { + esp_err_t err = ESP_OK; +#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(5, 3, 0) + wifi_itwt_setup_config_t setup_config +#else + // wifi_itwt_setup_config_t only found in IDF v5.3.1 and above + wifi_twt_setup_config_t setup_config +#endif + = { + .setup_cmd = TWT_REQUEST, + .flow_id = 0, + .twt_id = CONFIG_EXAMPLE_ITWT_ID, + .flow_type = flow_type_announced ? 0 : 1, + .min_wake_dura = CONFIG_EXAMPLE_ITWT_MIN_WAKE_DURA, + .wake_duration_unit = CONFIG_EXAMPLE_ITWT_WAKE_DURATION_UNIT, + .wake_invl_expn = CONFIG_EXAMPLE_ITWT_WAKE_INVL_EXPN, + .wake_invl_mant = CONFIG_EXAMPLE_ITWT_WAKE_INVL_MANT, + .trigger = trigger_enabled, + .timeout_time_ms = CONFIG_EXAMPLE_ITWT_SETUP_TIMEOUT_TIME_MS, + }; + err = esp_wifi_sta_itwt_setup(&setup_config); + if (err != ESP_OK) { + ESP_LOGE(TAG, "itwt setup failed, err:0x%x", err); + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } else { + ESP_LOGE(TAG, "Must be in 11ax mode to support itwt"); + } +} + +static void start_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + ESP_LOGI(TAG, "sta connect to %s", DEFAULT_SSID); + esp_wifi_connect(); +} + +static void disconnect_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + ESP_LOGI(TAG, "sta disconnect, reconnect..."); + xEventGroupClearBits(wifi_event_group, CONNECTED_BIT); + esp_wifi_connect(); +} + +static void itwt_setup_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + wifi_event_sta_itwt_setup_t *setup = (wifi_event_sta_itwt_setup_t *) event_data; + if (setup->status == ITWT_SETUP_SUCCESS) { + /* TWT Wake Interval = TWT Wake Interval Mantissa * (2 ^ TWT Wake Interval Exponent) */ + ESP_LOGI(TAG, "twt_id:%d, flow_id:%d, %s, %s, wake_dura:%d, wake_dura_unit:%d, wake_invl_e:%d, wake_invl_m:%d", setup->config.twt_id, + setup->config.flow_id, setup->config.trigger ? "trigger-enabled" : "non-trigger-enabled", setup->config.flow_type ? "unannounced" : "announced", + setup->config.min_wake_dura, setup->config.wake_duration_unit, setup->config.wake_invl_expn, setup->config.wake_invl_mant); + ESP_LOGI(TAG, "target wake time:%lld, wake duration:%d us, service period:%d us", setup->target_wake_time, setup->config.min_wake_dura << (setup->config.wake_duration_unit == 1 ? 10 : 8), + setup->config.wake_invl_mant << setup->config.wake_invl_expn); + } else { + if (setup->status == ESP_ERR_WIFI_TWT_SETUP_TIMEOUT) { + ESP_LOGE(TAG, "twt_id:%d, timeout of receiving twt setup response frame", setup->config.twt_id); + } else if (setup->status == ESP_ERR_WIFI_TWT_SETUP_TXFAIL) { + ESP_LOGE(TAG, "twt_id:%d, twt setup frame tx failed, reason: %d", setup->config.twt_id, setup->reason); + } else if (setup->status == ESP_ERR_WIFI_TWT_SETUP_REJECT) { + ESP_LOGE(TAG, "twt_id:%d, twt setup request was rejected, setup cmd: %d", setup->config.twt_id, setup->config.setup_cmd); + } else { + ESP_LOGE(TAG, "twt_id:%d, twt setup failed, status: %d", setup->config.twt_id, setup->status); + } + } +} + +static void itwt_teardown_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + wifi_event_sta_itwt_teardown_t *teardown = (wifi_event_sta_itwt_teardown_t *) event_data; + if (teardown->status == ITWT_TEARDOWN_FAIL) { + ESP_LOGE(TAG, "flow_id %d%s, twt teardown frame tx failed", teardown->flow_id, (teardown->flow_id == 8) ? "(all twt)" : ""); + } else { + ESP_LOGI(TAG, "flow_id %d%s", teardown->flow_id, (teardown->flow_id == 8) ? "(all twt)" : ""); + } +} + +static void itwt_suspend_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + wifi_event_sta_itwt_suspend_t *suspend = (wifi_event_sta_itwt_suspend_t *) event_data; + ESP_LOGI(TAG, "status:%d, flow_id_bitmap:0x%x, actual_suspend_time_ms:[%lu %lu %lu %lu %lu %lu %lu %lu]", + suspend->status, suspend->flow_id_bitmap, + suspend->actual_suspend_time_ms[0], suspend->actual_suspend_time_ms[1], suspend->actual_suspend_time_ms[2], suspend->actual_suspend_time_ms[3], + suspend->actual_suspend_time_ms[4], suspend->actual_suspend_time_ms[5], suspend->actual_suspend_time_ms[6], suspend->actual_suspend_time_ms[7]); +} + +static void itwt_probe_handler(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + wifi_event_sta_itwt_probe_t *probe = (wifi_event_sta_itwt_probe_t *) event_data; + ESP_LOGI(TAG, "status:%s, reason:0x%x", itwt_probe_status_to_str(probe->status), probe->reason); +} + +static void wifi_itwt(void) +{ + ESP_ERROR_CHECK(esp_netif_init()); + wifi_event_group = xEventGroupCreate(); + ESP_ERROR_CHECK(esp_event_loop_create_default()); + netif_sta = esp_netif_create_default_wifi_sta(); + assert(netif_sta); + + wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_wifi_init(&cfg)); + + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + WIFI_EVENT_STA_START, + &start_handler, + NULL, + NULL)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + WIFI_EVENT_STA_DISCONNECTED, + &disconnect_handler, + NULL, + NULL)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, + IP_EVENT_STA_GOT_IP, + &got_ip_handler, + NULL, + NULL)); + /* itwt */ + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + WIFI_EVENT_ITWT_SETUP, + &itwt_setup_handler, + NULL, + NULL)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + WIFI_EVENT_ITWT_TEARDOWN, + &itwt_teardown_handler, + NULL, + NULL)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + WIFI_EVENT_ITWT_SUSPEND, + &itwt_suspend_handler, + NULL, + NULL)); + ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, + WIFI_EVENT_ITWT_PROBE, + &itwt_probe_handler, + NULL, + NULL)); + + wifi_config_t wifi_config = { + .sta = { + .ssid = DEFAULT_SSID, + .password = DEFAULT_PWD, + }, + }; + ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); + ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config)); + +#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(5, 3, 0) + wifi_twt_config_t wifi_twt_config = { + .post_wakeup_event = false, +#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(5, 3, 1) + // twt_enable_keep_alive only found in IDF v5.3.2 and above + .twt_enable_keep_alive = keep_alive_enabled, +#endif + }; + // esp_wifi_sta_twt_config only found in IDF v5.3.1 and above + ESP_ERROR_CHECK(esp_wifi_sta_twt_config(&wifi_twt_config)); +#endif +#if CONFIG_SOC_WIFI_SUPPORT_5G || CONFIG_SLAVE_SOC_WIFI_SUPPORT_5G + wifi_bandwidths_t bw = { + .ghz_2g = WIFI_BW_HT20, + .ghz_5g = WIFI_BW_HT20, + }; + esp_wifi_set_bandwidths(WIFI_IF_STA, &bw); + + wifi_protocols_t protocol = { + .ghz_2g = WIFI_PROTOCOL_11AX, + .ghz_5g = WIFI_PROTOCOL_11AX, + }; + esp_wifi_set_protocols(WIFI_IF_STA, &protocol); +#else + esp_wifi_set_bandwidth(WIFI_IF_STA, WIFI_BW_HT20); + esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N | WIFI_PROTOCOL_11AX); +#endif + esp_wifi_set_ps(WIFI_PS_MIN_MODEM); + +#if CONFIG_EXAMPLE_ENABLE_STATIC_IP + example_set_static_ip(netif_sta); +#endif + + ESP_ERROR_CHECK(esp_wifi_start()); + +#if CONFIG_ESP_WIFI_ENABLE_WIFI_RX_STATS +#if CONFIG_ESP_WIFI_ENABLE_WIFI_RX_MU_STATS + esp_wifi_enable_rx_statistics(true, true); +#else + esp_wifi_enable_rx_statistics(true, false); +#endif +#endif +#if CONFIG_ESP_WIFI_ENABLE_WIFI_TX_STATS + esp_wifi_enable_tx_statistics(ESP_WIFI_ACI_VO, true); //VO, mgmt + esp_wifi_enable_tx_statistics(ESP_WIFI_ACI_BE, true); //BE, data +#endif + +} + +void app_main(void) +{ + // Initialize NVS + esp_err_t ret = nvs_flash_init(); + if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) { + ESP_ERROR_CHECK(nvs_flash_erase()); + ret = nvs_flash_init(); + } + +#if CONFIG_PM_ENABLE + // Configure dynamic frequency scaling: + // maximum and minimum frequencies are set in sdkconfig, + // automatic light sleep is enabled if tickless idle support is enabled. + esp_pm_config_t pm_config = { + .max_freq_mhz = CONFIG_EXAMPLE_MAX_CPU_FREQ_MHZ, + .min_freq_mhz = CONFIG_EXAMPLE_MIN_CPU_FREQ_MHZ, +#if CONFIG_FREERTOS_USE_TICKLESS_IDLE + // SDIO currently does not work with auto light sleep + //.light_sleep_enable = true + .light_sleep_enable = false +#endif + }; + ESP_ERROR_CHECK( esp_pm_configure(&pm_config) ); + ESP_ERROR_CHECK( ret ); + +#else + printf("\n =================================================\n"); + printf(" | Test WiFi 6 itwt |\n"); + printf(" =================================================\n\n"); + + esp_console_repl_t *repl = NULL; + esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT(); + repl_config.prompt = "itwt>"; + + // init console REPL environment +#if CONFIG_ESP_CONSOLE_UART + esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl)); +#elif CONFIG_ESP_CONSOLE_USB_CDC + esp_console_dev_usb_cdc_config_t cdc_config = ESP_CONSOLE_DEV_CDC_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_console_new_repl_usb_cdc(&cdc_config, &repl_config, &repl)); +#elif CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG + esp_console_dev_usb_serial_jtag_config_t usbjtag_config = ESP_CONSOLE_DEV_USB_SERIAL_JTAG_CONFIG_DEFAULT(); + ESP_ERROR_CHECK(esp_console_new_repl_usb_serial_jtag(&usbjtag_config, &repl_config, &repl)); +#endif + + // start console REPL + ESP_ERROR_CHECK(esp_console_start_repl(repl)); +#endif + + //start wifi + wifi_itwt(); + // register commands + register_system(); + register_wifi_itwt(); + register_wifi_stats(); + +} diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_cmd.h b/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_cmd.h new file mode 100644 index 0000000..ab91396 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_cmd.h @@ -0,0 +1,18 @@ +/* + * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +void register_wifi_itwt(void); +void register_wifi_stats(void); + +#ifdef __cplusplus +} +#endif diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_itwt_cmd.c b/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_itwt_cmd.c new file mode 100644 index 0000000..97e8935 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_itwt_cmd.c @@ -0,0 +1,259 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include "esp_log.h" +#include "freertos/FreeRTOS.h" +#include "freertos/event_groups.h" + +#if CONFIG_SOC_WIFI_HE_SUPPORT || CONFIG_SLAVE_SOC_WIFI_HE_SUPPORT + +#include "esp_console.h" +#include "argtable3/argtable3.h" +#include "esp_netif.h" +#include "esp_event.h" +#include "esp_wifi.h" +#include "esp_wifi_he.h" + +/******************************************************* + * Constants + *******************************************************/ +static const char *TAG = "twt"; + +/******************************************************* + * Structures + *******************************************************/ +typedef struct { + struct arg_int *setup; + struct arg_lit *teardown; + struct arg_lit *suspend; + struct arg_lit *getflowid; + struct arg_int *waketimeoffset; + struct arg_int *trigger; //1-trigger-enabled, 0-non-trigger-enabled, setup + struct arg_int *flowtype; //1-unannounced, 0-announced, setup + struct arg_int *negtype; + struct arg_int *wakeinvlexp; //setup + struct arg_int *wakeduraunit; //1-TU, 0-256us + struct arg_int *wakeinvlman; //setup + struct arg_int *minwakedur; //setup + struct arg_int *flowid; + struct arg_int *twtid; + struct arg_int *setup_timeout_time_ms; + struct arg_int *suspend_time_ms; + struct arg_int *all_twt; + struct arg_end *end; +} wifi_itwt_args_t; + +typedef struct { + struct arg_int *timeout; + struct arg_end *end; +} wifi_itwt_send_probereq_t; + +/******************************************************* + * Variable Definitions + *******************************************************/ +static wifi_itwt_args_t itwt_args; +static wifi_itwt_send_probereq_t itwt_probe_args; + +/******************************************************* + * Function Declarations + *******************************************************/ + +/******************************************************* + * Function Definitions + *******************************************************/ +static int wifi_cmd_itwt(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &itwt_args); + if (nerrors != 0) { + arg_print_errors(stderr, itwt_args.end, argv[0]); + return 1; + } + + esp_err_t err = ESP_OK; + if (itwt_args.setup->count) { + if (itwt_args.wakeinvlman->count) { + if (itwt_args.wakeinvlman->ival[0] < 0 || itwt_args.wakeinvlman->ival[0] > 65535) { + ESP_LOGE(TAG, "(itwt)expect [0, 65535], wake_invl_mant: %d", itwt_args.wakeinvlman->ival[0]); + return 1; + } + } + if (itwt_args.wakeinvlexp->count) { + if (itwt_args.wakeinvlexp->ival[0] < 0 || itwt_args.wakeinvlexp->ival[0] > 31) { + ESP_LOGE(TAG, "(itwt)expect [0, 31], wake_invl_expn: %d", itwt_args.wakeinvlexp->ival[0]); + return 1; + } + } + if (itwt_args.minwakedur->count) { + if (itwt_args.minwakedur->ival[0] < 0 || itwt_args.minwakedur->ival[0] > 255) { + ESP_LOGE(TAG, "(itwt)expect [0, 255], min_wake_dura: %d", itwt_args.minwakedur->ival[0]); + return 1; + } + } + if (itwt_args.wakeduraunit->count) { + if (itwt_args.wakeduraunit->ival[0] < 0 || itwt_args.wakeduraunit->ival[0] > 1) { + ESP_LOGE(TAG, "(itwt)expect [0, 1], wake duration unit: %d", itwt_args.wakeduraunit->ival[0]); + return 1; + } + } + if (itwt_args.twtid->count) { + if (itwt_args.twtid->ival[0] < 0 || itwt_args.twtid->ival[0] > 32767) { + ESP_LOGE(TAG, "(itwt)expect [0, 32767], twt id: %d", itwt_args.twtid->ival[0]); + return 1; + } + } + if (itwt_args.setup_timeout_time_ms->count) { + if (itwt_args.setup_timeout_time_ms->ival[0] < 0 || itwt_args.setup_timeout_time_ms->ival[0] > 65535) { + ESP_LOGE(TAG, "(itwt)expect [0, 65535], setup timeout time: %d", itwt_args.setup_timeout_time_ms->ival[0]); + return 1; + } + } + wifi_twt_setup_config_t setup_config = { + .setup_cmd = (itwt_args.setup->ival[0] <= TWT_DEMAND) ? itwt_args.setup->ival[0] : TWT_REQUEST, + .flow_id = itwt_args.flowid->count ? itwt_args.flowid->ival[0] : 0, + .twt_id = itwt_args.twtid->count ? itwt_args.twtid->ival[0] : 0, + .flow_type = itwt_args.flowtype->count ? ((itwt_args.flowtype->ival[0] == 0) ? 0 : 1) : 0, + .min_wake_dura = itwt_args.minwakedur->count ? itwt_args.minwakedur->ival[0] : 255, + .wake_duration_unit = itwt_args.wakeduraunit->count ? itwt_args.wakeduraunit->ival[0] : 0, + .wake_invl_expn = itwt_args.wakeinvlexp->count ? itwt_args.wakeinvlexp->ival[0] : 10, + .wake_invl_mant = itwt_args.wakeinvlman->count ? itwt_args.wakeinvlman->ival[0] : 512, + .trigger = itwt_args.trigger->count ? (itwt_args.trigger->ival[0] ? 1 : 0) : 1, + .timeout_time_ms = itwt_args.setup_timeout_time_ms->count ? itwt_args.setup_timeout_time_ms->ival[0] : 5000, + }; + err = esp_wifi_sta_itwt_setup(&setup_config); + ESP_LOGI(TAG, "(itwt)setup, trigger:%d, %s, flow_id:%d, err:0x%x", + setup_config.trigger, setup_config.flow_type ? "unannounce" : "announced", setup_config.flow_id, err); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } + if (itwt_args.teardown->count) { + // teardown a given flow id, all_twt has a high priority + int flow_id = itwt_args.flowid->count ? itwt_args.flowid->ival[0] : (-1); + bool all_twt = itwt_args.all_twt->count ? ((itwt_args.all_twt->ival[0] == 1) ? true : false) : false; + flow_id = (all_twt == true) ? FLOW_ID_ALL : flow_id; + ESP_LOGW(TAG, "flow_id %d", flow_id); + if (flow_id >= 0) { + err = esp_wifi_sta_itwt_teardown(flow_id); + ESP_LOGI(TAG, "(itwt)teardown, flow_id:%d, all_twt:%d, err:0x%x", flow_id, all_twt, err); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } else { + ESP_LOGE(TAG, "(itwt)teardown, should specify an existing flow id"); + } + } + if (itwt_args.suspend->count) { + // suspend a given flow id + int flow_id = itwt_args.flowid->count ? itwt_args.flowid->ival[0] : (-1); + bool all_twt = itwt_args.all_twt->count ? (itwt_args.all_twt->ival[0] ? true : false) : false; + flow_id = (all_twt == true) ? FLOW_ID_ALL : flow_id; + int suspend_time_ms = itwt_args.suspend_time_ms->count ? itwt_args.suspend_time_ms->ival[0] : 0; + if (flow_id >= 0) { + err = esp_wifi_sta_itwt_suspend(flow_id, suspend_time_ms); + ESP_LOGI(TAG, "(itwt)suspend, flow_id:%d, all_twt:%d, suspend:%d ms, err:0x%x", flow_id, all_twt, suspend_time_ms, err); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } else { + ESP_LOGE(TAG, "(itwt)suspend, should specify an existing flow id"); + } + } + if (itwt_args.getflowid->count) { + int flow_id_bitmap; + err = esp_wifi_sta_itwt_get_flow_id_status(&flow_id_bitmap); + if (err == ESP_OK) { + ESP_LOGI(TAG, "flowid bitmap: 0x%" PRIx16, flow_id_bitmap); + } else { + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } + if (itwt_args.waketimeoffset->count) { + int offset_us = itwt_args.waketimeoffset->ival[0]; + err = esp_wifi_sta_itwt_set_target_wake_time_offset(offset_us); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } + return 0; +} + +static int wifi_cmd_itwt_probe(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &itwt_probe_args); + if (nerrors != 0) { + arg_print_errors(stderr, itwt_probe_args.end, argv[0]); + return 1; + } + + esp_err_t err = ESP_OK; + if (itwt_probe_args.timeout->count) { + if (itwt_probe_args.timeout->ival[0] > 0) { + ESP_LOGI(TAG, "(itwt)send probe req, timeout:%d ms", itwt_probe_args.timeout->ival[0]); + err = esp_wifi_sta_itwt_send_probe_req(itwt_probe_args.timeout->ival[0]); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Error: %s", esp_err_to_name(err)); + } + } else { + ESP_LOGE(TAG, "(itwt)invalid input, timeout:%d ms", itwt_probe_args.timeout->ival[0]); + } + } + ESP_LOGI(TAG, "err:0x%x", err); + return err; +} + +void register_wifi_itwt(void) +{ + /* itwt setup/teardown */ + itwt_args.setup = arg_int0(NULL, "setup", "", "twt setup/teardown an individual flow id"); + itwt_args.teardown = arg_lit0(NULL, "teardown", "twt setup/teardown an individual flow id"); + itwt_args.suspend = arg_lit0(NULL, "suspend", "twt setup/teardown an individual flow id"); + itwt_args.getflowid = arg_lit0(NULL, "getflowid", "get flow ids"); + itwt_args.waketimeoffset = arg_int0(NULL, "waketimeoffset", "", "set wake time offset (in us)"); + itwt_args.trigger = arg_int0("t", NULL, "", "trigger"); + itwt_args.flowtype = arg_int0("f", NULL, "", "flow type: 0-announced, 1-unannounced"); + itwt_args.negtype = arg_int0("n", NULL, "", "negotiate type"); + itwt_args.minwakedur = arg_int0("d", NULL, "", "Norminal Min. Wake Duration"); + itwt_args.wakeduraunit = arg_int0("u", NULL, "", "wake duration unit 0-256us, 1-TU (TU = 1024us)"); + itwt_args.wakeinvlexp = arg_int0("e", NULL, "", "Wake Interval Exponent"); + itwt_args.wakeinvlman = arg_int0("m", NULL, "", "Wake Interval Mantissa"); + itwt_args.flowid = arg_int0("i", NULL, "", "Flow ID"); + itwt_args.suspend_time_ms = arg_int0("s", NULL, "", "time of suspending iTWT agreements, unit ms"); + itwt_args.twtid = arg_int0("w", NULL, "", "TWT ID"); + itwt_args.setup_timeout_time_ms = arg_int0("u", NULL, "", "iTWT setup timeout time, unit ms"); + itwt_args.all_twt = arg_int0("a", NULL, "", "All TWT"); + itwt_args.end = arg_end(1); + const esp_console_cmd_t itwt_cmd = { + .command = "itwt", + .help = "itwt setup, teardown or suspend", + .hint = NULL, + .func = &wifi_cmd_itwt, + .argtable = &itwt_args + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&itwt_cmd)); + + /* itwt probe */ + itwt_probe_args.timeout = arg_int0("t", NULL, "[timeout]", "time of sending a probe request frame and receiving a probe response frame from ap, unit ms"); + itwt_probe_args.end = arg_end(1); + const esp_console_cmd_t itwt_probe_cmd = { + .command = "probe", + .help = "send probe request for TSF update when at lease one itwt agreement setup", + .hint = NULL, + .func = &wifi_cmd_itwt_probe, + .argtable = &itwt_probe_args + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&itwt_probe_cmd)); +} + +#else + +void register_wifi_itwt(void) +{ + ; +} + +#endif /* CONFIG_SOC_WIFI_HE_SUPPORT || CONFIG_SLAVE_SOC_WIFI_HE_SUPPORT */ diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_stats_cmd.c b/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_stats_cmd.c new file mode 100644 index 0000000..b3a9e10 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/main/wifi_stats_cmd.c @@ -0,0 +1,584 @@ +/* + * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include "esp_log.h" + +#if CONFIG_ESP_WIFI_ENABLE_WIFI_TX_STATS || CONFIG_ESP_WIFI_ENABLE_WIFI_RX_STATS + +#include "esp_console.h" +#include "argtable3/argtable3.h" +#include "esp_event.h" +#include "esp_wifi.h" +#include "esp_wifi_types.h" +#include "esp_private/esp_wifi_he_private.h" + +/******************************************************* + * Macros + *******************************************************/ +/* + * enable/disable rx/tx statistics after Wi-Fi started: + * (1) esp_wifi_enable_rx_statistics(true, true); //rx_stats=true, rx_mu_stats=true + * (2) esp_wifi_enable_tx_statistics(ESP_WIFI_ACI_BE, true); //aci=ESP_WIFI_ACI_BE, tx_stats=true + */ + +/******************************************************* + * Constants + *******************************************************/ +static const char *TAG = "stats"; + +/******************************************************* + * Structures + *******************************************************/ + +/******************************************************* + * Variable Definitions + *******************************************************/ +#if CONFIG_ESP_WIFI_ENABLE_WIFI_RX_MU_STATS +esp_test_rx_mu_statistics_t rx_mu_stats = { 0, }; //10932 bytes +#endif + +/******************************************************* + * Function Declarations + *******************************************************/ + +/******************************************************* + * Function Definitions + *******************************************************/ +const char *tx_fail_error2str(esp_test_tx_fail_error_t error) +{ + switch (error) { + case TEST_TX_FAIL_ERROR_H00: + return "0x00"; + case TEST_TX_FAIL_ERROR_H53: + return "0x53"; + case TEST_TX_FAIL_ERROR_H63: + return "0x63"; + case TEST_TX_FAIL_ERROR_H75: + return "0x75"; + case TEST_TX_FAIL_ERROR_H41: + return "0x41"; + case TEST_TX_FAIL_ERROR_H42: + return "0x42"; + case TEST_TX_FAIL_ERROR_H47: + return "0x47"; + case TEST_TX_FAIL_ERROR_H80: + return "0x80"; + case TEST_TX_FAIL_ERROR_H5A: + return "0x5A"; + case TEST_TX_FAIL_ERROR_HXX: + return "Others"; + case TEST_TX_FAIL_ERROR_MAX: + return "Undefined"; + } + return "Undefined"; +} + +const char *tx_fail_match2str(esp_test_tx_fail_match_t match) +{ + switch (match) { + case TEST_TX_WAIT_MATCH: + return "MATCH"; + case TEST_TX_WAIT_NOT2SELF: + return "NOT2SELF"; + case TEST_TX_MISMATCH: + return "MISMATCH"; + case TEST_TX_WAIT_TIMEOUT: + return "TIMEOUT"; + case TEST_TX_WAIT_MAX: + return "Undefined"; + } + return "Undefined"; +} + +const char *tx_fail_state2str(esp_test_tx_fail_state_t state) +{ + switch (state) { + case TEST_TX_SUCCESS: + return "TX Success"; + case TEST_TX_FAIL_RTS: + return "TX RTS"; + case TEST_TX_WAIT_CTS: //RX + return "Wait CTS"; + case TEST_TX_FAIL_CTS: + return "TX RTS"; + case TEST_TX_FAIL_DATA: + return "TX DATA"; + case TEST_TX_WAIT_ACK: //RX + return "Wait ACK/BA"; + case TEST_TX_FAIL_MAX: + return "Undefined"; + } + return "Undefined"; +} + +int wifi_cmd_clr_tx_statistics(int argc, char **argv) +{ + ESP_LOGW(TAG, "Clear tx statistics"); + int i; + for (i = 0; i < 3; i++) { + esp_wifi_clr_tx_statistics(i); //BE + esp_wifi_clr_tx_tb_statistics(i); + } + esp_test_clr_hw_statistics(); + return 0; +} + +void print_hw_tb_statistics(void) +{ + esp_test_hw_tb_statistics_t hw_tb_stats = { 0, }; + esp_test_get_hw_tb_statistics(&hw_tb_stats); + printf("(test)rx_trig:%d, tx_bfrpt:%d, tb_times:%d, tb_qos_null:%d, tb_qos_data:%d, tb_cca_cancel:%d, tb_sifs_abort:%d, tb_pwr_outof_range:%d\n", + hw_tb_stats.rx_trig, + hw_tb_stats.tx_bfrpt, //including TB and Non-TB + hw_tb_stats.tb_times, + hw_tb_stats.tb_qos_null, + hw_tb_stats.tb_times - hw_tb_stats.tb_qos_null, + hw_tb_stats.tb_cca_cancel, + hw_tb_stats.tb_sifs_abort, + hw_tb_stats.tb_pwr_outof_range); +} + +int wifi_cmd_get_tx_statistics(int argc, char **argv) +{ + uint8_t i, h, j, k; + + ESP_LOGW(TAG, "Get tx statistics"); + esp_test_tx_tb_statistics_t tb_stats = { 0, }; //32 bytes + esp_test_tx_statistics_t tx_stats = { 0, }; //136 bytes + esp_test_tx_fail_statistics_t tx_fail[TEST_TX_FAIL_MAX] = { 0, }; //TEST_TX_FAIL_MAX * 164 bytes + + print_hw_tb_statistics(); + //only check BE + for (i = 2; i < 3; i++) { + esp_wifi_get_tx_tb_statistics(i, &tb_stats); + /* TB */ + printf("(test)aci:%" PRIu8 ", tb(suc:%" PRIu32 ", ack:%" PRIu32 ", err:%" PRIu32 "), " + "count(suc:%" PRIu32 ", ack:%" PRIu32 ", err:%" PRIu32 ", tot:%" PRIu32 ", max_sent:%" PRIu32 ")\n", + i, + tb_stats.complete_suc_tb, + tb_stats.complete_ack_tb, + tb_stats.complete_err_tb, + tb_stats.complete_tb_suc_count, + tb_stats.complete_tb_ack_count, + tb_stats.complete_tb_err_count, + tb_stats.complete_tb_tot_count, + tb_stats.complete_tb_pack_sent); + + esp_wifi_get_tx_statistics(i, &tx_stats, (esp_test_tx_fail_statistics_t *) &tx_fail); + int tot_tx_times = tx_stats.tb_times + (tx_stats.tx_enable - tx_stats.tb_last); //TB + EDCA + int tot_fail = tx_fail[1].count + tx_fail[2].count + tx_fail[3].count + tx_fail[4].count + tx_fail[5].count; + printf("(test)aci:%" PRIu8 ", enable:%" PRIu32 ", complete:%" PRIu32 ", tb_times:%" PRIu32 ", tb_last:%" PRIu32 ", edca:%" PRIu32 ", " + "succ:%" PRIu32 ", fail(%" PRIu32 ",%" PRIu32 ",%" PRIu32 ", cts:%" PRIu32 "/%2.2f%%, ack:%" PRIu32 "/%2.2f%%, tot:%d, %.2f%%), " + "edca(ack:%" PRIu32 ", ba:%" PRIu32 "), tb(hw-ba:%" PRIu32 ", sw-ba:%" PRIu32 ")\n", + i, tx_stats.tx_enable, + tx_stats.tx_complete, + tx_stats.tb_times, + tx_stats.tb_last, + tx_stats.tx_enable - tx_stats.tb_last, + tx_fail[0].count, + tx_fail[1].count, + tx_fail[3].count, + tx_fail[4].count, + tx_fail[2].count, + (float) ((float) tx_fail[2].count / (float) tot_tx_times) * 100, //rx cts + tx_fail[5].count, (float) ((float) tx_fail[5].count / (float) tot_tx_times) * 100, //rx ack + tot_fail, + (float) ((float) tot_fail / (float) tot_tx_times) * 100, + tx_stats.rx_ack, + tx_stats.rx_ba, + tx_stats.tb_rx_ba, //including ACKs + tx_stats.rx_dump_ba); + + printf("(test)aci:%" PRIu8 ", txFrames:%" PRIu32 ", s-mpdu:%" PRIu32 "(%.2f%%), " + "bitmap(max:%d, min:%d, tot:%" PRIu32 ", avg:%.2f), " + "retry(edca:%" PRIu32 ", tb:%" PRIu32 ", %.2f%%), collision:%" PRIu32 ", timeout:%" PRIu32 "\n", + i, + tx_stats.tx_succ, + tx_stats.rx_ack, + ((float) (tx_stats.rx_ack) / (float) tot_tx_times) * 100, + tx_stats.rx_max_bitmap, + tx_stats.rx_min_bitmap, + tx_stats.rx_tot_bitmap, + (float) tx_stats.rx_tot_bitmap / (float) (tx_stats.tb_rx_ba + tx_stats.rx_ba), + tx_stats.retry_edca, tx_stats.retry_tb, (float) (tx_stats.retry_edca + tx_stats.retry_tb) / (float) tx_stats.tx_succ * 100, + tx_stats.collision, tx_stats.timeout); + + float tot_rtt_ms = (float) tx_stats.tx_tot_rtt / (float) 1000; + printf("(test)aci:%" PRIu8 ", seqno_rtt[%" PRIu32 ",%" PRIu32 "], hw_rtt[%" PRIu32 ", %" PRIu32 "], muedca[enable:%" PRIu32 ", times:%" PRIu32 ", %.2f, %.2f, tot:%.2f], avg:%.3f ms, tot:%.3f secs\n", + i, + tx_stats.tx_seq_min_rtt, + tx_stats.tx_seq_max_rtt, + tx_stats.tx_min_rtt, + tx_stats.tx_max_rtt, + tx_stats.tx_muedca_enable, + tx_stats.muedca_times, + (float) tx_stats.tx_min_muedca_time / (float) 1000, + (float) tx_stats.tx_max_muedca_time / (float) 1000, + (float) tx_stats.tx_tot_muedca_time / (float) 1000, //ms + (float) tot_rtt_ms / (float) tot_tx_times, //ms + (float) tot_rtt_ms / (float) 1000); //seconds + /* fail state */ + for (h = 1; h < TEST_TX_FAIL_MAX; h++) { //state + for (j = 0; j < TEST_TX_WAIT_MAX; j++) { //match + for (k = 0; k < TEST_TX_FAIL_ERROR_MAX; k++) { //error + if (tx_fail[h].match[j][k]) { + printf("(test)[%d][%d][%d](%16s + %16s + %16s)%3" PRIu32 "/%3" PRIu32 "(%.2f%%)\n", h, j, k, tx_fail_state2str(h), + tx_fail_match2str(j), tx_fail_error2str(k), + tx_fail[h].match[j][k], tx_fail[h].count, + ((float) tx_fail[h].match[j][k] / (float) tx_fail[h].count) * 100); + } + } + } + } + printf("\n"); + } + wifi_cmd_clr_tx_statistics(0, 0); + return 0; +} + +void print_rx_statistics_nonmimo(const esp_test_rx_mu_statistics_t *mu_stats) +{ + if (!mu_stats->nonmimo_rx) { + return; + } + + int i, j; + int tot_rx_nonmimo = 0; + ESP_LOGW(TAG, "(nonmimo)dut rx:%" PRIu32, mu_stats->nonmimo_rx); + ESP_LOGW(TAG, "(nonmimo)ru_alloc_96_num_2046:%" PRIu32 ", ru_alloc_112_num_2046:%" PRIu32, mu_stats->ru_alloc_96_num_2046, mu_stats->ru_alloc_112_num_2046); + ESP_LOGW(TAG, "(nonmimo)sigb, mcs0:%" PRIu32 "(%2.2f%%), mcs1:%" PRIu32 "(%2.2f%%), mcs2:%" PRIu32 "(%2.2f%%), mcs3:%" PRIu32 "(%2.2f%%), mcs4:%" PRIu32 "(%2.2f%%), mcs5:%" PRIu32 "(%2.2f%%)", + mu_stats->nonmimo_sigb_mcs[0], ((float) mu_stats->nonmimo_sigb_mcs[0] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_sigb_mcs[1], ((float) mu_stats->nonmimo_sigb_mcs[1] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_sigb_mcs[2], ((float) mu_stats->nonmimo_sigb_mcs[2] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_sigb_mcs[3], ((float) mu_stats->nonmimo_sigb_mcs[3] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_sigb_mcs[4], ((float) mu_stats->nonmimo_sigb_mcs[4] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_sigb_mcs[5], ((float) mu_stats->nonmimo_sigb_mcs[5] / (float) mu_stats->nonmimo_rx) * 100); + ESP_LOGW(TAG, "(nonmimo)users, num1:%" PRIu32 "(%2.2f%%), num2:%" PRIu32 "(%2.2f%%), num3:%" PRIu32 "(%2.2f%%), num4:%" PRIu32 "(%2.2f%%), num5:%" PRIu32 "(%2.2f%%), num6:%" PRIu32 "(%2.2f%%), num7:%" PRIu32 "(%2.2f%%), num8:%" PRIu32 "(%2.2f%%), num9:%" PRIu32 "(%2.2f%%)", + mu_stats->nonmimo_user_num_occu[0], ((float) mu_stats->nonmimo_user_num_occu[0] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[1], ((float) mu_stats->nonmimo_user_num_occu[1] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[2], ((float) mu_stats->nonmimo_user_num_occu[2] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[3], ((float) mu_stats->nonmimo_user_num_occu[3] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[4], ((float) mu_stats->nonmimo_user_num_occu[4] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[5], ((float) mu_stats->nonmimo_user_num_occu[5] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[6], ((float) mu_stats->nonmimo_user_num_occu[6] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[7], ((float) mu_stats->nonmimo_user_num_occu[7] / (float) mu_stats->nonmimo_rx) * 100, + mu_stats->nonmimo_user_num_occu[8], ((float) mu_stats->nonmimo_user_num_occu[8] / (float) mu_stats->nonmimo_rx) * 100); + for (i = 0; i < 256; i++) { + for (j = 0; j < 9; j++) { + if (!mu_stats->nonmimo_ru_alloc[i][j]) { + continue; + } + ESP_LOGI(TAG, "(nonmimo)ru_allocation:0x%2x(%3" PRIu8 "), position:%" PRIu8 ", %5" PRIu32 "(%2.2f%%)", i, i, j + 1, mu_stats->nonmimo_ru_alloc[i][j], + ((float) mu_stats->nonmimo_ru_alloc[i][j] / (float) mu_stats->nonmimo_rx) * 100); + } + } + for (i = 0; i < ESP_TEST_RX_MU_USER_NUM; i++) { + if (!mu_stats->nonmimo[i].aid) { + continue; + } + if (mu_stats->aid != mu_stats->nonmimo[i].aid) { + continue; + } + tot_rx_nonmimo = mu_stats->nonmimo[i].occu_nsts[0] + mu_stats->nonmimo[i].occu_nsts[1] + mu_stats->nonmimo[i].occu_nsts[2] + mu_stats->nonmimo[i].occu_nsts[3]; + printf("[%" PRIu8 "]%said:0x%x, txbf:%" PRIu32 ", dcm:%" PRIu32 "\n", i, (mu_stats->aid == mu_stats->nonmimo[i].aid) ? "#" : " ", mu_stats->nonmimo[i].aid, + mu_stats->nonmimo[i].txbf, mu_stats->nonmimo[i].dcm); + printf("[%d]%said:0x%x, " + "mcs0:%" PRIu32 "(%2.2f%%), mcs1:%" PRIu32 "(%2.2f%%), mcs2:%" PRIu32 "(%2.2f%%), mcs3:%" PRIu32 "(%2.2f%%), mcs4:%" PRIu32 "(%2.2f%%), " + "mcs5:%" PRIu32 "(%2.2f%%), mcs6:%" PRIu32 "(%2.2f%%), mcs7:%" PRIu32 "(%2.2f%%), mcs8:%" PRIu32 "(%2.2f%%), mcs9:%" PRIu32 "(%2.2f%%), " + "mcs10:%" PRIu32 "(%2.2f%%), mcs11:%" PRIu32 "(%2.2f%%)\n", + i, (mu_stats->aid == mu_stats->nonmimo[i].aid) ? "#" : " ", mu_stats->nonmimo[i].aid, + mu_stats->nonmimo[i].occu_mcs[0], ((float) mu_stats->nonmimo[i].occu_mcs[0] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[1], ((float) mu_stats->nonmimo[i].occu_mcs[1] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[2], ((float) mu_stats->nonmimo[i].occu_mcs[2] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[3], ((float) mu_stats->nonmimo[i].occu_mcs[3] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[4], ((float) mu_stats->nonmimo[i].occu_mcs[4] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[5], ((float) mu_stats->nonmimo[i].occu_mcs[5] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[6], ((float) mu_stats->nonmimo[i].occu_mcs[6] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[7], ((float) mu_stats->nonmimo[i].occu_mcs[7] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[8], ((float) mu_stats->nonmimo[i].occu_mcs[8] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[9], ((float) mu_stats->nonmimo[i].occu_mcs[9] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[10], ((float) mu_stats->nonmimo[i].occu_mcs[10] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_mcs[11], ((float) mu_stats->nonmimo[i].occu_mcs[11] / (float) tot_rx_nonmimo) * 100); + printf("[%" PRIu8 "]%said:0x%x, " + "nsts0:%" PRIu32 "(%2.2f%%), nsts1:%" PRIu32 "(%2.2f%%), nsts2:%" PRIu32 "(%2.2f%%), nsts3:%" PRIu32 "(%2.2f%%)\n", + i, (mu_stats->aid == mu_stats->nonmimo[i].aid) ? "#" : " ", mu_stats->nonmimo[i].aid, + mu_stats->nonmimo[i].occu_nsts[0], ((float) mu_stats->nonmimo[i].occu_nsts[0] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_nsts[1], ((float) mu_stats->nonmimo[i].occu_nsts[1] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_nsts[2], ((float) mu_stats->nonmimo[i].occu_nsts[2] / (float) tot_rx_nonmimo) * 100, + mu_stats->nonmimo[i].occu_nsts[3], ((float) mu_stats->nonmimo[i].occu_nsts[3] / (float) tot_rx_nonmimo) * 100); + printf("[%" PRIu8 "]%said:0x%x, " + "tot_rx_nonmimo:%8d, sta/dut:%2.2f%%\n", + i, (mu_stats->aid == mu_stats->nonmimo[i].aid) ? "#" : " ", mu_stats->nonmimo[i].aid, + tot_rx_nonmimo, ((float) tot_rx_nonmimo / (float) mu_stats->nonmimo_rx) * 100); + } +} + +void print_rx_statistics_mimo(const esp_test_rx_mu_statistics_t *mu_stats) +{ + if (!mu_stats->mimo_rx) { + return; + } + + int i; + int tot_rx_mimo = 0; + ESP_LOGW(TAG, "(mimo)dut rx:%" PRIu32 "", mu_stats->mimo_rx); + ESP_LOGW(TAG, "(mimo)sigb, mcs0:%" PRIu32 "(%2.2f%%), mcs1:%" PRIu32 "(%2.2f%%), mcs2:%" PRIu32 "(%2.2f%%), mcs3:%" PRIu32 "(%2.2f%%), mcs4:%" PRIu32 "(%2.2f%%), mcs5:%" PRIu32 "(%2.2f%%)", + mu_stats->mimo_sigb_mcs[0], ((float) mu_stats->mimo_sigb_mcs[0] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_sigb_mcs[1], ((float) mu_stats->mimo_sigb_mcs[1] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_sigb_mcs[2], ((float) mu_stats->mimo_sigb_mcs[2] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_sigb_mcs[3], ((float) mu_stats->mimo_sigb_mcs[3] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_sigb_mcs[4], ((float) mu_stats->mimo_sigb_mcs[4] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_sigb_mcs[5], ((float) mu_stats->mimo_sigb_mcs[5] / (float) mu_stats->mimo_rx) * 100); + ESP_LOGW(TAG, "(mimo)users num2:%" PRIu32 "(%2.2f%%), num3:%" PRIu32 "(%2.2f%%), num4:%" PRIu32 "(%2.2f%%), num5:%" PRIu32 "(%2.2f%%), num6:%" PRIu32 "(%2.2f%%), num7:%" PRIu32 "(%2.2f%%), num8:%" PRIu32 "(%2.2f%%)", + mu_stats->mimo_user_num_occu[0], ((float) mu_stats->mimo_user_num_occu[0] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_user_num_occu[1], ((float) mu_stats->mimo_user_num_occu[1] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_user_num_occu[2], ((float) mu_stats->mimo_user_num_occu[2] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_user_num_occu[3], ((float) mu_stats->mimo_user_num_occu[3] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_user_num_occu[4], ((float) mu_stats->mimo_user_num_occu[4] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_user_num_occu[5], ((float) mu_stats->mimo_user_num_occu[5] / (float) mu_stats->mimo_rx) * 100, + mu_stats->mimo_user_num_occu[6], ((float) mu_stats->mimo_user_num_occu[6] / (float) mu_stats->mimo_rx) * 100); + for (i = 0; i < ESP_TEST_RX_MU_USER_NUM; i++) { + if (!mu_stats->mimo[i].aid) { + continue; + } + tot_rx_mimo = mu_stats->mimo[i].occu_ss[0] + mu_stats->mimo[i].occu_ss[1] + mu_stats->mimo[i].occu_ss[2] + mu_stats->mimo[i].occu_ss[3]; + printf("[%" PRIu8 "]%said:0x%x, " + "mcs0:%" PRIu32 "(%2.2f%%), mcs1:%" PRIu32 "(%2.2f%%), mcs2:%" PRIu32 "(%2.2f%%), mcs3:%" PRIu32 "(%2.2f%%), mcs4:%" PRIu32 "(%2.2f%%), " + "mcs5:%" PRIu32 "(%2.2f%%), mcs6:%" PRIu32 "(%2.2f%%), mcs7:%" PRIu32 "(%2.2f%%), mcs8:%" PRIu32 "(%2.2f%%), mcs9:%" PRIu32 "(%2.2f%%), " + "mcs10:%" PRIu32 "(%2.2f%%), mcs11:%" PRIu32 "(%2.2f%%)\n", + i, (mu_stats->aid == mu_stats->mimo[i].aid) ? "#" : " ", mu_stats->mimo[i].aid, + mu_stats->mimo[i].occu_mcs[0], ((float) mu_stats->mimo[i].occu_mcs[0] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[1], ((float) mu_stats->mimo[i].occu_mcs[1] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[2], ((float) mu_stats->mimo[i].occu_mcs[2] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[3], ((float) mu_stats->mimo[i].occu_mcs[3] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[4], ((float) mu_stats->mimo[i].occu_mcs[4] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[5], ((float) mu_stats->mimo[i].occu_mcs[5] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[6], ((float) mu_stats->mimo[i].occu_mcs[6] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[7], ((float) mu_stats->mimo[i].occu_mcs[7] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[8], ((float) mu_stats->mimo[i].occu_mcs[8] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[9], ((float) mu_stats->mimo[i].occu_mcs[9] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[10], ((float) mu_stats->mimo[i].occu_mcs[10] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_mcs[11], ((float) mu_stats->mimo[i].occu_mcs[11] / (float) tot_rx_mimo) * 100); + printf("[%" PRIu8 "]%said:0x%x, " + "ss0:%" PRIu32 "(%2.2f%%), ss1:%" PRIu32 "(%2.2f%%), ss2:%" PRIu32 "(%2.2f%%), ss3:%" PRIu32 "(%2.2f%%)\n", + i, (mu_stats->aid == mu_stats->mimo[i].aid) ? "#" : " ", mu_stats->mimo[i].aid, + mu_stats->mimo[i].occu_ss[0], ((float) mu_stats->mimo[i].occu_ss[0] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_ss[1], ((float) mu_stats->mimo[i].occu_ss[1] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_ss[2], ((float) mu_stats->mimo[i].occu_ss[2] / (float) tot_rx_mimo) * 100, + mu_stats->mimo[i].occu_ss[3], ((float) mu_stats->mimo[i].occu_ss[3] / (float) tot_rx_mimo) * 100); + printf("[%" PRIu8 "]%said:0x%x, " + "tot_rx_mimo:%8d, sta/dut:%2.2f%%\n", + i, (mu_stats->aid == mu_stats->mimo[i].aid) ? "#" : " ", mu_stats->mimo[i].aid, + tot_rx_mimo, ((float) tot_rx_mimo / (float) mu_stats->mimo_rx) * 100); + } +} + +void print_hw_rx_statistics(void) +{ + esp_test_hw_rx_statistics_t hw_rx_stats = { 0, }; + esp_test_get_hw_rx_statistics(&hw_rx_stats); + printf( + "WDEVRX_FCS_ERR :%d\n" + "WDEVRX_ABORT :%d\n" + "WDEVRX_ABORT_FCS_PASS :%d\n" + "NRX_ERR_PWRDROP :%d\n" + "NRX_HESIGB_ERR :%d\n" + "WDEVRX_SAMEBM_ERRCNT :%d\n" + "WDEVRX_MPDU :%d\n" + "WDEVRX_END_CNT :%d\n" + "WDEVRX_DATASUC :%d\n" + "WDEVRX_LASTUNMATCH_ERR :%d\n" + "RXHUNG_STATIS :%d\n" + "TXHUNG_STATIS :%d\n" + "RXTXHUNG :%" PRIu32 "\n" + "WDEVRX_CFO :%d\n" + "WDEVRX_SF :%d\n" + "WDEVRX_OTHER_UCAST :%d\n" + "WDEVRX_BUF_FULLCNT :%d\n" + "WDEVRX_FIFO_OVFCNT :%d\n" + "WDEVRX_TKIP_ERRCNT :%d\n" + "WDEVRX_BTBLOCK_ERR :%d\n" + "WDEVRX_FREQHOP_ERR :%d\n" + "WDEVRX_ACK_INT_CNT :%d\n" + "WDEVRX_RTS_INT_CNT :%d\n" + "BRX_ERR_AGC :%d\n" + "BRX_ERR :%d\n" + "NRX_ERR :%d\n" + "NRX_ERR_ABORT :%d\n" + "NRX_ERR_AGCEXIT :%d\n" + "NRX_ERR_BBOFF :%d\n" + "NRX_ERR_FDM_WDG :%d\n" + "NRX_ERR_RESTART :%d\n" + "NRX_ERR_SERV :%d\n" + "NRX_ERR_TXOVER :%d\n" + "NRX_HE_UNSUPPORT :%d\n" + "NRX_HTSIG_ERR :%d\n" + "NRX_HEUNSUPPORT :%d\n" + "NRX_HESIGA_CRC :%d\n", + hw_rx_stats.rx_fcs_err, + hw_rx_stats.rx_abort, + hw_rx_stats.rx_abort_fcs_pass, + hw_rx_stats.nrx_err_pwrdrop, + hw_rx_stats.nrx_hesigb_err, + hw_rx_stats.rx_samebm_errcnt, + hw_rx_stats.rx_mpdu, + hw_rx_stats.rx_end_cnt, + hw_rx_stats.rx_datasuc, + hw_rx_stats.rx_lastunmatch_err, + hw_rx_stats.rxhung_statis, + hw_rx_stats.txhung_statis, + hw_rx_stats.rxtxhung, + hw_rx_stats.rx_cfo_hz, + hw_rx_stats.rx_sf, + hw_rx_stats.rx_other_ucast, + hw_rx_stats.rx_buf_fullcnt, + hw_rx_stats.rx_fifo_ovfcnt, + hw_rx_stats.rx_tkip_errcnt, + hw_rx_stats.rx_btblock_err, + hw_rx_stats.rx_freqhop_err, + hw_rx_stats.rx_ack_int_cnt, + hw_rx_stats.rx_rts_int_cnt, + hw_rx_stats.brx_err_agc, + hw_rx_stats.brx_err, + hw_rx_stats.nrx_err, + hw_rx_stats.nrx_err_abort, + hw_rx_stats.nrx_err_agcexit, + hw_rx_stats.nrx_err_bboff, + hw_rx_stats.nrx_err_fdm_wdg, + hw_rx_stats.nrx_err_restart, + hw_rx_stats.nrx_err_serv, + hw_rx_stats.nrx_err_txover, + hw_rx_stats.nrx_err_unsupport, + hw_rx_stats.nrx_htsig_err, + hw_rx_stats.nrx_heunsupport, + hw_rx_stats.nrx_hesiga_crc + ); +} + +int wifi_cmd_clr_rx_statistics(int argc, char **argv) +{ + ESP_LOGW(TAG, "Clear rx statistics"); + esp_wifi_clr_rx_statistics(0); + esp_wifi_clr_rx_statistics(7); +#if CONFIG_ESP_WIFI_ENABLE_WIFI_RX_MU_STATS + esp_test_clr_rx_error_occurs(); + esp_wifi_clr_rx_mu_statistics(); +#endif + esp_test_clr_hw_statistics(); + return 0; +} + +void print_rx_mu_statistics(void) +{ + /* mu */ + esp_wifi_get_rx_mu_statistics(&rx_mu_stats); + /* MIMO */ + print_rx_statistics_mimo(&rx_mu_stats); + /* non-MIMO */ + print_rx_statistics_nonmimo(&rx_mu_stats); +} + +int wifi_cmd_get_rx_statistics(int argc, char **argv) +{ + ESP_LOGW(TAG, "Get rx statistics"); + esp_test_rx_statistics_t rx_stats = { 0, }; + esp_test_rx_error_occurs_t rx_error_occurs = { 0, }; + + esp_wifi_get_rx_statistics(0, &rx_stats); //tid=0 + print_hw_tb_statistics(); + + ESP_LOGW(TAG, "(0)legacy:%" PRIu32 ", ht(ht:%" PRIu32 ", ht_retry:%" PRIu32 "/%2.2f%%, ht_noeb:%" PRIu32 "/%2.2f%%)", + rx_stats.legacy, + rx_stats.ht, rx_stats.ht_retry, + rx_stats.ht_retry ? ((float) ((float) rx_stats.ht_retry / (float) rx_stats.ht) * 100) : 0, + rx_stats.ht_noeb, rx_stats.ht_noeb ? ((float) ((float) rx_stats.ht_noeb / (float) rx_stats.ht) * 100) : 0); + ESP_LOGW(TAG, "(0)su(su:%" PRIu32 ", su_txbf:%" PRIu32 ", su_stbc:%" PRIu32 ", su_retry:%" PRIu32 "/%2.2f%%, ersu:%" PRIu32 ", ersu_dcm:%" PRIu32 ", su_noeb:%" PRIu32 "/%2.2f%%)", + rx_stats.su, + rx_stats.su_txbf, rx_stats.su_stbc, + rx_stats.su_retry, + rx_stats.su_retry ? ((float) ((float) rx_stats.su_retry / (float) rx_stats.su) * 100) : 0, + rx_stats.ersu, + rx_stats.ersu_dcm, + rx_stats.su_noeb, rx_stats.su_noeb ? ((float) ((float) rx_stats.su_noeb / (float) rx_stats.su) * 100) : 0); + ESP_LOGW(TAG, "(0)mu(mu:%" PRIu32 ", mimo:%" PRIu32 ", non-mimo:%" PRIu32 ", txbf:%" PRIu32 ", stbc:%" PRIu32 ", mu_retry:%" PRIu32 "/%2.2f%%, mu_noeb:%" PRIu32 "/%2.2f%%)", + rx_stats.mu, + rx_stats.mu_mimo, + rx_stats.mu_ofdma, rx_stats.mu_txbf, rx_stats.mu_stbc, + rx_stats.mu_retry, + rx_stats.mu_retry ? ((float) ((float) rx_stats.mu_retry / (float) rx_stats.mu) * 100) : 0, + rx_stats.mu_noeb, rx_stats.mu_noeb ? ((float) ((float) rx_stats.mu_noeb / (float) rx_stats.mu) * 100) : 0); + + memset(&rx_stats, 0, sizeof(rx_stats)); + esp_wifi_get_rx_statistics(7, &rx_stats); //tid=7 + ESP_LOGW(TAG, "(7)legacy:%" PRIu32 ", ht:%" PRIu32 ", su:%" PRIu32 ", su_txbf:%" PRIu32 ", ersu:%" PRIu32 ", mu:%" PRIu32, rx_stats.legacy, + rx_stats.ht, rx_stats.su, rx_stats.su_txbf, rx_stats.ersu, rx_stats.mu); + ESP_LOGW(TAG, "(hw)isr:%" PRIu32 ", nblks:%" PRIu32, rx_stats.rx_isr, rx_stats.rx_nblks); + /* hw rx statistics */ + print_hw_rx_statistics(); +#if CONFIG_ESP_WIFI_ENABLE_WIFI_RX_MU_STATS + print_rx_mu_statistics(); +#endif + esp_test_get_rx_error_occurs(&rx_error_occurs); + ESP_LOGW(TAG, "(rx)tot_errors:%" PRIu32, rx_error_occurs.tot); + int known_errors = 0; //rx error: 0x40-0xff + int i; + for (i = 0; i < 2; i++) { + if (rx_error_occurs.occurs[i]) { + known_errors += rx_error_occurs.occurs[i]; + printf("[%3d] 0x%x, %8" PRIu32 ", %2.2f%%\n", i, (i ? 0xf5 : 0xc6), rx_error_occurs.occurs[i], ((float) rx_error_occurs.occurs[i] / (float) rx_error_occurs.tot) * 100); + } + } + if (rx_error_occurs.tot - known_errors) { + printf("[%3d]others, %8" PRIu32 ", %2.2f%%\n\n", i, rx_error_occurs.tot - known_errors, ((float) known_errors / (float) rx_error_occurs.tot) * 100); + } + wifi_cmd_clr_rx_statistics(0, 0); + return 0; +} + +#endif /* CONFIG_ESP_WIFI_ENABLE_WIFI_TX_STATS || CONFIG_ESP_WIFI_ENABLE_WIFI_RX_STATS */ + +void register_wifi_stats(void) +{ +#if CONFIG_ESP_WIFI_ENABLE_WIFI_TX_STATS + /* get tx statistics */ + const esp_console_cmd_t tx_stats_cmd = { + .command = "tx", + .help = "get tx statistics", + .hint = NULL, + .func = &wifi_cmd_get_tx_statistics, + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&tx_stats_cmd)); + /* clear tx statistics */ + const esp_console_cmd_t clr_cmd = { + .command = "clrtx", + .help = "clear tx statistics", + .hint = NULL, + .func = &wifi_cmd_clr_tx_statistics, + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&clr_cmd)); +#endif + +#if CONFIG_ESP_WIFI_ENABLE_WIFI_RX_STATS + /* get rx statistics */ + const esp_console_cmd_t rx_stats_cmd = { + .command = "rx", + .help = "get rx statistics", + .hint = NULL, + .func = &wifi_cmd_get_rx_statistics, + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&rx_stats_cmd)); + /* clear rx statistics */ + const esp_console_cmd_t clr_rx_cmd = { + .command = "clrrx", + .help = "clear rx statistics", + .hint = NULL, + .func = &wifi_cmd_clr_rx_statistics, + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&clr_rx_cmd)); +#endif +} diff --git a/SillyFilly-Hardware-Attack-Tool/host_p4/sdkconfig.defaults b/SillyFilly-Hardware-Attack-Tool/host_p4/sdkconfig.defaults new file mode 100644 index 0000000..917d07d --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/host_p4/sdkconfig.defaults @@ -0,0 +1,12 @@ + +CONFIG_IDF_TARGET="esp32p4" +CONFIG_ESPTOOLPY_FLASHMODE_QIO=y +CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y +CONFIG_EXAMPLE_ENABLE_STATIC_IP=n +CONFIG_PM_ENABLE=y +CONFIG_PM_SLP_DISABLE_GPIO=y +CONFIG_FREERTOS_HZ=1000 +CONFIG_FREERTOS_USE_TICKLESS_IDLE=y +CONFIG_LWIP_ESP_GRATUITOUS_ARP=n +CONFIG_SLAVE_IDF_TARGET_ESP32C5=y +CONFIG_EXAMPLE_MAX_CPU_FREQ_90=y diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/CMakeLists.txt b/SillyFilly-Hardware-Attack-Tool/slave_c5/CMakeLists.txt new file mode 100644 index 0000000..d6538c6 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/CMakeLists.txt @@ -0,0 +1,62 @@ +# The following lines of boilerplate have to be in your project's CMakeLists +# in this exact order for cmake to work correctly +cmake_minimum_required(VERSION 3.5) + +# Add the wrap flag for esp_wifi_init +add_compile_options(-Wl,--wrap=esp_wifi_init) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +list(APPEND EXCLUDE_COMPONENTS lwip esp_netif) + +set(COMPONENTS esp_timer esptool_py bootloader main nvs_flash esp_rom esp_wifi protocomm driver mqtt wpa_supplicant wifi_provisioning esp_driver_sdio) + +#list(APPEND COMPONENTS esp_gdbstub) # incase gdbstub needed +project(network_adapter) +idf_build_set_property(COMPILE_OPTIONS "-fdiagnostics-color=always" APPEND) + +# for disable 80211 sanity check +add_link_options("-Wl,-z,muldefs") + +if(EXISTS "${PROJECT_DIR}/../common") + set(common_dir "${PROJECT_DIR}/../common") + message(STATUS "common: ${common_dir}") +elseif(EXISTS "${PROJECT_DIR}/main/common") + set(common_dir "${PROJECT_DIR}/main/common") + message(STATUS "common: ${common_dir}") +else() + message(FATAL_ERROR "Could not find 'common' directory in either '${PROJECT_DIR}/../common' or '${PROJECT_DIR}/main/common'") +endif() + + +if(EXISTS "${common_dir}/esp_hosted_lwip_src_port_hook.h") +idf_component_get_property(lwip lwip COMPONENT_LIB) +if(TARGET ${lwip}) + # Use generator expressions to only apply to non-INTERFACE targets + get_target_property(lwip_type ${lwip} TYPE) + if(NOT lwip_type STREQUAL "INTERFACE_LIBRARY") + message(STATUS "********** Configuring LWIP for network split mode with custom hook **********") + target_include_directories(${lwip} PRIVATE "${common_dir}") + target_compile_definitions(${lwip} PRIVATE "-DESP_IDF_LWIP_HOOK_FILENAME=\"${common_dir}/esp_hosted_lwip_src_port_hook.h\"") + endif() +endif() +endif() + +### read and display FW Version +file(READ "${CMAKE_CURRENT_LIST_DIR}/main/esp_hosted_coprocessor_fw_ver.h" HEADER_CONTENTS) +set(PROJECT_VERSION_REGEX "#define[ \t]+PROJECT_VERSION_MAJOR_1[ \t]+([0-9]+)[ \t\n]+#define[ \t]+PROJECT_VERSION_MINOR_1[ \t]+([0-9]+)[ \t\n]+#define[ \t]+PROJECT_VERSION_PATCH_1[ \t]+([0-9]+)") +string(REGEX MATCH "${PROJECT_VERSION_REGEX}" PROJECT_VERSION_MATCH "${HEADER_CONTENTS}") + +if(PROJECT_VERSION_MATCH) + set(PROJECT_VERSION_MAJOR_1 "${CMAKE_MATCH_1}") + set(PROJECT_VERSION_MINOR_1 "${CMAKE_MATCH_2}") + set(PROJECT_VERSION_PATCH_1 "${CMAKE_MATCH_3}") + + # Construct project version + set(PROJECT_VER "${PROJECT_VERSION_MAJOR_1}.${PROJECT_VERSION_MINOR_1}.${PROJECT_VERSION_PATCH_1}") + + message(*************************************************************************************) + message(" Building ESP-Hosted-MCU FW :: ${PROJECT_VER} ") + message(*************************************************************************************) +else() + message(FATAL_ERROR "Failed to read project version from main/esp_hosted_coprocessor_fw_ver.h") +endif() diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/disable_ieee80211_raw_frame_sanity_check.c b/SillyFilly-Hardware-Attack-Tool/slave_c5/disable_ieee80211_raw_frame_sanity_check.c new file mode 100644 index 0000000..168c648 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/disable_ieee80211_raw_frame_sanity_check.c @@ -0,0 +1,5 @@ +#include + +int ieee80211_raw_frame_sanity_check(int32_t arg, int32_t arg2, int32_t arg3) { + return 0; +} diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/CMakeLists.txt b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/CMakeLists.txt new file mode 100644 index 0000000..30ff884 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/CMakeLists.txt @@ -0,0 +1,70 @@ +if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/common") + set(common_dir "${CMAKE_CURRENT_SOURCE_DIR}/common") +else() + set(common_dir "../../common") +endif() + +set(COMPONENT_SRCS + "slave_control.c" + "${common_dir}/proto/esp_hosted_rpc.pb-c.c" + "${common_dir}/utils/esp_hosted_cli.c" + "protocomm_pserial.c" + "esp_hosted_coprocessor.c" + "slave_bt.c" + "mempool.c" + "stats.c" + "mempool_ll.c" + "host_power_save.c" + "lwip_filter.c" + "disable_ieee80211_raw_frame_sanity_check.c" +) + +set(COMPONENT_ADD_INCLUDEDIRS + "." + "${common_dir}" + "${common_dir}/log" + "${common_dir}/proto" + "${common_dir}/rpc" + "${common_dir}/transport" +) + +# Select BT UART code based on IDF Target +if(CONFIG_IDF_TARGET_ESP32) + list(APPEND COMPONENT_SRCS slave_bt_uart_esp32.c) +elseif(CONFIG_IDF_TARGET_ESP32C3 OR CONFIG_IDF_TARGET_ESP32S3) + list(APPEND COMPONENT_SRCS slave_bt_uart_esp32c3_s3.c) +else() + list(APPEND COMPONENT_SRCS slave_bt_uart_esp32xx.c) +endif() + +if(CONFIG_ESP_SDIO_HOST_INTERFACE) + list(APPEND COMPONENT_SRCS sdio_slave_api.c) +elseif(CONFIG_ESP_SPI_HOST_INTERFACE) + list(APPEND COMPONENT_SRCS spi_slave_api.c) +elseif(CONFIG_ESP_SPI_HD_MODE) + list(APPEND COMPONENT_SRCS spi_hd_slave_api.c) +else(CONFIG_ESP_UART_HOST_INTERFACE) + list(APPEND COMPONENT_SRCS uart_slave_api.c) +endif() + +if(CONFIG_ESP_HOSTED_COPROCESSOR_EXAMPLE_MQTT) + list(APPEND COMPONENT_SRCS mqtt_example.c) +endif() + +if(CONFIG_ESP_HOSTED_COPROCESSOR_EXAMPLE_HTTP_CLIENT) + list(APPEND COMPONENT_SRCS http_req.c) +endif() + +# cli +list(APPEND COMPONENT_ADD_INCLUDEDIRS "${common_dir}/utils") +list(APPEND COMPONENT_SRCS "${common_dir}/utils/esp_hosted_cli.c") + + +register_component() + +# Add directory of protocomm_priv.h to include paths +idf_component_get_property(protocomm_dir protocomm COMPONENT_DIR) +target_include_directories(${COMPONENT_LIB} PRIVATE "${protocomm_dir}/src/common") + +# Add linker options to wrap esp_wifi_init function +target_link_libraries(${COMPONENT_LIB} INTERFACE "-Wl,--wrap=esp_wifi_init") diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/Kconfig.projbuild b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/Kconfig.projbuild new file mode 100644 index 0000000..93cdd47 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/Kconfig.projbuild @@ -0,0 +1,1267 @@ +menu "Example Configuration" + + config ESP_HOSTED_COPROCESSOR + bool + default y + + menu "Bus Config in between Host and Co-processor" + choice ESP_HOST_DEV_BOARD + bool "Configure GPIOs based on an ESP Development Board" + default ESP_HOST_DEV_BOARD_NONE + help + "Preconfigures GPIOs to use based on an ESP Development Board" + + config ESP_HOST_DEV_BOARD_NONE + bool "No specific development board" + + config ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + bool "ESP32-P4-Function-EV-Board" + depends on IDF_TARGET_ESP32C6 + + config C2_C5_MODULE_SUB_BOARD + bool "ESP32-P4 EV Sub-Board for C2 & C5" + depends on IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C5 + endchoice + + choice ESP_HOST_INTERFACE + bool "Transport layer" + default ESP_SDIO_HOST_INTERFACE if SOC_SDIO_SLAVE_SUPPORTED + default ESP_SPI_HOST_INTERFACE + help + Bus interface to be used for communication with the host + + config ESP_SPI_HOST_INTERFACE + bool "SPI Full-duplex" + help + Enable/Disable SPI Full-duplex host interface + + config ESP_SDIO_HOST_INTERFACE + bool "SDIO" + depends on SOC_SDIO_SLAVE_SUPPORTED + help + Enable/Disable SDIO host interface + + # SPI Half Duplex is not supported in ESP32 + config ESP_SPI_HD_HOST_INTERFACE + bool "SPI Half-duplex" + depends on !IDF_TARGET_ESP32 + help + Enable/Disable SPI Half-duplex host interface + + config ESP_UART_HOST_INTERFACE + bool "UART" + help + Enable/Disable UART host interface + endchoice + + menu "SPI Full-duplex Configuration" + depends on ESP_SPI_HOST_INTERFACE + depends on C2_C5_MODULE_SUB_BOARD || !C2_C5_MODULE_SUB_BOARD + + choice ESP_SPI_PRIV_MODE + bool "Slave SPI mode" + default ESP_SPI_PRIV_MODE_2 if IDF_TARGET_ESP32 + default ESP_SPI_PRIV_MODE_3 + + config ESP_SPI_PRIV_MODE_0 + bool "Slave SPI mode 0" + + config ESP_SPI_PRIV_MODE_1 + bool "Slave SPI mode 1" + + config ESP_SPI_PRIV_MODE_2 + bool "Slave SPI mode 2" + + config ESP_SPI_PRIV_MODE_3 + bool "Slave SPI mode 3" + endchoice + + config ESP_SPI_MODE + int + default 0 if ESP_SPI_PRIV_MODE_0 + default 1 if ESP_SPI_PRIV_MODE_1 + default 2 if ESP_SPI_PRIV_MODE_2 + default 3 if ESP_SPI_PRIV_MODE_3 + default 3 + + + choice SPI_CONTROLLER + bool "SPI controller to use" + default SPI_HSPI + + config SPI_HSPI + bool "FSPI/HSPI" + help + "HSPI/FSPI: SPI_controller_1" + + config SPI_VSPI + depends on IDF_TARGET_ESP32 + bool "VSPI" + help + "VSPI: SPI_controller_2" + + endchoice + + config ESP_SPI_CONTROLLER + int + default 2 if SPI_VSPI + default 1 + + menu "Hosted SPI GPIOs" + config ESP_SPI_HSPI_GPIO_MOSI + depends on SPI_HSPI + int "Slave GPIO pin for Host MOSI" + default 20 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 13 if IDF_TARGET_ESP32 + default 11 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 7 + help + SPI controller Host MOSI + + config ESP_SPI_HSPI_GPIO_MISO + depends on SPI_HSPI + int "Slave GPIO pin for Host MISO" + default 21 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 12 if IDF_TARGET_ESP32 + default 13 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 2 + help + SPI controller Host MISO + + config ESP_SPI_HSPI_GPIO_CLK + depends on SPI_HSPI + int "Slave GPIO pin for Host CLK" + default 19 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 3 if IDF_TARGET_ESP32C5 + default 0 if IDF_TARGET_ESP32C2 && C2_C5_MODULE_SUB_BOARD + default 14 if IDF_TARGET_ESP32 + default 12 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 6 + help + SPI controller Host CLK + + config ESP_SPI_HSPI_GPIO_CS + depends on SPI_HSPI + int "Slave GPIO pin for Host CS" + default 18 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 15 if IDF_TARGET_ESP32 + default 10 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + default 10 + help + SPI controller Host CS + + config ESP_SPI_VSPI_GPIO_MOSI + depends on SPI_VSPI + int "Slave GPIO pin for Host MOSI" + default 23 + help + SPI controller Host MOSI + + config ESP_SPI_VSPI_GPIO_MISO + depends on SPI_VSPI + int "Slave GPIO pin for Host MISO" + default 19 + help + SPI controller Host MISO + + config ESP_SPI_VSPI_GPIO_CLK + depends on SPI_VSPI + int "Slave GPIO pin for Host CLK" + default 18 + help + SPI controller Host CLK + + config ESP_SPI_VSPI_GPIO_CS + depends on SPI_VSPI + int "Slave GPIO pin for Host CS" + default 5 + help + SPI controller Host CS + + config ESP_SPI_GPIO_MOSI + int + default ESP_SPI_VSPI_GPIO_MOSI if SPI_VSPI + default ESP_SPI_HSPI_GPIO_MOSI + + config ESP_SPI_GPIO_MISO + int + default ESP_SPI_VSPI_GPIO_MISO if SPI_VSPI + default ESP_SPI_HSPI_GPIO_MISO + + config ESP_SPI_GPIO_CLK + int + default ESP_SPI_VSPI_GPIO_CLK if SPI_VSPI + default ESP_SPI_HSPI_GPIO_CLK + + config ESP_SPI_GPIO_CS + int + default ESP_SPI_VSPI_GPIO_CS if SPI_VSPI + default ESP_SPI_HSPI_GPIO_CS + + config ESP_SPI_GPIO_HANDSHAKE + int "Slave GPIO pin for handshake" + default 22 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 18 if IDF_TARGET_ESP32C2 && C2_C5_MODULE_SUB_BOARD + default 3 if IDF_TARGET_ESP32C2 && !C2_C5_MODULE_SUB_BOARD + default 4 if IDF_TARGET_ESP32C5 && C2_C5_MODULE_SUB_BOARD + default 1 if IDF_TARGET_ESP32C5 && !C2_C5_MODULE_SUB_BOARD + default 3 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32C6 + default 17 if IDF_TARGET_ESP32S3 || IDF_TARGET_ESP32S2 + default 26 + help + Slave GPIO pin to use for handshake with other spi controller + + config ESP_SPI_GPIO_DATA_READY + int "Slave GPIO pin for data ready interrupt" + default 23 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 1 if IDF_TARGET_ESP32C2 && C2_C5_MODULE_SUB_BOARD + default 4 if IDF_TARGET_ESP32C2 && !C2_C5_MODULE_SUB_BOARD + default 0 if IDF_TARGET_ESP32C5 && C2_C5_MODULE_SUB_BOARD + default 4 if IDF_TARGET_ESP32C5 && !C2_C5_MODULE_SUB_BOARD + default 4 + help + Slave GPIO pin for indicating host that SPI slave has data to be read by host + + config ESP_SPI_GPIO_RESET + int "Slave GPIO pin to reset itself" + default -1 + help + Host uses this pin to reset the slave ESP. To re-use ESP 'RST' or 'EN' GPIO, set value to -1 + endmenu + + config ESP_SPI_DEASSERT_HS_ON_CS + bool "Deassert Handshake when SPI CS is deasserted" + default y + help + Deassert Handshake and prepare a new SPI transaction only after + CS has been deasserted. This helps prevent data loss with MCUs + that delay deasserting CS after the end of a SPI transaction + by prematurely starting a new slave SPI transaction + since CS is detected by the slave as still asserted. + + config ESP_SPI_TX_Q_SIZE + int "ESP to Host SPI queue size" + default 10 if IDF_TARGET_ESP32 + default 6 if IDF_TARGET_ESP32C2 && BT_ENABLED + default 10 if IDF_TARGET_ESP32C2 + default 20 + help + Very small tx queue will lower ESP -- SPI --> Host data rate + + config ESP_SPI_RX_Q_SIZE + int "Host to ESP SPI queue size" + default 10 if IDF_TARGET_ESP32 + default 6 if IDF_TARGET_ESP32C2 && BT_ENABLED + default 7 if IDF_TARGET_ESP32C2 + default 20 + help + Very small RX queue will lower ESP <-- SPI -- Host data rate + + config ESP_SPI_CHECKSUM + bool "SPI checksum ENABLE/DISABLE" + default y + help + ENABLE/DISABLE software SPI checksum + endmenu + + menu "SDIO Configuration" + depends on ESP_SDIO_HOST_INTERFACE + + config ESP_SDIO_STREAMING_MODE + bool "Enable SDIO Streaming Mode" + default y + help + Enable Streaming Mode. Host to receive queued data from slave + as one stream instead of individual packets. This can improve + host SDIO read performance by doing one large read transaction + instead of many smaller read transactions. + + config ESP_SDIO_GPIO_RESET + int "Slave GPIO pin to reset itself" + default -1 + help + Host uses this pin to reset the slave ESP. To re-use ESP 'RST' or 'EN' GPIO, set value to -1 + + choice + prompt "SDIO Bus Speed" + default ESP_SDIO_HIGH_SPEED + help + Select the SDIO Slave Bus Speed. Actual speed in use depends on SDIO bus speed the SDIO Master can support + + config ESP_SDIO_DEFAULT_SPEED + bool "Default Speed (20 MHz)" + + config ESP_SDIO_HIGH_SPEED + bool "High Speed (40 MHz)" + endchoice + + # from /components/soc//include/soc/sdio_slave_pins.h + menu "Hosted SDIO GPIOs" + config ESP_SDIO_PIN_CMD + int "CMD GPIO number" + range 15 15 if IDF_TARGET_ESP32 + range 18 18 if IDF_TARGET_ESP32C6 + range 25 25 if IDF_TARGET_ESP32C61 + range 10 10 if IDF_TARGET_ESP32C5 + help + "Value cannot be configured. Displayed for reference." + + config ESP_SDIO_PIN_CLK + int "CLK GPIO number" + range 14 14 if IDF_TARGET_ESP32 + range 19 19 if IDF_TARGET_ESP32C6 + range 26 26 if IDF_TARGET_ESP32C61 + range 9 9 if IDF_TARGET_ESP32C5 + help + "Value cannot be configured. Displayed for reference." + + config ESP_SDIO_PIN_D0 + int "D0 GPIO number" + range 2 2 if IDF_TARGET_ESP32 + range 20 20 if IDF_TARGET_ESP32C6 + range 27 27 if IDF_TARGET_ESP32C61 + range 8 8 if IDF_TARGET_ESP32C5 + help + "Value cannot be configured. Displayed for reference." + + config ESP_SDIO_PIN_D1 + int "D1 GPIO number" + range 4 4 if IDF_TARGET_ESP32 + range 21 21 if IDF_TARGET_ESP32C6 + range 28 28 if IDF_TARGET_ESP32C61 + range 7 7 if IDF_TARGET_ESP32C5 + help + "Value cannot be configured. Displayed for reference." + + config ESP_SDIO_PIN_D2 + int "D2 GPIO number" + range 12 12 if IDF_TARGET_ESP32 + range 22 22 if IDF_TARGET_ESP32C6 + range 22 22 if IDF_TARGET_ESP32C61 + range 14 14 if IDF_TARGET_ESP32C5 + help + "Value cannot be configured. Displayed for reference." + + config ESP_SDIO_PIN_D3 + int "D3 GPIO number" + range 13 13 if IDF_TARGET_ESP32 + range 23 23 if IDF_TARGET_ESP32C6 + range 23 23 if IDF_TARGET_ESP32C61 + range 13 13 if IDF_TARGET_ESP32C5 + help + "Value cannot be configured. Displayed for reference." + endmenu + + choice + prompt "SDIO Slave Timing" + default ESP_SDIO_PSEND_PSAMPLE + help + Select the SDIO timing used by slave. Default value works with most + SDMMC controllers but if transfer errors are encountered, selecting a + different timing may help resolve the errors. + See https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/sdio_slave.html#_CPPv419sdio_slave_timing_t + for more information + + config ESP_SDIO_PSEND_PSAMPLE + bool "Send at positive edge, sample at positive edge" + + config ESP_SDIO_NSEND_PSAMPLE + bool "Send at negative edge, sample at positive edge" + + config ESP_SDIO_PSEND_NSAMPLE + bool "Send at positive edge, sample at negative edge" + + config ESP_SDIO_NSEND_NSAMPLE + bool "Send at negative edge, sample at negative edge" + endchoice + + config ESP_SDIO_TX_Q_SIZE + int "SDIO TX queue size" + default 10 if IDF_TARGET_ESP32C61 + default 20 + help + Very small TX queue will lower ESP --> SDIO -- Host data rate + + config ESP_SDIO_RX_Q_SIZE + int "SDIO RX queue size" + default 10 if IDF_TARGET_ESP32C61 + default 20 + help + Very small RX queue will lower ESP <-- SDIO -- Host data rate + + config ESP_SDIO_CHECKSUM + bool "SDIO checksum ENABLE/DISABLE" + default n + help + ENABLE/DISABLE software SDIO checksum + + endmenu + + menu "SPI Half-duplex Configuration" + depends on ESP_SPI_HD_HOST_INTERFACE + + choice ESP_SPI_HD_PRIV_MODE + bool "Slave SPI mode" + default ESP_SPI_HD_PRIV_MODE_3 + + config ESP_SPI_HD_PRIV_MODE_0 + bool "Slave SPI mode 0" + + config ESP_SPI_HD_PRIV_MODE_1 + bool "Slave SPI mode 1" + + config ESP_SPI_HD_PRIV_MODE_2 + bool "Slave SPI mode 2" + + config ESP_SPI_HD_PRIV_MODE_3 + bool "Slave SPI mode 3" + endchoice + + config ESP_SPI_HD_MODE + int + default 0 if ESP_SPI_HD_PRIV_MODE_0 + default 1 if ESP_SPI_HD_PRIV_MODE_1 + default 2 if ESP_SPI_HD_PRIV_MODE_2 + default 3 if ESP_SPI_HD_PRIV_MODE_3 + help + SPI Mode to use. The same mode must be used on both host and slave. + + choice ESP_SPI_HD_PRIV_INTERFACE_NUM_DATA_LINES + bool "Num Data Lines to use" + default ESP_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + help + Number of Data Lines to use in the SPI HD interface + + config ESP_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + bool "4 data lines" + + config ESP_SPI_HD_PRIV_INTERFACE_2_DATA_LINES + bool "2 data lines" + endchoice + + config ESP_SPI_HD_INTERFACE_NUM_DATA_LINES + int + default 4 if ESP_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + default 2 if ESP_SPI_HD_PRIV_INTERFACE_2_DATA_LINES + + menu "GPIOs" + + config ESP_SPI_HD_GPIO_CS + int "Slave GPIO pin for Host CS" + default 18 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 10 + help + SPI HD controller Host CS + + config ESP_SPI_HD_GPIO_CLK + int "Slave GPIO pin for Host CLK" + default 19 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 3 if IDF_TARGET_ESP32C5 + default 0 if IDF_TARGET_ESP32C2 + default 6 + help + SPI HD controller Host CS + + config ESP_SPI_HD_GPIO_D0 + int "Slave GPIO pin for Host D0" + default 20 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 7 + help + SPI HD controller Host D0 + + config ESP_SPI_HD_GPIO_D1 + int "Slave GPIO pin for Host D1" + default 21 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 2 + help + SPI HD controller Host D1 + + config ESP_SPI_HD_GPIO_D2 + depends on ESP_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + int "Slave GPIO pin for Host D2" + default 22 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 5 + help + SPI HD controller Host D2 + + config ESP_SPI_HD_GPIO_D3 + depends on ESP_SPI_HD_PRIV_INTERFACE_4_DATA_LINES + int "Slave GPIO pin for Host D3" + default 23 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 4 + help + SPI HD controller Host D3 + + config ESP_SPI_HD_GPIO_DATA_READY + int "Slave GPIO pin for Data Ready" + default 2 if ESP_HOST_DEV_BOARD_P4_FUNC_BOARD + default 0 if IDF_TARGET_ESP32C5 + default 1 if IDF_TARGET_ESP32C2 + default 11 + help + Slave GPIO pin for indicating host that SPI slave has data to be read by host + + choice ESP_SPI_HD_DATAREADY_GPIO_CONFIG + bool "DataReady GPIO Config" + default ESP_DR_ACTIVE_HIGH + help + Configure Data Ready to be active high (default) or active low + + config ESP_DR_ACTIVE_HIGH + bool "Active High" + config ESP_DR_ACTIVE_LOW + bool "Active Low" + endchoice + + config ESP_SPI_HD_GPIO_RESET + int "Slave GPIO pin to reset itself" + default -1 + help + Host uses this pin to reset the slave ESP. To re-use ESP 'RST' or 'EN' GPIO, set value to -1 + + endmenu + + config ESP_SPI_HD_Q_SIZE + int "Queue size" + default 12 if IDF_TARGET_ESP32C2 + default 10 if IDF_TARGET_ESP32C5 + default 20 + help + Very small queue will lower SPI HD data rate + + config ESP_SPI_HD_CHECKSUM + bool "Checksum ENABLE/DISABLE" + default y + help + ENABLE/DISABLE SPI HD software checksum + + endmenu + + menu "UART Configuration" + depends on ESP_UART_HOST_INTERFACE + + config ESP_UART_PORT + int "UART Port to Use" + default 1 + range 0 2 if IDF_TARGET_ESP32 + range 0 1 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32C5 || IDF_TARGET_ESP32C6 + range 0 2 if IDF_TARGET_ESP32C61 + range 0 1 if IDF_TARGET_ESP32S2 + range 0 2 if IDF_TARGET_ESP32S3 + help + Select UART Port to Use. Do not select the UART Port used for console output (if enabled) + + config ESP_UART_PIN_TX + int "TX GPIO number" + default 13 if IDF_TARGET_ESP32 + default 5 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 + default 14 if IDF_TARGET_ESP32C5 + default 21 if IDF_TARGET_ESP32C6 + default 5 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + help + GPIO used for UART TX + + config ESP_UART_PIN_RX + int "RX GPIO number" + default 12 if IDF_TARGET_ESP32 + default 4 if IDF_TARGET_ESP32C2 || IDF_TARGET_ESP32C3 + default 13 if IDF_TARGET_ESP32C5 + default 20 if IDF_TARGET_ESP32C6 + default 4 if IDF_TARGET_ESP32S2 || IDF_TARGET_ESP32S3 + help + GPIO used for UART RX + + config ESP_UART_BAUDRATE + int "Baud Rate" + default 921600 + range 9600 3500000 + help + Baud Rate to Use. Make sure Hardware supports the rate. Standard rates are 9600, 19200, 38400, 57600, 115200, 460800, 921600 + + config ESP_UART_NUM_DATA_BITS + int "Number of Data Bits" + default 8 + range 5 8 + help + Number of Data Bits to use + + choice ESP_UART_PRIV_PARITY + bool "Parity" + + config ESP_UART_PRIV_PARITY_NONE + bool "None" + + config ESP_UART_PRIV_PARITY_EVEN + bool "Even" + + config ESP_UART_PRIV_PARITY_ODD + bool "Odd" + endchoice + + config ESP_UART_PARITY + int + default 0 if ESP_UART_PRIV_PARITY_NONE + default 1 if ESP_UART_PRIV_PARITY_EVEN + default 2 if ESP_UART_PRIV_PARITY_ODD + + choice ESP_UART_PRIV_STOP_BITS + bool "Number of Stop Bits" + + config ESP_UART_PRIV_STOP_BITS_1 + bool "1" + + config ESP_UART_PRIV_STOP_BITS_1_5 + bool "1.5" + + config ESP_UART_PRIV_STOP_BITS_2 + bool "2" + endchoice + + config ESP_UART_STOP_BITS + int + default 0 if ESP_UART_PRIV_STOP_BITS_1 + default 1 if ESP_UART_PRIV_STOP_BITS_1_5 + default 2 if ESP_UART_PRIV_STOP_BITS_2 + + config ESP_UART_GPIO_RESET + int "Slave GPIO pin to reset itself" + default -1 + help + Host uses this pin to reset the slave ESP. To re-use ESP 'RST' or 'EN' GPIO, set value to -1 + + config ESP_UART_TX_Q_SIZE + int "Tx Queue Size" + default 5 + help + UART rates are low, so large queue sizes are not required + + config ESP_UART_RX_Q_SIZE + int "Rx Queue Size" + default 5 + help + UART rates are low, so large queue sizes are not required + + config ESP_UART_CHECKSUM + bool "UART checksum ENABLE/DISABLE" + default y + help + ENABLE/DISABLE software UART checksum + endmenu + + config ESP_GPIO_SLAVE_RESET + int + default ESP_SPI_GPIO_RESET if ESP_SPI_HOST_INTERFACE + default ESP_SDIO_GPIO_RESET if ESP_SDIO_HOST_INTERFACE + default ESP_SPI_HD_GPIO_RESET if ESP_SPI_HD_HOST_INTERFACE + default ESP_UART_GPIO_RESET if ESP_UART_HOST_INTERFACE + + endmenu + + # HCI UART menu for ESP32-C3/S3 + menu "HCI UART Settings" + depends on BT_CTRL_HCI_MODE_UART_H4 && (IDF_TARGET_ESP32C3 || IDF_TARGET_ESP32S3) + + # only S3 has two UART ports to select from + config ESP_HOSTED_PRIV_BT_UART_PORT_ESP32_S3 + int "HCI UART Port" + depends on IDF_TARGET_ESP32S3 + default 1 + range 1 2 + help + UART Port for HCI + + config ESP_HOSTED_BT_UART_PORT_ESP32_C3_S3 + int + default ESP_HOSTED_PRIV_BT_UART_PORT_ESP32_S3 if IDF_TARGET_ESP32S3 + default 1 + + config ESP_HOSTED_BT_UART_BAUDRATE_ESP32_C3_S3 + int "HCI UART Baudrate" + range 115200 921600 + default 921600 + help + UART Baudrate for HCI. Please use standard baudrate. + + config ESP_HOSTED_BT_UART_TX_PIN_ESP32_C3_S3 + int "HCI UART Tx Pin" + default 5 if IDF_TARGET_ESP32C3 + default 16 + help + UART Tx Pin for HCI + + config ESP_HOSTED_BT_UART_RX_PIN_ESP32_C3_S3 + int "HCI UART Rx Pin" + default 18 + help + UART Rx Pin for HCI + + choice ESP_HOSTED_PRIV_BT_UART_FLOWCONTROL_ESP32_C3_S3 + bool "HCI UART Flow Control" + default ESP_HOSTED_BT_UART_FLOWCONTROL_DISABLED + + config ESP_HOSTED_BT_UART_FLOWCONTROL_DISABLED + bool "Disabled" + + config ESP_HOSTED_BT_UART_FLOWCONTROL_ENABLED + bool "Enabled" + endchoice + + config ESP_HOSTED_BT_UART_FLOWCONTROL_ESP32_C3_S3 + int + default 3 if ESP_HOSTED_BT_UART_FLOWCONTROL_ENABLED + default 0 + + config ESP_HOSTED_BT_UART_RTS_PIN_ESP32_C3_S3 + depends on ESP_HOSTED_BT_UART_FLOWCONTROL_ENABLED + int "HCI UART RTS Pin" + default 19 + help + UART RTS Pin for HCI + + config ESP_HOSTED_BT_UART_CTS_PIN_ESP32_C3_S3 + depends on ESP_HOSTED_BT_UART_FLOWCONTROL_ENABLED + int "HCI UART CTS Pin" + default 1 if IDF_TARGET_ESP32C3 + default 20 + help + UART CTS Pin for HCI + + endmenu + + # HCI UART menu for ESP32 + menu "HCI UART Settings" + depends on BTDM_CTRL_HCI_MODE_UART_H4 && IDF_TARGET_ESP32 + + config ESP_HOSTED_BT_UART_TX_PIN_ESP32 + int "HCI UART Tx Pin" + default 5 + help + UART Tx Pin for HCI + + config ESP_HOSTED_BT_UART_RX_PIN_ESP32 + int "HCI UART Rx Pin" + default 18 + help + UART Rx Pin for HCI + + config ESP_HOSTED_BT_UART_RTS_PIN_ESP32 + depends on BTDM_CTRL_HCI_UART_FLOW_CTRL_EN + int "HCI UART RTS Pin" + default 19 + help + UART RTS Pin for HCI + + config ESP_HOSTED_BT_UART_CTS_PIN_ESP32 + depends on BTDM_CTRL_HCI_UART_FLOW_CTRL_EN + int "HCI UART CTS Pin" + default 23 + help + UART CTS Pin for HCI + + comment "HCI UART Settings from Bluetooth Component" + comment "To change Port, Baud Rate, Flow Control, select Component config ---> Bluetooth ---> Controller Options ---> HCI Config" + + config ESP_HOSTED_BT_UART_PORT_ESP32 + int "HCI UART Port" + range BTDM_CTRL_HCI_UART_NO BTDM_CTRL_HCI_UART_NO + help + UART Port for HCI + + config ESP_HOSTED_BT_UART_BAUDRATE_ESP32 + int "HCI UART Baudrate" + range BTDM_CTRL_HCI_UART_BAUDRATE BTDM_CTRL_HCI_UART_BAUDRATE + help + UART Baudrate for HCI. Please use standard baudrate. + + endmenu + + # HCI UART menu for other ESP32 chips + menu "HCI UART Settings" + depends on BT_LE_HCI_INTERFACE_USE_UART && !IDF_TARGET_ESP32 && !IDF_TARGET_ESP32C3 && !IDF_TARGET_ESP32S3 + comment "HCI UART Settings from Bluetooth Component" + comment "To change, select Component config ---> Bluetooth ---> Controller Options ---> HCI Config" + + config ESP_HOSTED_BT_UART_PORT + int "HCI UART Port" + range BT_LE_HCI_UART_PORT BT_LE_HCI_UART_PORT # kconfig ignore: multiple-definition + help + UART Port for HCI + + config ESP_HOSTED_BT_UART_TX_PIN + int "HCI UART Tx Pin" + range BT_LE_HCI_UART_TX_PIN BT_LE_HCI_UART_TX_PIN + help + UART Tx Pin for HCI + + config ESP_HOSTED_BT_UART_RX_PIN + int "HCI UART Rx Pin" + range BT_LE_HCI_UART_RX_PIN BT_LE_HCI_UART_RX_PIN + help + UART Rx Pin for HCI + + config ESP_HOSTED_BT_UART_RTS_PIN + depends on BT_LE_HCI_UART_FLOWCTRL + int "HCI UART RTS Pin" + range BT_LE_HCI_UART_RTS_PIN BT_LE_HCI_UART_RTS_PIN + help + UART RTS Pin for HCI + + config ESP_HOSTED_BT_UART_CTS_PIN + depends on BT_LE_HCI_UART_FLOWCTRL + int "HCI UART CTS Pin" + range BT_LE_HCI_UART_CTS_PIN BT_LE_HCI_UART_CTS_PIN + help + UART CTS Pin for HCI + + config ESP_HOSTED_BT_UART_BAUDRATE + int "HCI UART Baudrate" + range BT_LE_HCI_UART_BAUD BT_LE_HCI_UART_BAUD + help + UART Baudrate for HCI. Please use standard baudrate. + + endmenu + + config ESP_HOSTED_DEFAULT_TASK_STACK_SIZE + int "ESP-Hosted task stack size" + default 4096 + help + Default task size of ESP-Hosted tasks + + config ESP_HOSTED_DEFAULT_TASK_PRIORITY + int "ESP-Hosted task priority" + default 22 + help + Default task priority of ESP-Hosted tasks + + config ESP_CACHE_MALLOC + bool "Enable Mempool" + default y + help + Mempool will help to alloc buffer without going to heap for every memory allocation or free + + config ESP_OTA_WORKAROUND + bool "OTA workaround - Add sleeps while OTA write" + default y + help + Enable/disable sleeps while OTA operations + + config ESP_WIFI_DPP_SUPPORT + bool "Enable Wi-Fi Easy Connect (DPP)" + default n + help + Enable Wi-Fi Easy Connect (DPP) support + + menu "Hosted Debugging" + config ESP_RAW_THROUGHPUT_TRANSPORT + bool "RawTP: Transport level throughput debug test" + default n + help + Find max transport performance which helps to assess stability of porting done + + config ESP_RAW_TP_ESP_TO_HOST_PKT_LEN + depends on ESP_RAW_THROUGHPUT_TRANSPORT + int "RawTP: ESP to Host packet size" + range 1 1500 + default 1460 + + config ESP_RAW_TP_REPORT_INTERVAL + depends on ESP_RAW_THROUGHPUT_TRANSPORT + int "RawTP: periodic duration to report stats accumulated" + default 10 + + config ESP_PKT_STATS + bool "Transport level packet stats" + default n + help + On comparing with slave packet stats helps to understand any packet loss at hosted + + config ESP_PKT_STATS_INTERVAL_SEC + depends on ESP_PKT_STATS + int "Packet stats reporting interval (sec)" + default 30 + + config ESP_HOSTED_FUNCTION_PROFILING + bool "Enable function execution time profiling" + default n + help + Enable this option to measure and report function execution times. + This is useful for performance profiling and optimization. + + config ESP_HOSTED_FUNCTION_PROFILING_MAX_ENTRIES + int "Maximum number of functions to profile" + depends on ESP_HOSTED_FUNCTION_PROFILING + default 10 + range 1 50 + help + Maximum number of unique functions that can be profiled simultaneously. + Each entry consumes memory, so keep this value reasonable based on + available memory. + endmenu + + config ESP_HOSTED_NETWORK_SPLIT_ENABLED + bool "Enable Network Split: Shared IP address between host and slave" + depends on !IDF_TARGET_ESP32C2 && !IDF_TARGET_ESP32C3 + default n + help + Enables the LWIP stack on the slave to process its own set of ports, + alongside the host stack. Helps split network traffic and allows + background tasks on the slave, even when the host is in low-power mode. + + menu "Network Split Configuration" + depends on ESP_HOSTED_NETWORK_SPLIT_ENABLED + + choice + prompt "Destination LWIP for unfiltered packet" + default ESP_DEFAULT_LWIP_SLAVE + help + Packets having destination port within 'remote' port range are forwarded to host. Rest unfiltered packets, are to be sent to this LWIP. Please note: + (1) These settings are only for IP packets, yet. + (2) Extra filtering may be in effect to respond some packets locally by slave LWIP. + + config ESP_DEFAULT_LWIP_SLAVE + bool "Send packet to slave LWIP" + + config ESP_DEFAULT_LWIP_HOST + bool "Send packet to host LWIP" + + config ESP_DEFAULT_LWIP_BOTH + bool "Send packet to both LWIPs" + endchoice + + menu "Host Static Port Forwarding" + + config ESP_HOSTED_HOST_RESERVED_PORTS_CONFIGURED + bool "Extra port forwarding to host (static)" + default y + help + Enable static port forwarding to host for specific ports + + config ESP_HOSTED_HOST_RESERVED_TCP_SRC_PORTS + depends on ESP_HOSTED_HOST_RESERVED_PORTS_CONFIGURED + string "TCP source ports to forward to host (comma separated)" + default "22,8554" + help + Comma separated list of TCP source ports that will be allowed from host (Max 10) + + config ESP_HOSTED_HOST_RESERVED_TCP_DEST_PORTS + depends on ESP_HOSTED_HOST_RESERVED_PORTS_CONFIGURED + string "TCP destination ports to forward to host (comma separated)" + default "22,80,443,8080,8554" + help + Comma separated list of TCP destination ports that will be forwarded to host (Max 10) + + config ESP_HOSTED_HOST_RESERVED_UDP_SRC_PORTS + depends on ESP_HOSTED_HOST_RESERVED_PORTS_CONFIGURED + string "UDP source ports to allowed from host (comma separated)" + default "" + help + Comma separated list of UDP source ports that will be forwarded to host (Max 10) + + config ESP_HOSTED_HOST_RESERVED_UDP_DEST_PORTS + depends on ESP_HOSTED_HOST_RESERVED_PORTS_CONFIGURED + string "UDP destination ports to forward to host (comma separated)" + default "53,123" + help + Comma separated list of UDP destination ports that will be forwarded to host (Max 10) + endmenu + + menu "Slave side (local) LWIP port range" + config LWIP_TCP_LOCAL_PORT_RANGE_START + int "Slave TCP start port" + default 61440 + help + Slave side TCP start port. Host defaults to 49152 + Slave range: 61440-65535 + Host range: 49152-61439 + + config LWIP_TCP_LOCAL_PORT_RANGE_END + int "Slave TCP end port" + default 65535 + help + Slave side TCP end port. Host defaults to 61439 + Slave range: 61440-65535 + Host range: 49152-61439 + + config LWIP_UDP_LOCAL_PORT_RANGE_START + int "Slave UDP start port" + default 61440 + help + Slave side UDP start port. Host defaults to 49152 + Slave range: 61440-65535 + Host range: 49152-61439 + + config LWIP_UDP_LOCAL_PORT_RANGE_END + int "Slave UDP end port" + default 65535 + help + Slave side UDP end port. Host defaults to 61439 + Slave range: 61440-65535 + Host range: 49152-61439 + endmenu + + menu "Host side (remote) LWIP port range" + config LWIP_TCP_REMOTE_PORT_RANGE_START + int "Host TCP start port" + default 49152 + help + Host side TCP start port. Slave defaults to 61440 + Slave range: 61440-65535 + Host range: 49152-61439 + + config LWIP_TCP_REMOTE_PORT_RANGE_END + int "Host TCP end port" + default 61439 + help + Host side TCP end port. Slave defaults to 65535 + Slave range: 61440-65535 + Host range: 49152-61439 + + config LWIP_UDP_REMOTE_PORT_RANGE_START + int "Host UDP start port" + default 49152 + help + Host side UDP start port. Slave defaults to 61440 + Slave range: 61440-65535 + Host range: 49152-61439 + + config LWIP_UDP_REMOTE_PORT_RANGE_END + int "Host UDP end port" + default 61439 + help + Host side UDP end port. Slave defaults to 65535 + Slave range: 61440-65535 + Host range: 49152-61439 + endmenu + + endmenu + + config ESP_HOSTED_HOST_POWER_SAVE_ENABLED + bool "Allow host to power save" + default n + help + Allow host to enter power save mode. + Host will notify slave before entering and exiting the power save + + menu "Host power save config" + depends on ESP_HOSTED_HOST_POWER_SAVE_ENABLED + + config ESP_HOSTED_HOST_DEEP_SLEEP_ALLOWED + depends on ESP_HOSTED_HOST_POWER_SAVE_ENABLED + bool "Allow host to enter deep sleep. Slave will wakeup host using GPIO when needed" + default y if ESP_HOSTED_HOST_POWER_SAVE_ENABLED + select ESP_HOSTED_CLI_ENABLED + help + Allow host to enter deep sleep mode. Host will notify slave before entering deep sleep. + + menu "Host deep sleep - wakeup config" + depends on ESP_HOSTED_HOST_DEEP_SLEEP_ALLOWED + config ESP_HOSTED_HOST_WAKEUP_GPIO + int "Slave out: Host wakeup GPIO" + default 2 if IDF_TARGET_ESP32C6 && !ESP_SPI_HD_HOST_INTERFACE + default 9 if IDF_TARGET_ESP32C6 && ESP_SPI_HD_HOST_INTERFACE + default 1 if IDF_TARGET_ESP32C3 + default 25 if IDF_TARGET_ESP32C5 + default 6 if IDF_TARGET_ESP32C2 && C2_C5_MODULE_SUB_BOARD + default -1 + + choice ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL + prompt "Host Wakeup GPIO Level" + default ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL_HIGH + + config ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL_HIGH + bool "High" + config ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL_LOW + bool "Low" + endchoice + + config ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL + int + default 1 if ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL_HIGH + default 0 if ESP_HOSTED_HOST_WAKEUP_GPIO_LEVEL_LOW + help + GPIO level to use for host wakeup from sleep. + Set to 0 to use low level, set to 1 to use high level. + endmenu + + config ESP_HOSTED_UNLOAD_BUS_DRIVER_DURING_HOST_SLEEP + depends on ESP_HOSTED_HOST_POWER_SAVE_ENABLED + bool "Unload low level BUS driver during host deep sleep" + default n + + config PRINT_HOST_WAKEUP_PACKET_FULL_PKT + bool "Print the full wakeup packet" + default n + + endmenu + + + config ESP_HOSTED_CLI_ENABLED + bool "Enable CLI Shell" + default y if ESP_HOSTED_HOST_DEEP_SLEEP_ALLOWED + default n if !ESP_HOSTED_HOST_DEEP_SLEEP_ALLOWED + help + Enable CLI shell for debugging and control purposes. + + config ESP_HOSTED_CLI_NEW_INSTANCE + depends on ESP_HOSTED_CLI_ENABLED + bool "Create new instance & do not re-use existing session if any" + default y + + config ESP_HOSTED_USE_EXAMPLE_WIFI_PRE_PROVISION_CONFIG + bool "Wi-Fi default config (pre-provisioning)" + default n + help + Enable this option to use a predefined Wi-Fi configuration for examples. + This can be useful for testing and development purposes where a known + Wi-Fi setup is required. + + + menu "Wi-Fi default config (pre-provisioning)" + depends on ESP_HOSTED_USE_EXAMPLE_WIFI_PRE_PROVISION_CONFIG + + config ESP_WIFI_SSID + string "WiFi SSID" + default "myssid" + help + SSID (network name) for the example to connect to. + + config ESP_WIFI_PASSWORD + string "WiFi Password" + default "mypassword" + help + WiFi password (WPA or WPA2) for the example to use. + + choice ESP_WIFI_SAE_MODE + prompt "WPA3 SAE mode selection" + default ESP_WPA3_SAE_PWE_BOTH + help + Select mode for SAE as Hunt and Peck, H2E or both. + config ESP_WPA3_SAE_PWE_HUNT_AND_PECK + bool "HUNT AND PECK" + config ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT + bool "H2E" + config ESP_WPA3_SAE_PWE_BOTH + bool "BOTH" + endchoice + + config ESP_WIFI_PW_ID + string "PASSWORD IDENTIFIER" + depends on ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT|| ESP_WPA3_SAE_PWE_BOTH + default "" + help + password identifier for SAE H2E + + config ESP_MAXIMUM_RETRY + int "Maximum retry" + default 5 + help + Set the Maximum retry to avoid station reconnecting to the AP unlimited when the AP is really inexistent. + + choice ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD + prompt "WiFi Scan auth mode threshold" + default ESP_WIFI_AUTH_WPA2_PSK + help + The weakest authmode to accept in the scan mode. + This value defaults to ESP_WIFI_AUTH_WPA2_PSK incase password is present and ESP_WIFI_AUTH_OPEN is used. + Please select ESP_WIFI_AUTH_WEP/ESP_WIFI_AUTH_WPA_PSK incase AP is operating in WEP/WPA mode. + + config ESP_WIFI_AUTH_OPEN + bool "OPEN" + config ESP_WIFI_AUTH_WEP + bool "WEP" + config ESP_WIFI_AUTH_WPA_PSK + bool "WPA PSK" + config ESP_WIFI_AUTH_WPA2_PSK + bool "WPA2 PSK" + config ESP_WIFI_AUTH_WPA_WPA2_PSK + bool "WPA/WPA2 PSK" + config ESP_WIFI_AUTH_WPA3_PSK + bool "WPA3 PSK" + config ESP_WIFI_AUTH_WPA2_WPA3_PSK + bool "WPA2/WPA3 PSK" + config ESP_WIFI_AUTH_WAPI_PSK + bool "WAPI PSK" + + endchoice + + choice WIFI_CMD_DEFAULT_COUNTRY + prompt "Set default country during initialize wifi" + default WIFI_CMD_DEFAULT_COUNTRY_CN + help + Set default wifi country during initialize wifi + + config WIFI_CMD_DEFAULT_COUNTRY_NONE + bool + prompt "Do not set country code" + + config WIFI_CMD_DEFAULT_COUNTRY_CN + bool + prompt "Set country code to CN (1-13)" + endchoice + endmenu + + config ESP_HOSTED_EXTRA_EXAMPLES + depends on ESP_HOSTED_NETWORK_SPLIT_ENABLED + bool "Additional higher layer examples to run" + default n + help + Extra set of optional examples to run at slave + + menu "Select Examples to run" + depends on ESP_HOSTED_EXTRA_EXAMPLES + + config ESP_HOSTED_COPROCESSOR_EXAMPLE_MQTT + bool "MQTT client example" + default y + + menu "MQTT client config" + depends on ESP_HOSTED_COPROCESSOR_EXAMPLE_MQTT + choice BROKER_CHOICE + prompt "MQTT Broker" + default BROKER_HIVEMQ + + config BROKER_ECLIPSEPROJECTS + bool "mqtt.eclipseprojects.io" + config BROKER_HIVEMQ + bool "broker.hivemq.com" + endchoice + + config BROKER_URL + string + default "mqtt://mqtt.eclipseprojects.io" if BROKER_ECLIPSEPROJECTS + default "mqtt://broker.hivemq.com" if BROKER_HIVEMQ + help + URL of the broker to connect to + + config BROKER_URL_FROM_STDIN + bool + default y if BROKER_URL = "FROM_STDIN" + + endmenu + + config ESP_HOSTED_COPROCESSOR_EXAMPLE_HTTP_CLIENT + bool "HTTP client example" + default y + + menu "HTTP client config" + depends on ESP_HOSTED_COPROCESSOR_EXAMPLE_HTTP_CLIENT + + config HTTP_WEBSERVER + string "HTTP webserver to send req" + default "example.com" + + config HTTP_WEBSERVER_PORT + string "HTTP webserver port" + default "80" + + config HTTP_WEBSERVER_PATH + string "HTTP webserver path" + default "/" + + config HTTP_REQ_DELAY + int "Delay after every http request (seconds)" + default 10 + + endmenu + endmenu +endmenu diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_header.h b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_header.h new file mode 100644 index 0000000..d7c16ba --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_header.h @@ -0,0 +1,41 @@ +// Copyright 2025 Espressif Systems (Shanghai) PTE LTD +/* SPDX-License-Identifier: GPL-2.0-only OR Apache-2.0 */ + +#ifndef __ESP_HOSTED_HEADER__H +#define __ESP_HOSTED_HEADER__H + +/* Add packet number to debug any drops or out-of-seq packets */ +//#define ESP_PKT_NUM_DEBUG 1 + +struct esp_payload_header { + uint8_t if_type:4; + uint8_t if_num:4; + uint8_t flags; + uint16_t len; + uint16_t offset; + uint16_t checksum; + uint16_t seq_num; + uint8_t throttle_cmd:2; + uint8_t reserved2:6; +#ifdef ESP_PKT_NUM_DEBUG + uint16_t pkt_num; +#endif + /* Position of union field has to always be last, + * this is required for hci_pkt_type */ + union { + uint8_t reserved3; + uint8_t hci_pkt_type; /* Packet type for HCI interface */ + uint8_t priv_pkt_type; /* Packet type for priv interface */ + }; + /* Do no add anything here */ +} __attribute__((packed)); + +/* ESP Payload Header Flags */ +#define MORE_FRAGMENT (1 << 0) +#define FLAG_WAKEUP_PKT (1 << 1) +#define FLAG_POWER_SAVE_STARTED (1 << 2) +#define FLAG_POWER_SAVE_STOPPED (1 << 3) + +#define H_ESP_PAYLOAD_HEADER_OFFSET sizeof(struct esp_payload_header) + +#endif diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_interface.h b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_interface.h new file mode 100644 index 0000000..7574a88 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_interface.h @@ -0,0 +1,30 @@ +/* +* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD +* +* SPDX-License-Identifier: Apache-2.0 +*/ + +#ifndef __ESP_HOSTED_INTERFACE_H__ +#define __ESP_HOSTED_INTERFACE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + ESP_INVALID_IF, + ESP_STA_IF, + ESP_AP_IF, + ESP_SERIAL_IF, + ESP_HCI_IF, + ESP_PRIV_IF, + ESP_TEST_IF, + ESP_ETH_IF, + ESP_MAX_IF, +} esp_hosted_if_type_t; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_lwip_src_port_hook.h b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_lwip_src_port_hook.h new file mode 100644 index 0000000..4ea558f --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/esp_hosted_lwip_src_port_hook.h @@ -0,0 +1,73 @@ +/* + * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ + + +#ifndef __ESP_HOSTED_LWIP_SRC_PORT_HOOK_H__ +#define __ESP_HOSTED_LWIP_SRC_PORT_HOOK_H__ + +#include "sdkconfig.h" + +#if defined(CONFIG_ESP_HOSTED_NETWORK_SPLIT_ENABLED) +#include "lwip/opt.h" +/* ----------------------------------Slave (local) Port Config---------------------------------------- */ +/* If configured, Any new UDP socket would automatically bind as local port within this specified UDP port range. + * Please note, Reserved ports (generally <1024) like DHCP, etc would still work as they generally are hardcoded + */ + +#define ENSURE_PORT_RANGE(port, START, END) \ + (((port) >= (START) && (port) <= (END)) ? \ + (port) : \ + (((port) % ((END) - (START) + 1)) + (START))) + +#ifdef CONFIG_LWIP_TCP_LOCAL_PORT_RANGE_START +#define TCP_LOCAL_PORT_RANGE_START CONFIG_LWIP_TCP_LOCAL_PORT_RANGE_START +#define TCP_LOCAL_PORT_RANGE_END CONFIG_LWIP_TCP_LOCAL_PORT_RANGE_END +#define TCP_ENSURE_LOCAL_PORT_RANGE(port) ENSURE_PORT_RANGE(port, TCP_LOCAL_PORT_RANGE_START, TCP_LOCAL_PORT_RANGE_END) +#if CONFIG_LWIP_TCP_LOCAL_PORT_RANGE_END == 0xffff + #define IS_LOCAL_TCP_PORT(port) (port>=TCP_LOCAL_PORT_RANGE_START) +#else + #define IS_LOCAL_TCP_PORT(port) (port>=TCP_LOCAL_PORT_RANGE_START && (port<=CONFIG_LWIP_TCP_LOCAL_PORT_RANGE_END)) +#endif +#endif + +#ifdef CONFIG_LWIP_TCP_REMOTE_PORT_RANGE_START +#define TCP_REMOTE_PORT_RANGE_START CONFIG_LWIP_TCP_REMOTE_PORT_RANGE_START +#define TCP_REMOTE_PORT_RANGE_END CONFIG_LWIP_TCP_REMOTE_PORT_RANGE_END +#define TCP_ENSURE_REMOTE_PORT_RANGE(port) ENSURE_PORT_RANGE(port, TCP_REMOTE_PORT_RANGE_START, TCP_REMOTE_PORT_RANGE_END) +#if CONFIG_LWIP_TCP_REMOTE_PORT_RANGE_END == 0xffff + #define IS_REMOTE_TCP_PORT(port) (port>=TCP_REMOTE_PORT_RANGE_START) +#else + #define IS_REMOTE_TCP_PORT(port) (port>=TCP_REMOTE_PORT_RANGE_START && (port<=CONFIG_LWIP_TCP_REMOTE_PORT_RANGE_END)) +#endif +#endif + +#ifdef CONFIG_LWIP_UDP_LOCAL_PORT_RANGE_START +#define UDP_LOCAL_PORT_RANGE_START CONFIG_LWIP_UDP_LOCAL_PORT_RANGE_START +#define UDP_LOCAL_PORT_RANGE_END CONFIG_LWIP_UDP_LOCAL_PORT_RANGE_END +#define UDP_ENSURE_LOCAL_PORT_RANGE(port) ENSURE_PORT_RANGE(port, UDP_LOCAL_PORT_RANGE_START, UDP_LOCAL_PORT_RANGE_END) + +#if CONFIG_LWIP_UDP_LOCAL_PORT_RANGE_END == 0xffff + #define IS_LOCAL_UDP_PORT(port) (port>=UDP_LOCAL_PORT_RANGE_START) +#else + #define IS_LOCAL_UDP_PORT(port) (port>=UDP_LOCAL_PORT_RANGE_START && (port<=CONFIG_LWIP_UDP_LOCAL_PORT_RANGE_END)) +#endif +#define DNS_PORT_ALLOWED(port) IS_LOCAL_UDP_PORT(port) +#endif + +#ifdef CONFIG_LWIP_UDP_REMOTE_PORT_RANGE_START +#define UDP_REMOTE_PORT_RANGE_START CONFIG_LWIP_UDP_REMOTE_PORT_RANGE_START +#define UDP_REMOTE_PORT_RANGE_END CONFIG_LWIP_UDP_REMOTE_PORT_RANGE_END +#define UDP_ENSURE_REMOTE_PORT_RANGE(port) ENSURE_PORT_RANGE(port, UDP_REMOTE_PORT_RANGE_START, UDP_REMOTE_PORT_RANGE_END) + +#if CONFIG_LWIP_UDP_REMOTE_PORT_RANGE_END == 0xffff + #define IS_REMOTE_UDP_PORT(port) (port>=UDP_REMOTE_PORT_RANGE_START) +#else + #define IS_REMOTE_UDP_PORT(port) (port>=UDP_REMOTE_PORT_RANGE_START && (port<=CONFIG_LWIP_UDP_REMOTE_PORT_RANGE_END)) +#endif +#endif + +#endif +#endif /* __ESP_HOSTED_LWIP_SOURCE_PORT_BINDING_HOOK_H__ */ diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/log/esp_hosted_log.h b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/log/esp_hosted_log.h new file mode 100644 index 0000000..2c01271 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/log/esp_hosted_log.h @@ -0,0 +1,37 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright 2015-2021 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. +// + +#ifndef __ESP_HOSTED_LOG_H +#define __ESP_HOSTED_LOG_H +#include "esp_log.h" + +#define ESP_PRIV_HEXDUMP(tag1, tag2, buff, buf_len, display_len, curr_level) \ + if ( LOG_LOCAL_LEVEL >= curr_level) { \ + int len_to_print = 0; \ + len_to_print = display_len/common/proto +$ protoc-c esp_hosted_rpc.proto --c_out=. +``` + +## Add new RPC message +To send an new RPC request/response + +1. Add C function in `host/host_common/commands.c` +2. Create python binding in `host/linux/host_control/python_support/commands_map_py_to_c.py` and its python function in `host/linux/host_control/python_support/commands_lib.py`. +3. Add ESP side C function in `esp/esp_driver/network_adapter/main/slave_commands.c`, respective to python function, to handle added message field. + +User can test added functionality using `host/linux/host_control/python_support/test.py`. diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.pb-c.c b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.pb-c.c new file mode 100644 index 0000000..e40ba90 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.pb-c.c @@ -0,0 +1,28773 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: esp_hosted_rpc.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "esp_hosted_rpc.pb-c.h" +void wifi_init_config__init + (WifiInitConfig *message) +{ + static const WifiInitConfig init_value = WIFI_INIT_CONFIG__INIT; + *message = init_value; +} +size_t wifi_init_config__get_packed_size + (const WifiInitConfig *message) +{ + assert(message->base.descriptor == &wifi_init_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_init_config__pack + (const WifiInitConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_init_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_init_config__pack_to_buffer + (const WifiInitConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_init_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiInitConfig * + wifi_init_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiInitConfig *) + protobuf_c_message_unpack (&wifi_init_config__descriptor, + allocator, len, data); +} +void wifi_init_config__free_unpacked + (WifiInitConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_init_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_country__init + (WifiCountry *message) +{ + static const WifiCountry init_value = WIFI_COUNTRY__INIT; + *message = init_value; +} +size_t wifi_country__get_packed_size + (const WifiCountry *message) +{ + assert(message->base.descriptor == &wifi_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_country__pack + (const WifiCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_country__pack_to_buffer + (const WifiCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiCountry * + wifi_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiCountry *) + protobuf_c_message_unpack (&wifi_country__descriptor, + allocator, len, data); +} +void wifi_country__free_unpacked + (WifiCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_active_scan_time__init + (WifiActiveScanTime *message) +{ + static const WifiActiveScanTime init_value = WIFI_ACTIVE_SCAN_TIME__INIT; + *message = init_value; +} +size_t wifi_active_scan_time__get_packed_size + (const WifiActiveScanTime *message) +{ + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_active_scan_time__pack + (const WifiActiveScanTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_active_scan_time__pack_to_buffer + (const WifiActiveScanTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiActiveScanTime * + wifi_active_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiActiveScanTime *) + protobuf_c_message_unpack (&wifi_active_scan_time__descriptor, + allocator, len, data); +} +void wifi_active_scan_time__free_unpacked + (WifiActiveScanTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_active_scan_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_time__init + (WifiScanTime *message) +{ + static const WifiScanTime init_value = WIFI_SCAN_TIME__INIT; + *message = init_value; +} +size_t wifi_scan_time__get_packed_size + (const WifiScanTime *message) +{ + assert(message->base.descriptor == &wifi_scan_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_time__pack + (const WifiScanTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_time__pack_to_buffer + (const WifiScanTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanTime * + wifi_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanTime *) + protobuf_c_message_unpack (&wifi_scan_time__descriptor, + allocator, len, data); +} +void wifi_scan_time__free_unpacked + (WifiScanTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_channel_bitmap__init + (WifiScanChannelBitmap *message) +{ + static const WifiScanChannelBitmap init_value = WIFI_SCAN_CHANNEL_BITMAP__INIT; + *message = init_value; +} +size_t wifi_scan_channel_bitmap__get_packed_size + (const WifiScanChannelBitmap *message) +{ + assert(message->base.descriptor == &wifi_scan_channel_bitmap__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_channel_bitmap__pack + (const WifiScanChannelBitmap *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_channel_bitmap__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_channel_bitmap__pack_to_buffer + (const WifiScanChannelBitmap *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_channel_bitmap__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanChannelBitmap * + wifi_scan_channel_bitmap__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanChannelBitmap *) + protobuf_c_message_unpack (&wifi_scan_channel_bitmap__descriptor, + allocator, len, data); +} +void wifi_scan_channel_bitmap__free_unpacked + (WifiScanChannelBitmap *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_channel_bitmap__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_config__init + (WifiScanConfig *message) +{ + static const WifiScanConfig init_value = WIFI_SCAN_CONFIG__INIT; + *message = init_value; +} +size_t wifi_scan_config__get_packed_size + (const WifiScanConfig *message) +{ + assert(message->base.descriptor == &wifi_scan_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_config__pack + (const WifiScanConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_config__pack_to_buffer + (const WifiScanConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanConfig * + wifi_scan_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanConfig *) + protobuf_c_message_unpack (&wifi_scan_config__descriptor, + allocator, len, data); +} +void wifi_scan_config__free_unpacked + (WifiScanConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_he_ap_info__init + (WifiHeApInfo *message) +{ + static const WifiHeApInfo init_value = WIFI_HE_AP_INFO__INIT; + *message = init_value; +} +size_t wifi_he_ap_info__get_packed_size + (const WifiHeApInfo *message) +{ + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_he_ap_info__pack + (const WifiHeApInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_he_ap_info__pack_to_buffer + (const WifiHeApInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiHeApInfo * + wifi_he_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiHeApInfo *) + protobuf_c_message_unpack (&wifi_he_ap_info__descriptor, + allocator, len, data); +} +void wifi_he_ap_info__free_unpacked + (WifiHeApInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_he_ap_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ap_record__init + (WifiApRecord *message) +{ + static const WifiApRecord init_value = WIFI_AP_RECORD__INIT; + *message = init_value; +} +size_t wifi_ap_record__get_packed_size + (const WifiApRecord *message) +{ + assert(message->base.descriptor == &wifi_ap_record__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ap_record__pack + (const WifiApRecord *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ap_record__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ap_record__pack_to_buffer + (const WifiApRecord *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ap_record__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiApRecord * + wifi_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiApRecord *) + protobuf_c_message_unpack (&wifi_ap_record__descriptor, + allocator, len, data); +} +void wifi_ap_record__free_unpacked + (WifiApRecord *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ap_record__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_scan_threshold__init + (WifiScanThreshold *message) +{ + static const WifiScanThreshold init_value = WIFI_SCAN_THRESHOLD__INIT; + *message = init_value; +} +size_t wifi_scan_threshold__get_packed_size + (const WifiScanThreshold *message) +{ + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_scan_threshold__pack + (const WifiScanThreshold *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_scan_threshold__pack_to_buffer + (const WifiScanThreshold *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiScanThreshold * + wifi_scan_threshold__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiScanThreshold *) + protobuf_c_message_unpack (&wifi_scan_threshold__descriptor, + allocator, len, data); +} +void wifi_scan_threshold__free_unpacked + (WifiScanThreshold *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_scan_threshold__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_pmf_config__init + (WifiPmfConfig *message) +{ + static const WifiPmfConfig init_value = WIFI_PMF_CONFIG__INIT; + *message = init_value; +} +size_t wifi_pmf_config__get_packed_size + (const WifiPmfConfig *message) +{ + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_pmf_config__pack + (const WifiPmfConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_pmf_config__pack_to_buffer + (const WifiPmfConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPmfConfig * + wifi_pmf_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPmfConfig *) + protobuf_c_message_unpack (&wifi_pmf_config__descriptor, + allocator, len, data); +} +void wifi_pmf_config__free_unpacked + (WifiPmfConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_pmf_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_bss_max_idle_config__init + (WifiBssMaxIdleConfig *message) +{ + static const WifiBssMaxIdleConfig init_value = WIFI_BSS_MAX_IDLE_CONFIG__INIT; + *message = init_value; +} +size_t wifi_bss_max_idle_config__get_packed_size + (const WifiBssMaxIdleConfig *message) +{ + assert(message->base.descriptor == &wifi_bss_max_idle_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_bss_max_idle_config__pack + (const WifiBssMaxIdleConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_bss_max_idle_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_bss_max_idle_config__pack_to_buffer + (const WifiBssMaxIdleConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_bss_max_idle_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiBssMaxIdleConfig * + wifi_bss_max_idle_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiBssMaxIdleConfig *) + protobuf_c_message_unpack (&wifi_bss_max_idle_config__descriptor, + allocator, len, data); +} +void wifi_bss_max_idle_config__free_unpacked + (WifiBssMaxIdleConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_bss_max_idle_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ap_config__init + (WifiApConfig *message) +{ + static const WifiApConfig init_value = WIFI_AP_CONFIG__INIT; + *message = init_value; +} +size_t wifi_ap_config__get_packed_size + (const WifiApConfig *message) +{ + assert(message->base.descriptor == &wifi_ap_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ap_config__pack + (const WifiApConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ap_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ap_config__pack_to_buffer + (const WifiApConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ap_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiApConfig * + wifi_ap_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiApConfig *) + protobuf_c_message_unpack (&wifi_ap_config__descriptor, + allocator, len, data); +} +void wifi_ap_config__free_unpacked + (WifiApConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ap_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_sta_config__init + (WifiStaConfig *message) +{ + static const WifiStaConfig init_value = WIFI_STA_CONFIG__INIT; + *message = init_value; +} +size_t wifi_sta_config__get_packed_size + (const WifiStaConfig *message) +{ + assert(message->base.descriptor == &wifi_sta_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_sta_config__pack + (const WifiStaConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_sta_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_sta_config__pack_to_buffer + (const WifiStaConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_sta_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiStaConfig * + wifi_sta_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiStaConfig *) + protobuf_c_message_unpack (&wifi_sta_config__descriptor, + allocator, len, data); +} +void wifi_sta_config__free_unpacked + (WifiStaConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_sta_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_config__init + (WifiConfig *message) +{ + static const WifiConfig init_value = WIFI_CONFIG__INIT; + *message = init_value; +} +size_t wifi_config__get_packed_size + (const WifiConfig *message) +{ + assert(message->base.descriptor == &wifi_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_config__pack + (const WifiConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_config__pack_to_buffer + (const WifiConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiConfig * + wifi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiConfig *) + protobuf_c_message_unpack (&wifi_config__descriptor, + allocator, len, data); +} +void wifi_config__free_unpacked + (WifiConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_sta_info__init + (WifiStaInfo *message) +{ + static const WifiStaInfo init_value = WIFI_STA_INFO__INIT; + *message = init_value; +} +size_t wifi_sta_info__get_packed_size + (const WifiStaInfo *message) +{ + assert(message->base.descriptor == &wifi_sta_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_sta_info__pack + (const WifiStaInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_sta_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_sta_info__pack_to_buffer + (const WifiStaInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_sta_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiStaInfo * + wifi_sta_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiStaInfo *) + protobuf_c_message_unpack (&wifi_sta_info__descriptor, + allocator, len, data); +} +void wifi_sta_info__free_unpacked + (WifiStaInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_sta_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_sta_list__init + (WifiStaList *message) +{ + static const WifiStaList init_value = WIFI_STA_LIST__INIT; + *message = init_value; +} +size_t wifi_sta_list__get_packed_size + (const WifiStaList *message) +{ + assert(message->base.descriptor == &wifi_sta_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_sta_list__pack + (const WifiStaList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_sta_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_sta_list__pack_to_buffer + (const WifiStaList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_sta_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiStaList * + wifi_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiStaList *) + protobuf_c_message_unpack (&wifi_sta_list__descriptor, + allocator, len, data); +} +void wifi_sta_list__free_unpacked + (WifiStaList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_sta_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_pkt_rx_ctrl__init + (WifiPktRxCtrl *message) +{ + static const WifiPktRxCtrl init_value = WIFI_PKT_RX_CTRL__INIT; + *message = init_value; +} +size_t wifi_pkt_rx_ctrl__get_packed_size + (const WifiPktRxCtrl *message) +{ + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_pkt_rx_ctrl__pack + (const WifiPktRxCtrl *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_pkt_rx_ctrl__pack_to_buffer + (const WifiPktRxCtrl *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPktRxCtrl * + wifi_pkt_rx_ctrl__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPktRxCtrl *) + protobuf_c_message_unpack (&wifi_pkt_rx_ctrl__descriptor, + allocator, len, data); +} +void wifi_pkt_rx_ctrl__free_unpacked + (WifiPktRxCtrl *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_pkt_rx_ctrl__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_promiscuous_pkt__init + (WifiPromiscuousPkt *message) +{ + static const WifiPromiscuousPkt init_value = WIFI_PROMISCUOUS_PKT__INIT; + *message = init_value; +} +size_t wifi_promiscuous_pkt__get_packed_size + (const WifiPromiscuousPkt *message) +{ + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_promiscuous_pkt__pack + (const WifiPromiscuousPkt *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_promiscuous_pkt__pack_to_buffer + (const WifiPromiscuousPkt *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPromiscuousPkt * + wifi_promiscuous_pkt__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPromiscuousPkt *) + protobuf_c_message_unpack (&wifi_promiscuous_pkt__descriptor, + allocator, len, data); +} +void wifi_promiscuous_pkt__free_unpacked + (WifiPromiscuousPkt *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_promiscuous_pkt__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_promiscuous_filter__init + (WifiPromiscuousFilter *message) +{ + static const WifiPromiscuousFilter init_value = WIFI_PROMISCUOUS_FILTER__INIT; + *message = init_value; +} +size_t wifi_promiscuous_filter__get_packed_size + (const WifiPromiscuousFilter *message) +{ + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_promiscuous_filter__pack + (const WifiPromiscuousFilter *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_promiscuous_filter__pack_to_buffer + (const WifiPromiscuousFilter *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiPromiscuousFilter * + wifi_promiscuous_filter__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiPromiscuousFilter *) + protobuf_c_message_unpack (&wifi_promiscuous_filter__descriptor, + allocator, len, data); +} +void wifi_promiscuous_filter__free_unpacked + (WifiPromiscuousFilter *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_promiscuous_filter__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_csi_config__init + (WifiCsiConfig *message) +{ + static const WifiCsiConfig init_value = WIFI_CSI_CONFIG__INIT; + *message = init_value; +} +size_t wifi_csi_config__get_packed_size + (const WifiCsiConfig *message) +{ + assert(message->base.descriptor == &wifi_csi_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_csi_config__pack + (const WifiCsiConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_csi_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_csi_config__pack_to_buffer + (const WifiCsiConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_csi_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiCsiConfig * + wifi_csi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiCsiConfig *) + protobuf_c_message_unpack (&wifi_csi_config__descriptor, + allocator, len, data); +} +void wifi_csi_config__free_unpacked + (WifiCsiConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_csi_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_csi_info__init + (WifiCsiInfo *message) +{ + static const WifiCsiInfo init_value = WIFI_CSI_INFO__INIT; + *message = init_value; +} +size_t wifi_csi_info__get_packed_size + (const WifiCsiInfo *message) +{ + assert(message->base.descriptor == &wifi_csi_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_csi_info__pack + (const WifiCsiInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_csi_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_csi_info__pack_to_buffer + (const WifiCsiInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_csi_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiCsiInfo * + wifi_csi_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiCsiInfo *) + protobuf_c_message_unpack (&wifi_csi_info__descriptor, + allocator, len, data); +} +void wifi_csi_info__free_unpacked + (WifiCsiInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_csi_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ant_gpio__init + (WifiAntGpio *message) +{ + static const WifiAntGpio init_value = WIFI_ANT_GPIO__INIT; + *message = init_value; +} +size_t wifi_ant_gpio__get_packed_size + (const WifiAntGpio *message) +{ + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ant_gpio__pack + (const WifiAntGpio *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ant_gpio__pack_to_buffer + (const WifiAntGpio *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiAntGpio * + wifi_ant_gpio__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiAntGpio *) + protobuf_c_message_unpack (&wifi_ant_gpio__descriptor, + allocator, len, data); +} +void wifi_ant_gpio__free_unpacked + (WifiAntGpio *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ant_gpio__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ant_gpio_config__init + (WifiAntGpioConfig *message) +{ + static const WifiAntGpioConfig init_value = WIFI_ANT_GPIO_CONFIG__INIT; + *message = init_value; +} +size_t wifi_ant_gpio_config__get_packed_size + (const WifiAntGpioConfig *message) +{ + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ant_gpio_config__pack + (const WifiAntGpioConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ant_gpio_config__pack_to_buffer + (const WifiAntGpioConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiAntGpioConfig * + wifi_ant_gpio_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiAntGpioConfig *) + protobuf_c_message_unpack (&wifi_ant_gpio_config__descriptor, + allocator, len, data); +} +void wifi_ant_gpio_config__free_unpacked + (WifiAntGpioConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ant_gpio_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ant_config__init + (WifiAntConfig *message) +{ + static const WifiAntConfig init_value = WIFI_ANT_CONFIG__INIT; + *message = init_value; +} +size_t wifi_ant_config__get_packed_size + (const WifiAntConfig *message) +{ + assert(message->base.descriptor == &wifi_ant_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ant_config__pack + (const WifiAntConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ant_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ant_config__pack_to_buffer + (const WifiAntConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ant_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiAntConfig * + wifi_ant_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiAntConfig *) + protobuf_c_message_unpack (&wifi_ant_config__descriptor, + allocator, len, data); +} +void wifi_ant_config__free_unpacked + (WifiAntConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ant_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_action_tx_req__init + (WifiActionTxReq *message) +{ + static const WifiActionTxReq init_value = WIFI_ACTION_TX_REQ__INIT; + *message = init_value; +} +size_t wifi_action_tx_req__get_packed_size + (const WifiActionTxReq *message) +{ + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_action_tx_req__pack + (const WifiActionTxReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_action_tx_req__pack_to_buffer + (const WifiActionTxReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiActionTxReq * + wifi_action_tx_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiActionTxReq *) + protobuf_c_message_unpack (&wifi_action_tx_req__descriptor, + allocator, len, data); +} +void wifi_action_tx_req__free_unpacked + (WifiActionTxReq *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_action_tx_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ftm_initiator_cfg__init + (WifiFtmInitiatorCfg *message) +{ + static const WifiFtmInitiatorCfg init_value = WIFI_FTM_INITIATOR_CFG__INIT; + *message = init_value; +} +size_t wifi_ftm_initiator_cfg__get_packed_size + (const WifiFtmInitiatorCfg *message) +{ + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ftm_initiator_cfg__pack + (const WifiFtmInitiatorCfg *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ftm_initiator_cfg__pack_to_buffer + (const WifiFtmInitiatorCfg *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiFtmInitiatorCfg * + wifi_ftm_initiator_cfg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiFtmInitiatorCfg *) + protobuf_c_message_unpack (&wifi_ftm_initiator_cfg__descriptor, + allocator, len, data); +} +void wifi_ftm_initiator_cfg__free_unpacked + (WifiFtmInitiatorCfg *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ftm_initiator_cfg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_scan_done__init + (WifiEventStaScanDone *message) +{ + static const WifiEventStaScanDone init_value = WIFI_EVENT_STA_SCAN_DONE__INIT; + *message = init_value; +} +size_t wifi_event_sta_scan_done__get_packed_size + (const WifiEventStaScanDone *message) +{ + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_scan_done__pack + (const WifiEventStaScanDone *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_scan_done__pack_to_buffer + (const WifiEventStaScanDone *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaScanDone * + wifi_event_sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaScanDone *) + protobuf_c_message_unpack (&wifi_event_sta_scan_done__descriptor, + allocator, len, data); +} +void wifi_event_sta_scan_done__free_unpacked + (WifiEventStaScanDone *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_scan_done__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_connected__init + (WifiEventStaConnected *message) +{ + static const WifiEventStaConnected init_value = WIFI_EVENT_STA_CONNECTED__INIT; + *message = init_value; +} +size_t wifi_event_sta_connected__get_packed_size + (const WifiEventStaConnected *message) +{ + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_connected__pack + (const WifiEventStaConnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_connected__pack_to_buffer + (const WifiEventStaConnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaConnected * + wifi_event_sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaConnected *) + protobuf_c_message_unpack (&wifi_event_sta_connected__descriptor, + allocator, len, data); +} +void wifi_event_sta_connected__free_unpacked + (WifiEventStaConnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_connected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_disconnected__init + (WifiEventStaDisconnected *message) +{ + static const WifiEventStaDisconnected init_value = WIFI_EVENT_STA_DISCONNECTED__INIT; + *message = init_value; +} +size_t wifi_event_sta_disconnected__get_packed_size + (const WifiEventStaDisconnected *message) +{ + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_disconnected__pack + (const WifiEventStaDisconnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_disconnected__pack_to_buffer + (const WifiEventStaDisconnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaDisconnected * + wifi_event_sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaDisconnected *) + protobuf_c_message_unpack (&wifi_event_sta_disconnected__descriptor, + allocator, len, data); +} +void wifi_event_sta_disconnected__free_unpacked + (WifiEventStaDisconnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_disconnected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_authmode_change__init + (WifiEventStaAuthmodeChange *message) +{ + static const WifiEventStaAuthmodeChange init_value = WIFI_EVENT_STA_AUTHMODE_CHANGE__INIT; + *message = init_value; +} +size_t wifi_event_sta_authmode_change__get_packed_size + (const WifiEventStaAuthmodeChange *message) +{ + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_authmode_change__pack + (const WifiEventStaAuthmodeChange *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_authmode_change__pack_to_buffer + (const WifiEventStaAuthmodeChange *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaAuthmodeChange * + wifi_event_sta_authmode_change__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaAuthmodeChange *) + protobuf_c_message_unpack (&wifi_event_sta_authmode_change__descriptor, + allocator, len, data); +} +void wifi_event_sta_authmode_change__free_unpacked + (WifiEventStaAuthmodeChange *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_authmode_change__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_wps_er_pin__init + (WifiEventStaWpsErPin *message) +{ + static const WifiEventStaWpsErPin init_value = WIFI_EVENT_STA_WPS_ER_PIN__INIT; + *message = init_value; +} +size_t wifi_event_sta_wps_er_pin__get_packed_size + (const WifiEventStaWpsErPin *message) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_wps_er_pin__pack + (const WifiEventStaWpsErPin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_wps_er_pin__pack_to_buffer + (const WifiEventStaWpsErPin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaWpsErPin * + wifi_event_sta_wps_er_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaWpsErPin *) + protobuf_c_message_unpack (&wifi_event_sta_wps_er_pin__descriptor, + allocator, len, data); +} +void wifi_event_sta_wps_er_pin__free_unpacked + (WifiEventStaWpsErPin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_wps_er_pin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void ap_cred__init + (ApCred *message) +{ + static const ApCred init_value = AP_CRED__INIT; + *message = init_value; +} +size_t ap_cred__get_packed_size + (const ApCred *message) +{ + assert(message->base.descriptor == &ap_cred__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ap_cred__pack + (const ApCred *message, + uint8_t *out) +{ + assert(message->base.descriptor == &ap_cred__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ap_cred__pack_to_buffer + (const ApCred *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &ap_cred__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ApCred * + ap_cred__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ApCred *) + protobuf_c_message_unpack (&ap_cred__descriptor, + allocator, len, data); +} +void ap_cred__free_unpacked + (ApCred *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &ap_cred__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_sta_wps_er_success__init + (WifiEventStaWpsErSuccess *message) +{ + static const WifiEventStaWpsErSuccess init_value = WIFI_EVENT_STA_WPS_ER_SUCCESS__INIT; + *message = init_value; +} +size_t wifi_event_sta_wps_er_success__get_packed_size + (const WifiEventStaWpsErSuccess *message) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_sta_wps_er_success__pack + (const WifiEventStaWpsErSuccess *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_sta_wps_er_success__pack_to_buffer + (const WifiEventStaWpsErSuccess *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventStaWpsErSuccess * + wifi_event_sta_wps_er_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventStaWpsErSuccess *) + protobuf_c_message_unpack (&wifi_event_sta_wps_er_success__descriptor, + allocator, len, data); +} +void wifi_event_sta_wps_er_success__free_unpacked + (WifiEventStaWpsErSuccess *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_sta_wps_er_success__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_probe_req_rx__init + (WifiEventApProbeReqRx *message) +{ + static const WifiEventApProbeReqRx init_value = WIFI_EVENT_AP_PROBE_REQ_RX__INIT; + *message = init_value; +} +size_t wifi_event_ap_probe_req_rx__get_packed_size + (const WifiEventApProbeReqRx *message) +{ + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_probe_req_rx__pack + (const WifiEventApProbeReqRx *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_probe_req_rx__pack_to_buffer + (const WifiEventApProbeReqRx *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApProbeReqRx * + wifi_event_ap_probe_req_rx__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApProbeReqRx *) + protobuf_c_message_unpack (&wifi_event_ap_probe_req_rx__descriptor, + allocator, len, data); +} +void wifi_event_ap_probe_req_rx__free_unpacked + (WifiEventApProbeReqRx *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_probe_req_rx__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_bss_rssi_low__init + (WifiEventBssRssiLow *message) +{ + static const WifiEventBssRssiLow init_value = WIFI_EVENT_BSS_RSSI_LOW__INIT; + *message = init_value; +} +size_t wifi_event_bss_rssi_low__get_packed_size + (const WifiEventBssRssiLow *message) +{ + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_bss_rssi_low__pack + (const WifiEventBssRssiLow *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_bss_rssi_low__pack_to_buffer + (const WifiEventBssRssiLow *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventBssRssiLow * + wifi_event_bss_rssi_low__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventBssRssiLow *) + protobuf_c_message_unpack (&wifi_event_bss_rssi_low__descriptor, + allocator, len, data); +} +void wifi_event_bss_rssi_low__free_unpacked + (WifiEventBssRssiLow *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_bss_rssi_low__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_ftm_report_entry__init + (WifiFtmReportEntry *message) +{ + static const WifiFtmReportEntry init_value = WIFI_FTM_REPORT_ENTRY__INIT; + *message = init_value; +} +size_t wifi_ftm_report_entry__get_packed_size + (const WifiFtmReportEntry *message) +{ + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_ftm_report_entry__pack + (const WifiFtmReportEntry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_ftm_report_entry__pack_to_buffer + (const WifiFtmReportEntry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiFtmReportEntry * + wifi_ftm_report_entry__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiFtmReportEntry *) + protobuf_c_message_unpack (&wifi_ftm_report_entry__descriptor, + allocator, len, data); +} +void wifi_ftm_report_entry__free_unpacked + (WifiFtmReportEntry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_ftm_report_entry__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ftm_report__init + (WifiEventFtmReport *message) +{ + static const WifiEventFtmReport init_value = WIFI_EVENT_FTM_REPORT__INIT; + *message = init_value; +} +size_t wifi_event_ftm_report__get_packed_size + (const WifiEventFtmReport *message) +{ + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ftm_report__pack + (const WifiEventFtmReport *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ftm_report__pack_to_buffer + (const WifiEventFtmReport *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventFtmReport * + wifi_event_ftm_report__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventFtmReport *) + protobuf_c_message_unpack (&wifi_event_ftm_report__descriptor, + allocator, len, data); +} +void wifi_event_ftm_report__free_unpacked + (WifiEventFtmReport *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ftm_report__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_action_tx_status__init + (WifiEventActionTxStatus *message) +{ + static const WifiEventActionTxStatus init_value = WIFI_EVENT_ACTION_TX_STATUS__INIT; + *message = init_value; +} +size_t wifi_event_action_tx_status__get_packed_size + (const WifiEventActionTxStatus *message) +{ + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_action_tx_status__pack + (const WifiEventActionTxStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_action_tx_status__pack_to_buffer + (const WifiEventActionTxStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventActionTxStatus * + wifi_event_action_tx_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventActionTxStatus *) + protobuf_c_message_unpack (&wifi_event_action_tx_status__descriptor, + allocator, len, data); +} +void wifi_event_action_tx_status__free_unpacked + (WifiEventActionTxStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_action_tx_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_roc_done__init + (WifiEventRocDone *message) +{ + static const WifiEventRocDone init_value = WIFI_EVENT_ROC_DONE__INIT; + *message = init_value; +} +size_t wifi_event_roc_done__get_packed_size + (const WifiEventRocDone *message) +{ + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_roc_done__pack + (const WifiEventRocDone *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_roc_done__pack_to_buffer + (const WifiEventRocDone *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventRocDone * + wifi_event_roc_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventRocDone *) + protobuf_c_message_unpack (&wifi_event_roc_done__descriptor, + allocator, len, data); +} +void wifi_event_roc_done__free_unpacked + (WifiEventRocDone *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_roc_done__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_wps_rg_pin__init + (WifiEventApWpsRgPin *message) +{ + static const WifiEventApWpsRgPin init_value = WIFI_EVENT_AP_WPS_RG_PIN__INIT; + *message = init_value; +} +size_t wifi_event_ap_wps_rg_pin__get_packed_size + (const WifiEventApWpsRgPin *message) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_wps_rg_pin__pack + (const WifiEventApWpsRgPin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_wps_rg_pin__pack_to_buffer + (const WifiEventApWpsRgPin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApWpsRgPin * + wifi_event_ap_wps_rg_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApWpsRgPin *) + protobuf_c_message_unpack (&wifi_event_ap_wps_rg_pin__descriptor, + allocator, len, data); +} +void wifi_event_ap_wps_rg_pin__free_unpacked + (WifiEventApWpsRgPin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_wps_rg_pin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_wps_rg_fail_reason__init + (WifiEventApWpsRgFailReason *message) +{ + static const WifiEventApWpsRgFailReason init_value = WIFI_EVENT_AP_WPS_RG_FAIL_REASON__INIT; + *message = init_value; +} +size_t wifi_event_ap_wps_rg_fail_reason__get_packed_size + (const WifiEventApWpsRgFailReason *message) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_wps_rg_fail_reason__pack + (const WifiEventApWpsRgFailReason *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_wps_rg_fail_reason__pack_to_buffer + (const WifiEventApWpsRgFailReason *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApWpsRgFailReason * + wifi_event_ap_wps_rg_fail_reason__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApWpsRgFailReason *) + protobuf_c_message_unpack (&wifi_event_ap_wps_rg_fail_reason__descriptor, + allocator, len, data); +} +void wifi_event_ap_wps_rg_fail_reason__free_unpacked + (WifiEventApWpsRgFailReason *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_wps_rg_fail_reason__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_event_ap_wps_rg_success__init + (WifiEventApWpsRgSuccess *message) +{ + static const WifiEventApWpsRgSuccess init_value = WIFI_EVENT_AP_WPS_RG_SUCCESS__INIT; + *message = init_value; +} +size_t wifi_event_ap_wps_rg_success__get_packed_size + (const WifiEventApWpsRgSuccess *message) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_event_ap_wps_rg_success__pack + (const WifiEventApWpsRgSuccess *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_event_ap_wps_rg_success__pack_to_buffer + (const WifiEventApWpsRgSuccess *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiEventApWpsRgSuccess * + wifi_event_ap_wps_rg_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiEventApWpsRgSuccess *) + protobuf_c_message_unpack (&wifi_event_ap_wps_rg_success__descriptor, + allocator, len, data); +} +void wifi_event_ap_wps_rg_success__free_unpacked + (WifiEventApWpsRgSuccess *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_event_ap_wps_rg_success__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_protocols__init + (WifiProtocols *message) +{ + static const WifiProtocols init_value = WIFI_PROTOCOLS__INIT; + *message = init_value; +} +size_t wifi_protocols__get_packed_size + (const WifiProtocols *message) +{ + assert(message->base.descriptor == &wifi_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_protocols__pack + (const WifiProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_protocols__pack_to_buffer + (const WifiProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiProtocols * + wifi_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiProtocols *) + protobuf_c_message_unpack (&wifi_protocols__descriptor, + allocator, len, data); +} +void wifi_protocols__free_unpacked + (WifiProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_bandwidths__init + (WifiBandwidths *message) +{ + static const WifiBandwidths init_value = WIFI_BANDWIDTHS__INIT; + *message = init_value; +} +size_t wifi_bandwidths__get_packed_size + (const WifiBandwidths *message) +{ + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_bandwidths__pack + (const WifiBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_bandwidths__pack_to_buffer + (const WifiBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiBandwidths * + wifi_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiBandwidths *) + protobuf_c_message_unpack (&wifi_bandwidths__descriptor, + allocator, len, data); +} +void wifi_bandwidths__free_unpacked + (WifiBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_itwt_setup_config__init + (WifiItwtSetupConfig *message) +{ + static const WifiItwtSetupConfig init_value = WIFI_ITWT_SETUP_CONFIG__INIT; + *message = init_value; +} +size_t wifi_itwt_setup_config__get_packed_size + (const WifiItwtSetupConfig *message) +{ + assert(message->base.descriptor == &wifi_itwt_setup_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_itwt_setup_config__pack + (const WifiItwtSetupConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_itwt_setup_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_itwt_setup_config__pack_to_buffer + (const WifiItwtSetupConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_itwt_setup_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiItwtSetupConfig * + wifi_itwt_setup_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiItwtSetupConfig *) + protobuf_c_message_unpack (&wifi_itwt_setup_config__descriptor, + allocator, len, data); +} +void wifi_itwt_setup_config__free_unpacked + (WifiItwtSetupConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_itwt_setup_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void wifi_twt_config__init + (WifiTwtConfig *message) +{ + static const WifiTwtConfig init_value = WIFI_TWT_CONFIG__INIT; + *message = init_value; +} +size_t wifi_twt_config__get_packed_size + (const WifiTwtConfig *message) +{ + assert(message->base.descriptor == &wifi_twt_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t wifi_twt_config__pack + (const WifiTwtConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &wifi_twt_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t wifi_twt_config__pack_to_buffer + (const WifiTwtConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &wifi_twt_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +WifiTwtConfig * + wifi_twt_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (WifiTwtConfig *) + protobuf_c_message_unpack (&wifi_twt_config__descriptor, + allocator, len, data); +} +void wifi_twt_config__free_unpacked + (WifiTwtConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &wifi_twt_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void connected_stalist__init + (ConnectedSTAList *message) +{ + static const ConnectedSTAList init_value = CONNECTED_STALIST__INIT; + *message = init_value; +} +size_t connected_stalist__get_packed_size + (const ConnectedSTAList *message) +{ + assert(message->base.descriptor == &connected_stalist__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t connected_stalist__pack + (const ConnectedSTAList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &connected_stalist__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t connected_stalist__pack_to_buffer + (const ConnectedSTAList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &connected_stalist__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ConnectedSTAList * + connected_stalist__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ConnectedSTAList *) + protobuf_c_message_unpack (&connected_stalist__descriptor, + allocator, len, data); +} +void connected_stalist__free_unpacked + (ConnectedSTAList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &connected_stalist__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eap_fast_config__init + (EapFastConfig *message) +{ + static const EapFastConfig init_value = EAP_FAST_CONFIG__INIT; + *message = init_value; +} +size_t eap_fast_config__get_packed_size + (const EapFastConfig *message) +{ + assert(message->base.descriptor == &eap_fast_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eap_fast_config__pack + (const EapFastConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &eap_fast_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eap_fast_config__pack_to_buffer + (const EapFastConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &eap_fast_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +EapFastConfig * + eap_fast_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (EapFastConfig *) + protobuf_c_message_unpack (&eap_fast_config__descriptor, + allocator, len, data); +} +void eap_fast_config__free_unpacked + (EapFastConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &eap_fast_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_mac_address__init + (RpcReqGetMacAddress *message) +{ + static const RpcReqGetMacAddress init_value = RPC__REQ__GET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__req__get_mac_address__get_packed_size + (const RpcReqGetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_mac_address__pack + (const RpcReqGetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_mac_address__pack_to_buffer + (const RpcReqGetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetMacAddress * + rpc__req__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetMacAddress *) + protobuf_c_message_unpack (&rpc__req__get_mac_address__descriptor, + allocator, len, data); +} +void rpc__req__get_mac_address__free_unpacked + (RpcReqGetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_mac_address__init + (RpcRespGetMacAddress *message) +{ + static const RpcRespGetMacAddress init_value = RPC__RESP__GET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__resp__get_mac_address__get_packed_size + (const RpcRespGetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_mac_address__pack + (const RpcRespGetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_mac_address__pack_to_buffer + (const RpcRespGetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetMacAddress * + rpc__resp__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetMacAddress *) + protobuf_c_message_unpack (&rpc__resp__get_mac_address__descriptor, + allocator, len, data); +} +void rpc__resp__get_mac_address__free_unpacked + (RpcRespGetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_mode__init + (RpcReqGetMode *message) +{ + static const RpcReqGetMode init_value = RPC__REQ__GET_MODE__INIT; + *message = init_value; +} +size_t rpc__req__get_mode__get_packed_size + (const RpcReqGetMode *message) +{ + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_mode__pack + (const RpcReqGetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_mode__pack_to_buffer + (const RpcReqGetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetMode * + rpc__req__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetMode *) + protobuf_c_message_unpack (&rpc__req__get_mode__descriptor, + allocator, len, data); +} +void rpc__req__get_mode__free_unpacked + (RpcReqGetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_mode__init + (RpcRespGetMode *message) +{ + static const RpcRespGetMode init_value = RPC__RESP__GET_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__get_mode__get_packed_size + (const RpcRespGetMode *message) +{ + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_mode__pack + (const RpcRespGetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_mode__pack_to_buffer + (const RpcRespGetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetMode * + rpc__resp__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetMode *) + protobuf_c_message_unpack (&rpc__resp__get_mode__descriptor, + allocator, len, data); +} +void rpc__resp__get_mode__free_unpacked + (RpcRespGetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_mode__init + (RpcReqSetMode *message) +{ + static const RpcReqSetMode init_value = RPC__REQ__SET_MODE__INIT; + *message = init_value; +} +size_t rpc__req__set_mode__get_packed_size + (const RpcReqSetMode *message) +{ + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_mode__pack + (const RpcReqSetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_mode__pack_to_buffer + (const RpcReqSetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetMode * + rpc__req__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetMode *) + protobuf_c_message_unpack (&rpc__req__set_mode__descriptor, + allocator, len, data); +} +void rpc__req__set_mode__free_unpacked + (RpcReqSetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_mode__init + (RpcRespSetMode *message) +{ + static const RpcRespSetMode init_value = RPC__RESP__SET_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__set_mode__get_packed_size + (const RpcRespSetMode *message) +{ + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_mode__pack + (const RpcRespSetMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_mode__pack_to_buffer + (const RpcRespSetMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetMode * + rpc__resp__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetMode *) + protobuf_c_message_unpack (&rpc__resp__set_mode__descriptor, + allocator, len, data); +} +void rpc__resp__set_mode__free_unpacked + (RpcRespSetMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_ps__init + (RpcReqGetPs *message) +{ + static const RpcReqGetPs init_value = RPC__REQ__GET_PS__INIT; + *message = init_value; +} +size_t rpc__req__get_ps__get_packed_size + (const RpcReqGetPs *message) +{ + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_ps__pack + (const RpcReqGetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_ps__pack_to_buffer + (const RpcReqGetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetPs * + rpc__req__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetPs *) + protobuf_c_message_unpack (&rpc__req__get_ps__descriptor, + allocator, len, data); +} +void rpc__req__get_ps__free_unpacked + (RpcReqGetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_ps__init + (RpcRespGetPs *message) +{ + static const RpcRespGetPs init_value = RPC__RESP__GET_PS__INIT; + *message = init_value; +} +size_t rpc__resp__get_ps__get_packed_size + (const RpcRespGetPs *message) +{ + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_ps__pack + (const RpcRespGetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_ps__pack_to_buffer + (const RpcRespGetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetPs * + rpc__resp__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetPs *) + protobuf_c_message_unpack (&rpc__resp__get_ps__descriptor, + allocator, len, data); +} +void rpc__resp__get_ps__free_unpacked + (RpcRespGetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_ps__init + (RpcReqSetPs *message) +{ + static const RpcReqSetPs init_value = RPC__REQ__SET_PS__INIT; + *message = init_value; +} +size_t rpc__req__set_ps__get_packed_size + (const RpcReqSetPs *message) +{ + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_ps__pack + (const RpcReqSetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_ps__pack_to_buffer + (const RpcReqSetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetPs * + rpc__req__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetPs *) + protobuf_c_message_unpack (&rpc__req__set_ps__descriptor, + allocator, len, data); +} +void rpc__req__set_ps__free_unpacked + (RpcReqSetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_ps__init + (RpcRespSetPs *message) +{ + static const RpcRespSetPs init_value = RPC__RESP__SET_PS__INIT; + *message = init_value; +} +size_t rpc__resp__set_ps__get_packed_size + (const RpcRespSetPs *message) +{ + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_ps__pack + (const RpcRespSetPs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_ps__pack_to_buffer + (const RpcRespSetPs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetPs * + rpc__resp__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetPs *) + protobuf_c_message_unpack (&rpc__resp__set_ps__descriptor, + allocator, len, data); +} +void rpc__resp__set_ps__free_unpacked + (RpcRespSetPs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_ps__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_mac_address__init + (RpcReqSetMacAddress *message) +{ + static const RpcReqSetMacAddress init_value = RPC__REQ__SET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__req__set_mac_address__get_packed_size + (const RpcReqSetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_mac_address__pack + (const RpcReqSetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_mac_address__pack_to_buffer + (const RpcReqSetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetMacAddress * + rpc__req__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetMacAddress *) + protobuf_c_message_unpack (&rpc__req__set_mac_address__descriptor, + allocator, len, data); +} +void rpc__req__set_mac_address__free_unpacked + (RpcReqSetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_mac_address__init + (RpcRespSetMacAddress *message) +{ + static const RpcRespSetMacAddress init_value = RPC__RESP__SET_MAC_ADDRESS__INIT; + *message = init_value; +} +size_t rpc__resp__set_mac_address__get_packed_size + (const RpcRespSetMacAddress *message) +{ + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_mac_address__pack + (const RpcRespSetMacAddress *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_mac_address__pack_to_buffer + (const RpcRespSetMacAddress *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetMacAddress * + rpc__resp__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetMacAddress *) + protobuf_c_message_unpack (&rpc__resp__set_mac_address__descriptor, + allocator, len, data); +} +void rpc__resp__set_mac_address__free_unpacked + (RpcRespSetMacAddress *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_mac_address__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__otabegin__init + (RpcReqOTABegin *message) +{ + static const RpcReqOTABegin init_value = RPC__REQ__OTABEGIN__INIT; + *message = init_value; +} +size_t rpc__req__otabegin__get_packed_size + (const RpcReqOTABegin *message) +{ + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__otabegin__pack + (const RpcReqOTABegin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__otabegin__pack_to_buffer + (const RpcReqOTABegin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqOTABegin * + rpc__req__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqOTABegin *) + protobuf_c_message_unpack (&rpc__req__otabegin__descriptor, + allocator, len, data); +} +void rpc__req__otabegin__free_unpacked + (RpcReqOTABegin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__otabegin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__otabegin__init + (RpcRespOTABegin *message) +{ + static const RpcRespOTABegin init_value = RPC__RESP__OTABEGIN__INIT; + *message = init_value; +} +size_t rpc__resp__otabegin__get_packed_size + (const RpcRespOTABegin *message) +{ + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__otabegin__pack + (const RpcRespOTABegin *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__otabegin__pack_to_buffer + (const RpcRespOTABegin *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespOTABegin * + rpc__resp__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespOTABegin *) + protobuf_c_message_unpack (&rpc__resp__otabegin__descriptor, + allocator, len, data); +} +void rpc__resp__otabegin__free_unpacked + (RpcRespOTABegin *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__otabegin__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__otawrite__init + (RpcReqOTAWrite *message) +{ + static const RpcReqOTAWrite init_value = RPC__REQ__OTAWRITE__INIT; + *message = init_value; +} +size_t rpc__req__otawrite__get_packed_size + (const RpcReqOTAWrite *message) +{ + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__otawrite__pack + (const RpcReqOTAWrite *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__otawrite__pack_to_buffer + (const RpcReqOTAWrite *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqOTAWrite * + rpc__req__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqOTAWrite *) + protobuf_c_message_unpack (&rpc__req__otawrite__descriptor, + allocator, len, data); +} +void rpc__req__otawrite__free_unpacked + (RpcReqOTAWrite *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__otawrite__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__otawrite__init + (RpcRespOTAWrite *message) +{ + static const RpcRespOTAWrite init_value = RPC__RESP__OTAWRITE__INIT; + *message = init_value; +} +size_t rpc__resp__otawrite__get_packed_size + (const RpcRespOTAWrite *message) +{ + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__otawrite__pack + (const RpcRespOTAWrite *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__otawrite__pack_to_buffer + (const RpcRespOTAWrite *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespOTAWrite * + rpc__resp__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespOTAWrite *) + protobuf_c_message_unpack (&rpc__resp__otawrite__descriptor, + allocator, len, data); +} +void rpc__resp__otawrite__free_unpacked + (RpcRespOTAWrite *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__otawrite__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__otaend__init + (RpcReqOTAEnd *message) +{ + static const RpcReqOTAEnd init_value = RPC__REQ__OTAEND__INIT; + *message = init_value; +} +size_t rpc__req__otaend__get_packed_size + (const RpcReqOTAEnd *message) +{ + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__otaend__pack + (const RpcReqOTAEnd *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__otaend__pack_to_buffer + (const RpcReqOTAEnd *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqOTAEnd * + rpc__req__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqOTAEnd *) + protobuf_c_message_unpack (&rpc__req__otaend__descriptor, + allocator, len, data); +} +void rpc__req__otaend__free_unpacked + (RpcReqOTAEnd *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__otaend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__otaend__init + (RpcRespOTAEnd *message) +{ + static const RpcRespOTAEnd init_value = RPC__RESP__OTAEND__INIT; + *message = init_value; +} +size_t rpc__resp__otaend__get_packed_size + (const RpcRespOTAEnd *message) +{ + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__otaend__pack + (const RpcRespOTAEnd *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__otaend__pack_to_buffer + (const RpcRespOTAEnd *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespOTAEnd * + rpc__resp__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespOTAEnd *) + protobuf_c_message_unpack (&rpc__resp__otaend__descriptor, + allocator, len, data); +} +void rpc__resp__otaend__free_unpacked + (RpcRespOTAEnd *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__otaend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_max_tx_power__init + (RpcReqWifiSetMaxTxPower *message) +{ + static const RpcReqWifiSetMaxTxPower init_value = RPC__REQ__WIFI_SET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_max_tx_power__get_packed_size + (const RpcReqWifiSetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_max_tx_power__pack + (const RpcReqWifiSetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_max_tx_power__pack_to_buffer + (const RpcReqWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetMaxTxPower * + rpc__req__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetMaxTxPower *) + protobuf_c_message_unpack (&rpc__req__wifi_set_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_max_tx_power__free_unpacked + (RpcReqWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_max_tx_power__init + (RpcRespWifiSetMaxTxPower *message) +{ + static const RpcRespWifiSetMaxTxPower init_value = RPC__RESP__WIFI_SET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_max_tx_power__get_packed_size + (const RpcRespWifiSetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_max_tx_power__pack + (const RpcRespWifiSetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_max_tx_power__pack_to_buffer + (const RpcRespWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetMaxTxPower * + rpc__resp__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetMaxTxPower *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_max_tx_power__free_unpacked + (RpcRespWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_max_tx_power__init + (RpcReqWifiGetMaxTxPower *message) +{ + static const RpcReqWifiGetMaxTxPower init_value = RPC__REQ__WIFI_GET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_max_tx_power__get_packed_size + (const RpcReqWifiGetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_max_tx_power__pack + (const RpcReqWifiGetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_max_tx_power__pack_to_buffer + (const RpcReqWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetMaxTxPower * + rpc__req__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetMaxTxPower *) + protobuf_c_message_unpack (&rpc__req__wifi_get_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_max_tx_power__free_unpacked + (RpcReqWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_max_tx_power__init + (RpcRespWifiGetMaxTxPower *message) +{ + static const RpcRespWifiGetMaxTxPower init_value = RPC__RESP__WIFI_GET_MAX_TX_POWER__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_max_tx_power__get_packed_size + (const RpcRespWifiGetMaxTxPower *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_max_tx_power__pack + (const RpcRespWifiGetMaxTxPower *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_max_tx_power__pack_to_buffer + (const RpcRespWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetMaxTxPower * + rpc__resp__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetMaxTxPower *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_max_tx_power__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_max_tx_power__free_unpacked + (RpcRespWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_max_tx_power__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__config_heartbeat__init + (RpcReqConfigHeartbeat *message) +{ + static const RpcReqConfigHeartbeat init_value = RPC__REQ__CONFIG_HEARTBEAT__INIT; + *message = init_value; +} +size_t rpc__req__config_heartbeat__get_packed_size + (const RpcReqConfigHeartbeat *message) +{ + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__config_heartbeat__pack + (const RpcReqConfigHeartbeat *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__config_heartbeat__pack_to_buffer + (const RpcReqConfigHeartbeat *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqConfigHeartbeat * + rpc__req__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqConfigHeartbeat *) + protobuf_c_message_unpack (&rpc__req__config_heartbeat__descriptor, + allocator, len, data); +} +void rpc__req__config_heartbeat__free_unpacked + (RpcReqConfigHeartbeat *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__config_heartbeat__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__config_heartbeat__init + (RpcRespConfigHeartbeat *message) +{ + static const RpcRespConfigHeartbeat init_value = RPC__RESP__CONFIG_HEARTBEAT__INIT; + *message = init_value; +} +size_t rpc__resp__config_heartbeat__get_packed_size + (const RpcRespConfigHeartbeat *message) +{ + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__config_heartbeat__pack + (const RpcRespConfigHeartbeat *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__config_heartbeat__pack_to_buffer + (const RpcRespConfigHeartbeat *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespConfigHeartbeat * + rpc__resp__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespConfigHeartbeat *) + protobuf_c_message_unpack (&rpc__resp__config_heartbeat__descriptor, + allocator, len, data); +} +void rpc__resp__config_heartbeat__free_unpacked + (RpcRespConfigHeartbeat *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__config_heartbeat__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_init__init + (RpcReqWifiInit *message) +{ + static const RpcReqWifiInit init_value = RPC__REQ__WIFI_INIT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_init__get_packed_size + (const RpcReqWifiInit *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_init__pack + (const RpcReqWifiInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_init__pack_to_buffer + (const RpcReqWifiInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiInit * + rpc__req__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiInit *) + protobuf_c_message_unpack (&rpc__req__wifi_init__descriptor, + allocator, len, data); +} +void rpc__req__wifi_init__free_unpacked + (RpcReqWifiInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_init__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_init__init + (RpcRespWifiInit *message) +{ + static const RpcRespWifiInit init_value = RPC__RESP__WIFI_INIT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_init__get_packed_size + (const RpcRespWifiInit *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_init__pack + (const RpcRespWifiInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_init__pack_to_buffer + (const RpcRespWifiInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiInit * + rpc__resp__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiInit *) + protobuf_c_message_unpack (&rpc__resp__wifi_init__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_init__free_unpacked + (RpcRespWifiInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_init__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_deinit__init + (RpcReqWifiDeinit *message) +{ + static const RpcReqWifiDeinit init_value = RPC__REQ__WIFI_DEINIT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_deinit__get_packed_size + (const RpcReqWifiDeinit *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_deinit__pack + (const RpcReqWifiDeinit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_deinit__pack_to_buffer + (const RpcReqWifiDeinit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiDeinit * + rpc__req__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiDeinit *) + protobuf_c_message_unpack (&rpc__req__wifi_deinit__descriptor, + allocator, len, data); +} +void rpc__req__wifi_deinit__free_unpacked + (RpcReqWifiDeinit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_deinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_deinit__init + (RpcRespWifiDeinit *message) +{ + static const RpcRespWifiDeinit init_value = RPC__RESP__WIFI_DEINIT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_deinit__get_packed_size + (const RpcRespWifiDeinit *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_deinit__pack + (const RpcRespWifiDeinit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_deinit__pack_to_buffer + (const RpcRespWifiDeinit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiDeinit * + rpc__resp__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiDeinit *) + protobuf_c_message_unpack (&rpc__resp__wifi_deinit__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_deinit__free_unpacked + (RpcRespWifiDeinit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_deinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_config__init + (RpcReqWifiSetConfig *message) +{ + static const RpcReqWifiSetConfig init_value = RPC__REQ__WIFI_SET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_config__get_packed_size + (const RpcReqWifiSetConfig *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_config__pack + (const RpcReqWifiSetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_config__pack_to_buffer + (const RpcReqWifiSetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetConfig * + rpc__req__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetConfig *) + protobuf_c_message_unpack (&rpc__req__wifi_set_config__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_config__free_unpacked + (RpcReqWifiSetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_config__init + (RpcRespWifiSetConfig *message) +{ + static const RpcRespWifiSetConfig init_value = RPC__RESP__WIFI_SET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_config__get_packed_size + (const RpcRespWifiSetConfig *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_config__pack + (const RpcRespWifiSetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_config__pack_to_buffer + (const RpcRespWifiSetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetConfig * + rpc__resp__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetConfig *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_config__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_config__free_unpacked + (RpcRespWifiSetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_config__init + (RpcReqWifiGetConfig *message) +{ + static const RpcReqWifiGetConfig init_value = RPC__REQ__WIFI_GET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_config__get_packed_size + (const RpcReqWifiGetConfig *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_config__pack + (const RpcReqWifiGetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_config__pack_to_buffer + (const RpcReqWifiGetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetConfig * + rpc__req__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetConfig *) + protobuf_c_message_unpack (&rpc__req__wifi_get_config__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_config__free_unpacked + (RpcReqWifiGetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_config__init + (RpcRespWifiGetConfig *message) +{ + static const RpcRespWifiGetConfig init_value = RPC__RESP__WIFI_GET_CONFIG__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_config__get_packed_size + (const RpcRespWifiGetConfig *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_config__pack + (const RpcRespWifiGetConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_config__pack_to_buffer + (const RpcRespWifiGetConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetConfig * + rpc__resp__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetConfig *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_config__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_config__free_unpacked + (RpcRespWifiGetConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_connect__init + (RpcReqWifiConnect *message) +{ + static const RpcReqWifiConnect init_value = RPC__REQ__WIFI_CONNECT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_connect__get_packed_size + (const RpcReqWifiConnect *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_connect__pack + (const RpcReqWifiConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_connect__pack_to_buffer + (const RpcReqWifiConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiConnect * + rpc__req__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiConnect *) + protobuf_c_message_unpack (&rpc__req__wifi_connect__descriptor, + allocator, len, data); +} +void rpc__req__wifi_connect__free_unpacked + (RpcReqWifiConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_connect__init + (RpcRespWifiConnect *message) +{ + static const RpcRespWifiConnect init_value = RPC__RESP__WIFI_CONNECT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_connect__get_packed_size + (const RpcRespWifiConnect *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_connect__pack + (const RpcRespWifiConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_connect__pack_to_buffer + (const RpcRespWifiConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiConnect * + rpc__resp__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiConnect *) + protobuf_c_message_unpack (&rpc__resp__wifi_connect__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_connect__free_unpacked + (RpcRespWifiConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_disconnect__init + (RpcReqWifiDisconnect *message) +{ + static const RpcReqWifiDisconnect init_value = RPC__REQ__WIFI_DISCONNECT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_disconnect__get_packed_size + (const RpcReqWifiDisconnect *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_disconnect__pack + (const RpcReqWifiDisconnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_disconnect__pack_to_buffer + (const RpcReqWifiDisconnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiDisconnect * + rpc__req__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiDisconnect *) + protobuf_c_message_unpack (&rpc__req__wifi_disconnect__descriptor, + allocator, len, data); +} +void rpc__req__wifi_disconnect__free_unpacked + (RpcReqWifiDisconnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_disconnect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_disconnect__init + (RpcRespWifiDisconnect *message) +{ + static const RpcRespWifiDisconnect init_value = RPC__RESP__WIFI_DISCONNECT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_disconnect__get_packed_size + (const RpcRespWifiDisconnect *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_disconnect__pack + (const RpcRespWifiDisconnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_disconnect__pack_to_buffer + (const RpcRespWifiDisconnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiDisconnect * + rpc__resp__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiDisconnect *) + protobuf_c_message_unpack (&rpc__resp__wifi_disconnect__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_disconnect__free_unpacked + (RpcRespWifiDisconnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_disconnect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_start__init + (RpcReqWifiStart *message) +{ + static const RpcReqWifiStart init_value = RPC__REQ__WIFI_START__INIT; + *message = init_value; +} +size_t rpc__req__wifi_start__get_packed_size + (const RpcReqWifiStart *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_start__pack + (const RpcReqWifiStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_start__pack_to_buffer + (const RpcReqWifiStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStart * + rpc__req__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStart *) + protobuf_c_message_unpack (&rpc__req__wifi_start__descriptor, + allocator, len, data); +} +void rpc__req__wifi_start__free_unpacked + (RpcReqWifiStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_start__init + (RpcRespWifiStart *message) +{ + static const RpcRespWifiStart init_value = RPC__RESP__WIFI_START__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_start__get_packed_size + (const RpcRespWifiStart *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_start__pack + (const RpcRespWifiStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_start__pack_to_buffer + (const RpcRespWifiStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStart * + rpc__resp__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStart *) + protobuf_c_message_unpack (&rpc__resp__wifi_start__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_start__free_unpacked + (RpcRespWifiStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_stop__init + (RpcReqWifiStop *message) +{ + static const RpcReqWifiStop init_value = RPC__REQ__WIFI_STOP__INIT; + *message = init_value; +} +size_t rpc__req__wifi_stop__get_packed_size + (const RpcReqWifiStop *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_stop__pack + (const RpcReqWifiStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_stop__pack_to_buffer + (const RpcReqWifiStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStop * + rpc__req__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStop *) + protobuf_c_message_unpack (&rpc__req__wifi_stop__descriptor, + allocator, len, data); +} +void rpc__req__wifi_stop__free_unpacked + (RpcReqWifiStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_stop__init + (RpcRespWifiStop *message) +{ + static const RpcRespWifiStop init_value = RPC__RESP__WIFI_STOP__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_stop__get_packed_size + (const RpcRespWifiStop *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_stop__pack + (const RpcRespWifiStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_stop__pack_to_buffer + (const RpcRespWifiStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStop * + rpc__resp__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStop *) + protobuf_c_message_unpack (&rpc__resp__wifi_stop__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_stop__free_unpacked + (RpcRespWifiStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_start__init + (RpcReqWifiScanStart *message) +{ + static const RpcReqWifiScanStart init_value = RPC__REQ__WIFI_SCAN_START__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_start__get_packed_size + (const RpcReqWifiScanStart *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_start__pack + (const RpcReqWifiScanStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_start__pack_to_buffer + (const RpcReqWifiScanStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanStart * + rpc__req__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanStart *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_start__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_start__free_unpacked + (RpcReqWifiScanStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_start__init + (RpcRespWifiScanStart *message) +{ + static const RpcRespWifiScanStart init_value = RPC__RESP__WIFI_SCAN_START__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_start__get_packed_size + (const RpcRespWifiScanStart *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_start__pack + (const RpcRespWifiScanStart *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_start__pack_to_buffer + (const RpcRespWifiScanStart *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanStart * + rpc__resp__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanStart *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_start__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_start__free_unpacked + (RpcRespWifiScanStart *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_start__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_stop__init + (RpcReqWifiScanStop *message) +{ + static const RpcReqWifiScanStop init_value = RPC__REQ__WIFI_SCAN_STOP__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_stop__get_packed_size + (const RpcReqWifiScanStop *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_stop__pack + (const RpcReqWifiScanStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_stop__pack_to_buffer + (const RpcReqWifiScanStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanStop * + rpc__req__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanStop *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_stop__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_stop__free_unpacked + (RpcReqWifiScanStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_stop__init + (RpcRespWifiScanStop *message) +{ + static const RpcRespWifiScanStop init_value = RPC__RESP__WIFI_SCAN_STOP__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_stop__get_packed_size + (const RpcRespWifiScanStop *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_stop__pack + (const RpcRespWifiScanStop *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_stop__pack_to_buffer + (const RpcRespWifiScanStop *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanStop * + rpc__resp__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanStop *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_stop__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_stop__free_unpacked + (RpcRespWifiScanStop *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_stop__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_get_ap_num__init + (RpcReqWifiScanGetApNum *message) +{ + static const RpcReqWifiScanGetApNum init_value = RPC__REQ__WIFI_SCAN_GET_AP_NUM__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_get_ap_num__get_packed_size + (const RpcReqWifiScanGetApNum *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_get_ap_num__pack + (const RpcReqWifiScanGetApNum *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_get_ap_num__pack_to_buffer + (const RpcReqWifiScanGetApNum *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanGetApNum * + rpc__req__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanGetApNum *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_get_ap_num__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_get_ap_num__free_unpacked + (RpcReqWifiScanGetApNum *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_num__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_get_ap_num__init + (RpcRespWifiScanGetApNum *message) +{ + static const RpcRespWifiScanGetApNum init_value = RPC__RESP__WIFI_SCAN_GET_AP_NUM__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_get_ap_num__get_packed_size + (const RpcRespWifiScanGetApNum *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_get_ap_num__pack + (const RpcRespWifiScanGetApNum *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_get_ap_num__pack_to_buffer + (const RpcRespWifiScanGetApNum *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanGetApNum * + rpc__resp__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanGetApNum *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_get_ap_num__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_get_ap_num__free_unpacked + (RpcRespWifiScanGetApNum *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_num__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_get_ap_records__init + (RpcReqWifiScanGetApRecords *message) +{ + static const RpcReqWifiScanGetApRecords init_value = RPC__REQ__WIFI_SCAN_GET_AP_RECORDS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_get_ap_records__get_packed_size + (const RpcReqWifiScanGetApRecords *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_get_ap_records__pack + (const RpcReqWifiScanGetApRecords *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_get_ap_records__pack_to_buffer + (const RpcReqWifiScanGetApRecords *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanGetApRecords * + rpc__req__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanGetApRecords *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_get_ap_records__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_get_ap_records__free_unpacked + (RpcReqWifiScanGetApRecords *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_records__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_get_ap_records__init + (RpcRespWifiScanGetApRecords *message) +{ + static const RpcRespWifiScanGetApRecords init_value = RPC__RESP__WIFI_SCAN_GET_AP_RECORDS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_get_ap_records__get_packed_size + (const RpcRespWifiScanGetApRecords *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_get_ap_records__pack + (const RpcRespWifiScanGetApRecords *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_get_ap_records__pack_to_buffer + (const RpcRespWifiScanGetApRecords *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanGetApRecords * + rpc__resp__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanGetApRecords *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_get_ap_records__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_get_ap_records__free_unpacked + (RpcRespWifiScanGetApRecords *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_records__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_scan_get_ap_record__init + (RpcReqWifiScanGetApRecord *message) +{ + static const RpcReqWifiScanGetApRecord init_value = RPC__REQ__WIFI_SCAN_GET_AP_RECORD__INIT; + *message = init_value; +} +size_t rpc__req__wifi_scan_get_ap_record__get_packed_size + (const RpcReqWifiScanGetApRecord *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_scan_get_ap_record__pack + (const RpcReqWifiScanGetApRecord *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_scan_get_ap_record__pack_to_buffer + (const RpcReqWifiScanGetApRecord *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiScanGetApRecord * + rpc__req__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiScanGetApRecord *) + protobuf_c_message_unpack (&rpc__req__wifi_scan_get_ap_record__descriptor, + allocator, len, data); +} +void rpc__req__wifi_scan_get_ap_record__free_unpacked + (RpcReqWifiScanGetApRecord *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_scan_get_ap_record__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_scan_get_ap_record__init + (RpcRespWifiScanGetApRecord *message) +{ + static const RpcRespWifiScanGetApRecord init_value = RPC__RESP__WIFI_SCAN_GET_AP_RECORD__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_scan_get_ap_record__get_packed_size + (const RpcRespWifiScanGetApRecord *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_scan_get_ap_record__pack + (const RpcRespWifiScanGetApRecord *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_scan_get_ap_record__pack_to_buffer + (const RpcRespWifiScanGetApRecord *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiScanGetApRecord * + rpc__resp__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiScanGetApRecord *) + protobuf_c_message_unpack (&rpc__resp__wifi_scan_get_ap_record__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_scan_get_ap_record__free_unpacked + (RpcRespWifiScanGetApRecord *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_scan_get_ap_record__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_clear_ap_list__init + (RpcReqWifiClearApList *message) +{ + static const RpcReqWifiClearApList init_value = RPC__REQ__WIFI_CLEAR_AP_LIST__INIT; + *message = init_value; +} +size_t rpc__req__wifi_clear_ap_list__get_packed_size + (const RpcReqWifiClearApList *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_clear_ap_list__pack + (const RpcReqWifiClearApList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_clear_ap_list__pack_to_buffer + (const RpcReqWifiClearApList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiClearApList * + rpc__req__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiClearApList *) + protobuf_c_message_unpack (&rpc__req__wifi_clear_ap_list__descriptor, + allocator, len, data); +} +void rpc__req__wifi_clear_ap_list__free_unpacked + (RpcReqWifiClearApList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_clear_ap_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_clear_ap_list__init + (RpcRespWifiClearApList *message) +{ + static const RpcRespWifiClearApList init_value = RPC__RESP__WIFI_CLEAR_AP_LIST__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_clear_ap_list__get_packed_size + (const RpcRespWifiClearApList *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_clear_ap_list__pack + (const RpcRespWifiClearApList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_clear_ap_list__pack_to_buffer + (const RpcRespWifiClearApList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiClearApList * + rpc__resp__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiClearApList *) + protobuf_c_message_unpack (&rpc__resp__wifi_clear_ap_list__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_clear_ap_list__free_unpacked + (RpcRespWifiClearApList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_clear_ap_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_restore__init + (RpcReqWifiRestore *message) +{ + static const RpcReqWifiRestore init_value = RPC__REQ__WIFI_RESTORE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_restore__get_packed_size + (const RpcReqWifiRestore *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_restore__pack + (const RpcReqWifiRestore *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_restore__pack_to_buffer + (const RpcReqWifiRestore *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiRestore * + rpc__req__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiRestore *) + protobuf_c_message_unpack (&rpc__req__wifi_restore__descriptor, + allocator, len, data); +} +void rpc__req__wifi_restore__free_unpacked + (RpcReqWifiRestore *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_restore__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_restore__init + (RpcRespWifiRestore *message) +{ + static const RpcRespWifiRestore init_value = RPC__RESP__WIFI_RESTORE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_restore__get_packed_size + (const RpcRespWifiRestore *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_restore__pack + (const RpcRespWifiRestore *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_restore__pack_to_buffer + (const RpcRespWifiRestore *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiRestore * + rpc__resp__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiRestore *) + protobuf_c_message_unpack (&rpc__resp__wifi_restore__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_restore__free_unpacked + (RpcRespWifiRestore *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_restore__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_clear_fast_connect__init + (RpcReqWifiClearFastConnect *message) +{ + static const RpcReqWifiClearFastConnect init_value = RPC__REQ__WIFI_CLEAR_FAST_CONNECT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_clear_fast_connect__get_packed_size + (const RpcReqWifiClearFastConnect *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_clear_fast_connect__pack + (const RpcReqWifiClearFastConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_clear_fast_connect__pack_to_buffer + (const RpcReqWifiClearFastConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiClearFastConnect * + rpc__req__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiClearFastConnect *) + protobuf_c_message_unpack (&rpc__req__wifi_clear_fast_connect__descriptor, + allocator, len, data); +} +void rpc__req__wifi_clear_fast_connect__free_unpacked + (RpcReqWifiClearFastConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_clear_fast_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_clear_fast_connect__init + (RpcRespWifiClearFastConnect *message) +{ + static const RpcRespWifiClearFastConnect init_value = RPC__RESP__WIFI_CLEAR_FAST_CONNECT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_clear_fast_connect__get_packed_size + (const RpcRespWifiClearFastConnect *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_clear_fast_connect__pack + (const RpcRespWifiClearFastConnect *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_clear_fast_connect__pack_to_buffer + (const RpcRespWifiClearFastConnect *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiClearFastConnect * + rpc__resp__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiClearFastConnect *) + protobuf_c_message_unpack (&rpc__resp__wifi_clear_fast_connect__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_clear_fast_connect__free_unpacked + (RpcRespWifiClearFastConnect *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_clear_fast_connect__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_deauth_sta__init + (RpcReqWifiDeauthSta *message) +{ + static const RpcReqWifiDeauthSta init_value = RPC__REQ__WIFI_DEAUTH_STA__INIT; + *message = init_value; +} +size_t rpc__req__wifi_deauth_sta__get_packed_size + (const RpcReqWifiDeauthSta *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_deauth_sta__pack + (const RpcReqWifiDeauthSta *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_deauth_sta__pack_to_buffer + (const RpcReqWifiDeauthSta *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiDeauthSta * + rpc__req__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiDeauthSta *) + protobuf_c_message_unpack (&rpc__req__wifi_deauth_sta__descriptor, + allocator, len, data); +} +void rpc__req__wifi_deauth_sta__free_unpacked + (RpcReqWifiDeauthSta *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_deauth_sta__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_deauth_sta__init + (RpcRespWifiDeauthSta *message) +{ + static const RpcRespWifiDeauthSta init_value = RPC__RESP__WIFI_DEAUTH_STA__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_deauth_sta__get_packed_size + (const RpcRespWifiDeauthSta *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_deauth_sta__pack + (const RpcRespWifiDeauthSta *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_deauth_sta__pack_to_buffer + (const RpcRespWifiDeauthSta *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiDeauthSta * + rpc__resp__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiDeauthSta *) + protobuf_c_message_unpack (&rpc__resp__wifi_deauth_sta__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_deauth_sta__free_unpacked + (RpcRespWifiDeauthSta *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_deauth_sta__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_ap_info__init + (RpcReqWifiStaGetApInfo *message) +{ + static const RpcReqWifiStaGetApInfo init_value = RPC__REQ__WIFI_STA_GET_AP_INFO__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_ap_info__get_packed_size + (const RpcReqWifiStaGetApInfo *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_ap_info__pack + (const RpcReqWifiStaGetApInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_ap_info__pack_to_buffer + (const RpcReqWifiStaGetApInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetApInfo * + rpc__req__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetApInfo *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_ap_info__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_ap_info__free_unpacked + (RpcReqWifiStaGetApInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_ap_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_ap_info__init + (RpcRespWifiStaGetApInfo *message) +{ + static const RpcRespWifiStaGetApInfo init_value = RPC__RESP__WIFI_STA_GET_AP_INFO__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_ap_info__get_packed_size + (const RpcRespWifiStaGetApInfo *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_ap_info__pack + (const RpcRespWifiStaGetApInfo *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_ap_info__pack_to_buffer + (const RpcRespWifiStaGetApInfo *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetApInfo * + rpc__resp__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetApInfo *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_ap_info__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_ap_info__free_unpacked + (RpcRespWifiStaGetApInfo *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_ap_info__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_protocol__init + (RpcReqWifiSetProtocol *message) +{ + static const RpcReqWifiSetProtocol init_value = RPC__REQ__WIFI_SET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_protocol__get_packed_size + (const RpcReqWifiSetProtocol *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_protocol__pack + (const RpcReqWifiSetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_protocol__pack_to_buffer + (const RpcReqWifiSetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetProtocol * + rpc__req__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetProtocol *) + protobuf_c_message_unpack (&rpc__req__wifi_set_protocol__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_protocol__free_unpacked + (RpcReqWifiSetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_protocol__init + (RpcRespWifiSetProtocol *message) +{ + static const RpcRespWifiSetProtocol init_value = RPC__RESP__WIFI_SET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_protocol__get_packed_size + (const RpcRespWifiSetProtocol *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_protocol__pack + (const RpcRespWifiSetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_protocol__pack_to_buffer + (const RpcRespWifiSetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetProtocol * + rpc__resp__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetProtocol *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_protocol__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_protocol__free_unpacked + (RpcRespWifiSetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_protocol__init + (RpcReqWifiGetProtocol *message) +{ + static const RpcReqWifiGetProtocol init_value = RPC__REQ__WIFI_GET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_protocol__get_packed_size + (const RpcReqWifiGetProtocol *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_protocol__pack + (const RpcReqWifiGetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_protocol__pack_to_buffer + (const RpcReqWifiGetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetProtocol * + rpc__req__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetProtocol *) + protobuf_c_message_unpack (&rpc__req__wifi_get_protocol__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_protocol__free_unpacked + (RpcReqWifiGetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_protocol__init + (RpcRespWifiGetProtocol *message) +{ + static const RpcRespWifiGetProtocol init_value = RPC__RESP__WIFI_GET_PROTOCOL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_protocol__get_packed_size + (const RpcRespWifiGetProtocol *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_protocol__pack + (const RpcRespWifiGetProtocol *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_protocol__pack_to_buffer + (const RpcRespWifiGetProtocol *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetProtocol * + rpc__resp__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetProtocol *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_protocol__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_protocol__free_unpacked + (RpcRespWifiGetProtocol *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_protocol__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_bandwidth__init + (RpcReqWifiSetBandwidth *message) +{ + static const RpcReqWifiSetBandwidth init_value = RPC__REQ__WIFI_SET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_bandwidth__get_packed_size + (const RpcReqWifiSetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_bandwidth__pack + (const RpcReqWifiSetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_bandwidth__pack_to_buffer + (const RpcReqWifiSetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBandwidth * + rpc__req__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBandwidth *) + protobuf_c_message_unpack (&rpc__req__wifi_set_bandwidth__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_bandwidth__free_unpacked + (RpcReqWifiSetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_bandwidth__init + (RpcRespWifiSetBandwidth *message) +{ + static const RpcRespWifiSetBandwidth init_value = RPC__RESP__WIFI_SET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_bandwidth__get_packed_size + (const RpcRespWifiSetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_bandwidth__pack + (const RpcRespWifiSetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_bandwidth__pack_to_buffer + (const RpcRespWifiSetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBandwidth * + rpc__resp__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBandwidth *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_bandwidth__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_bandwidth__free_unpacked + (RpcRespWifiSetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_bandwidth__init + (RpcReqWifiGetBandwidth *message) +{ + static const RpcReqWifiGetBandwidth init_value = RPC__REQ__WIFI_GET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_bandwidth__get_packed_size + (const RpcReqWifiGetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_bandwidth__pack + (const RpcReqWifiGetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_bandwidth__pack_to_buffer + (const RpcReqWifiGetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBandwidth * + rpc__req__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBandwidth *) + protobuf_c_message_unpack (&rpc__req__wifi_get_bandwidth__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_bandwidth__free_unpacked + (RpcReqWifiGetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_bandwidth__init + (RpcRespWifiGetBandwidth *message) +{ + static const RpcRespWifiGetBandwidth init_value = RPC__RESP__WIFI_GET_BANDWIDTH__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_bandwidth__get_packed_size + (const RpcRespWifiGetBandwidth *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_bandwidth__pack + (const RpcRespWifiGetBandwidth *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_bandwidth__pack_to_buffer + (const RpcRespWifiGetBandwidth *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBandwidth * + rpc__resp__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBandwidth *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_bandwidth__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_bandwidth__free_unpacked + (RpcRespWifiGetBandwidth *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidth__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_channel__init + (RpcReqWifiSetChannel *message) +{ + static const RpcReqWifiSetChannel init_value = RPC__REQ__WIFI_SET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_channel__get_packed_size + (const RpcReqWifiSetChannel *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_channel__pack + (const RpcReqWifiSetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_channel__pack_to_buffer + (const RpcReqWifiSetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetChannel * + rpc__req__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetChannel *) + protobuf_c_message_unpack (&rpc__req__wifi_set_channel__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_channel__free_unpacked + (RpcReqWifiSetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_channel__init + (RpcRespWifiSetChannel *message) +{ + static const RpcRespWifiSetChannel init_value = RPC__RESP__WIFI_SET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_channel__get_packed_size + (const RpcRespWifiSetChannel *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_channel__pack + (const RpcRespWifiSetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_channel__pack_to_buffer + (const RpcRespWifiSetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetChannel * + rpc__resp__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetChannel *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_channel__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_channel__free_unpacked + (RpcRespWifiSetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_channel__init + (RpcReqWifiGetChannel *message) +{ + static const RpcReqWifiGetChannel init_value = RPC__REQ__WIFI_GET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_channel__get_packed_size + (const RpcReqWifiGetChannel *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_channel__pack + (const RpcReqWifiGetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_channel__pack_to_buffer + (const RpcReqWifiGetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetChannel * + rpc__req__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetChannel *) + protobuf_c_message_unpack (&rpc__req__wifi_get_channel__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_channel__free_unpacked + (RpcReqWifiGetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_channel__init + (RpcRespWifiGetChannel *message) +{ + static const RpcRespWifiGetChannel init_value = RPC__RESP__WIFI_GET_CHANNEL__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_channel__get_packed_size + (const RpcRespWifiGetChannel *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_channel__pack + (const RpcRespWifiGetChannel *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_channel__pack_to_buffer + (const RpcRespWifiGetChannel *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetChannel * + rpc__resp__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetChannel *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_channel__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_channel__free_unpacked + (RpcRespWifiGetChannel *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_channel__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_storage__init + (RpcReqWifiSetStorage *message) +{ + static const RpcReqWifiSetStorage init_value = RPC__REQ__WIFI_SET_STORAGE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_storage__get_packed_size + (const RpcReqWifiSetStorage *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_storage__pack + (const RpcReqWifiSetStorage *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_storage__pack_to_buffer + (const RpcReqWifiSetStorage *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetStorage * + rpc__req__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetStorage *) + protobuf_c_message_unpack (&rpc__req__wifi_set_storage__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_storage__free_unpacked + (RpcReqWifiSetStorage *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_storage__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_storage__init + (RpcRespWifiSetStorage *message) +{ + static const RpcRespWifiSetStorage init_value = RPC__RESP__WIFI_SET_STORAGE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_storage__get_packed_size + (const RpcRespWifiSetStorage *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_storage__pack + (const RpcRespWifiSetStorage *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_storage__pack_to_buffer + (const RpcRespWifiSetStorage *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetStorage * + rpc__resp__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetStorage *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_storage__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_storage__free_unpacked + (RpcRespWifiSetStorage *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_storage__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_country_code__init + (RpcReqWifiSetCountryCode *message) +{ + static const RpcReqWifiSetCountryCode init_value = RPC__REQ__WIFI_SET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_country_code__get_packed_size + (const RpcReqWifiSetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_country_code__pack + (const RpcReqWifiSetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_country_code__pack_to_buffer + (const RpcReqWifiSetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetCountryCode * + rpc__req__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetCountryCode *) + protobuf_c_message_unpack (&rpc__req__wifi_set_country_code__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_country_code__free_unpacked + (RpcReqWifiSetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_country_code__init + (RpcRespWifiSetCountryCode *message) +{ + static const RpcRespWifiSetCountryCode init_value = RPC__RESP__WIFI_SET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_country_code__get_packed_size + (const RpcRespWifiSetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_country_code__pack + (const RpcRespWifiSetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_country_code__pack_to_buffer + (const RpcRespWifiSetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetCountryCode * + rpc__resp__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetCountryCode *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_country_code__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_country_code__free_unpacked + (RpcRespWifiSetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_country_code__init + (RpcReqWifiGetCountryCode *message) +{ + static const RpcReqWifiGetCountryCode init_value = RPC__REQ__WIFI_GET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_country_code__get_packed_size + (const RpcReqWifiGetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_country_code__pack + (const RpcReqWifiGetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_country_code__pack_to_buffer + (const RpcReqWifiGetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetCountryCode * + rpc__req__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetCountryCode *) + protobuf_c_message_unpack (&rpc__req__wifi_get_country_code__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_country_code__free_unpacked + (RpcReqWifiGetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_country_code__init + (RpcRespWifiGetCountryCode *message) +{ + static const RpcRespWifiGetCountryCode init_value = RPC__RESP__WIFI_GET_COUNTRY_CODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_country_code__get_packed_size + (const RpcRespWifiGetCountryCode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_country_code__pack + (const RpcRespWifiGetCountryCode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_country_code__pack_to_buffer + (const RpcRespWifiGetCountryCode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetCountryCode * + rpc__resp__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetCountryCode *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_country_code__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_country_code__free_unpacked + (RpcRespWifiGetCountryCode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_country_code__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_country__init + (RpcReqWifiSetCountry *message) +{ + static const RpcReqWifiSetCountry init_value = RPC__REQ__WIFI_SET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_country__get_packed_size + (const RpcReqWifiSetCountry *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_country__pack + (const RpcReqWifiSetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_country__pack_to_buffer + (const RpcReqWifiSetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetCountry * + rpc__req__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetCountry *) + protobuf_c_message_unpack (&rpc__req__wifi_set_country__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_country__free_unpacked + (RpcReqWifiSetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_country__init + (RpcRespWifiSetCountry *message) +{ + static const RpcRespWifiSetCountry init_value = RPC__RESP__WIFI_SET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_country__get_packed_size + (const RpcRespWifiSetCountry *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_country__pack + (const RpcRespWifiSetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_country__pack_to_buffer + (const RpcRespWifiSetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetCountry * + rpc__resp__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetCountry *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_country__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_country__free_unpacked + (RpcRespWifiSetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_country__init + (RpcReqWifiGetCountry *message) +{ + static const RpcReqWifiGetCountry init_value = RPC__REQ__WIFI_GET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_country__get_packed_size + (const RpcReqWifiGetCountry *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_country__pack + (const RpcReqWifiGetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_country__pack_to_buffer + (const RpcReqWifiGetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetCountry * + rpc__req__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetCountry *) + protobuf_c_message_unpack (&rpc__req__wifi_get_country__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_country__free_unpacked + (RpcReqWifiGetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_country__init + (RpcRespWifiGetCountry *message) +{ + static const RpcRespWifiGetCountry init_value = RPC__RESP__WIFI_GET_COUNTRY__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_country__get_packed_size + (const RpcRespWifiGetCountry *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_country__pack + (const RpcRespWifiGetCountry *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_country__pack_to_buffer + (const RpcRespWifiGetCountry *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetCountry * + rpc__resp__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetCountry *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_country__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_country__free_unpacked + (RpcRespWifiGetCountry *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_country__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_ap_get_sta_list__init + (RpcReqWifiApGetStaList *message) +{ + static const RpcReqWifiApGetStaList init_value = RPC__REQ__WIFI_AP_GET_STA_LIST__INIT; + *message = init_value; +} +size_t rpc__req__wifi_ap_get_sta_list__get_packed_size + (const RpcReqWifiApGetStaList *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_ap_get_sta_list__pack + (const RpcReqWifiApGetStaList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_ap_get_sta_list__pack_to_buffer + (const RpcReqWifiApGetStaList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiApGetStaList * + rpc__req__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiApGetStaList *) + protobuf_c_message_unpack (&rpc__req__wifi_ap_get_sta_list__descriptor, + allocator, len, data); +} +void rpc__req__wifi_ap_get_sta_list__free_unpacked + (RpcReqWifiApGetStaList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_ap_get_sta_list__init + (RpcRespWifiApGetStaList *message) +{ + static const RpcRespWifiApGetStaList init_value = RPC__RESP__WIFI_AP_GET_STA_LIST__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_ap_get_sta_list__get_packed_size + (const RpcRespWifiApGetStaList *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_ap_get_sta_list__pack + (const RpcRespWifiApGetStaList *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_ap_get_sta_list__pack_to_buffer + (const RpcRespWifiApGetStaList *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiApGetStaList * + rpc__resp__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiApGetStaList *) + protobuf_c_message_unpack (&rpc__resp__wifi_ap_get_sta_list__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_ap_get_sta_list__free_unpacked + (RpcRespWifiApGetStaList *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_list__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_ap_get_sta_aid__init + (RpcReqWifiApGetStaAid *message) +{ + static const RpcReqWifiApGetStaAid init_value = RPC__REQ__WIFI_AP_GET_STA_AID__INIT; + *message = init_value; +} +size_t rpc__req__wifi_ap_get_sta_aid__get_packed_size + (const RpcReqWifiApGetStaAid *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_ap_get_sta_aid__pack + (const RpcReqWifiApGetStaAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcReqWifiApGetStaAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiApGetStaAid * + rpc__req__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiApGetStaAid *) + protobuf_c_message_unpack (&rpc__req__wifi_ap_get_sta_aid__descriptor, + allocator, len, data); +} +void rpc__req__wifi_ap_get_sta_aid__free_unpacked + (RpcReqWifiApGetStaAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_ap_get_sta_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_negotiated_phymode__init + (RpcReqWifiStaGetNegotiatedPhymode *message) +{ + static const RpcReqWifiStaGetNegotiatedPhymode init_value = RPC__REQ__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcReqWifiStaGetNegotiatedPhymode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack + (const RpcReqWifiStaGetNegotiatedPhymode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetNegotiatedPhymode * + rpc__req__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetNegotiatedPhymode *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_negotiated_phymode__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_negotiated_phymode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_negotiated_phymode__init + (RpcRespWifiStaGetNegotiatedPhymode *message) +{ + static const RpcRespWifiStaGetNegotiatedPhymode init_value = RPC__RESP__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcRespWifiStaGetNegotiatedPhymode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack + (const RpcRespWifiStaGetNegotiatedPhymode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetNegotiatedPhymode * + rpc__resp__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetNegotiatedPhymode *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_negotiated_phymode__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_ap_get_sta_aid__init + (RpcRespWifiApGetStaAid *message) +{ + static const RpcRespWifiApGetStaAid init_value = RPC__RESP__WIFI_AP_GET_STA_AID__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_ap_get_sta_aid__get_packed_size + (const RpcRespWifiApGetStaAid *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_ap_get_sta_aid__pack + (const RpcRespWifiApGetStaAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcRespWifiApGetStaAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiApGetStaAid * + rpc__resp__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiApGetStaAid *) + protobuf_c_message_unpack (&rpc__resp__wifi_ap_get_sta_aid__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_ap_get_sta_aid__free_unpacked + (RpcRespWifiApGetStaAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_ap_get_sta_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_rssi__init + (RpcReqWifiStaGetRssi *message) +{ + static const RpcReqWifiStaGetRssi init_value = RPC__REQ__WIFI_STA_GET_RSSI__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_rssi__get_packed_size + (const RpcReqWifiStaGetRssi *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_rssi__pack + (const RpcReqWifiStaGetRssi *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_rssi__pack_to_buffer + (const RpcReqWifiStaGetRssi *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetRssi * + rpc__req__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetRssi *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_rssi__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_rssi__free_unpacked + (RpcReqWifiStaGetRssi *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_rssi__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_rssi__init + (RpcRespWifiStaGetRssi *message) +{ + static const RpcRespWifiStaGetRssi init_value = RPC__RESP__WIFI_STA_GET_RSSI__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_rssi__get_packed_size + (const RpcRespWifiStaGetRssi *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_rssi__pack + (const RpcRespWifiStaGetRssi *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_rssi__pack_to_buffer + (const RpcRespWifiStaGetRssi *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetRssi * + rpc__resp__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetRssi *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_rssi__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_rssi__free_unpacked + (RpcRespWifiStaGetRssi *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_rssi__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_get_aid__init + (RpcReqWifiStaGetAid *message) +{ + static const RpcReqWifiStaGetAid init_value = RPC__REQ__WIFI_STA_GET_AID__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_get_aid__get_packed_size + (const RpcReqWifiStaGetAid *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_get_aid__pack + (const RpcReqWifiStaGetAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_get_aid__pack_to_buffer + (const RpcReqWifiStaGetAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaGetAid * + rpc__req__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaGetAid *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_get_aid__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_get_aid__free_unpacked + (RpcReqWifiStaGetAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_get_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_get_aid__init + (RpcRespWifiStaGetAid *message) +{ + static const RpcRespWifiStaGetAid init_value = RPC__RESP__WIFI_STA_GET_AID__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_get_aid__get_packed_size + (const RpcRespWifiStaGetAid *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_get_aid__pack + (const RpcRespWifiStaGetAid *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_get_aid__pack_to_buffer + (const RpcRespWifiStaGetAid *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaGetAid * + rpc__resp__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaGetAid *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_get_aid__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_get_aid__free_unpacked + (RpcRespWifiStaGetAid *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_get_aid__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_protocols__init + (RpcReqWifiSetProtocols *message) +{ + static const RpcReqWifiSetProtocols init_value = RPC__REQ__WIFI_SET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_protocols__get_packed_size + (const RpcReqWifiSetProtocols *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_protocols__pack + (const RpcReqWifiSetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_protocols__pack_to_buffer + (const RpcReqWifiSetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetProtocols * + rpc__req__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetProtocols *) + protobuf_c_message_unpack (&rpc__req__wifi_set_protocols__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_protocols__free_unpacked + (RpcReqWifiSetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_protocols__init + (RpcRespWifiSetProtocols *message) +{ + static const RpcRespWifiSetProtocols init_value = RPC__RESP__WIFI_SET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_protocols__get_packed_size + (const RpcRespWifiSetProtocols *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_protocols__pack + (const RpcRespWifiSetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_protocols__pack_to_buffer + (const RpcRespWifiSetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetProtocols * + rpc__resp__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetProtocols *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_protocols__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_protocols__free_unpacked + (RpcRespWifiSetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_protocols__init + (RpcReqWifiGetProtocols *message) +{ + static const RpcReqWifiGetProtocols init_value = RPC__REQ__WIFI_GET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_protocols__get_packed_size + (const RpcReqWifiGetProtocols *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_protocols__pack + (const RpcReqWifiGetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_protocols__pack_to_buffer + (const RpcReqWifiGetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetProtocols * + rpc__req__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetProtocols *) + protobuf_c_message_unpack (&rpc__req__wifi_get_protocols__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_protocols__free_unpacked + (RpcReqWifiGetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_protocols__init + (RpcRespWifiGetProtocols *message) +{ + static const RpcRespWifiGetProtocols init_value = RPC__RESP__WIFI_GET_PROTOCOLS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_protocols__get_packed_size + (const RpcRespWifiGetProtocols *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_protocols__pack + (const RpcRespWifiGetProtocols *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_protocols__pack_to_buffer + (const RpcRespWifiGetProtocols *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetProtocols * + rpc__resp__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetProtocols *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_protocols__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_protocols__free_unpacked + (RpcRespWifiGetProtocols *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_protocols__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_bandwidths__init + (RpcReqWifiSetBandwidths *message) +{ + static const RpcReqWifiSetBandwidths init_value = RPC__REQ__WIFI_SET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_bandwidths__get_packed_size + (const RpcReqWifiSetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_bandwidths__pack + (const RpcReqWifiSetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_bandwidths__pack_to_buffer + (const RpcReqWifiSetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBandwidths * + rpc__req__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBandwidths *) + protobuf_c_message_unpack (&rpc__req__wifi_set_bandwidths__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_bandwidths__free_unpacked + (RpcReqWifiSetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_bandwidths__init + (RpcRespWifiSetBandwidths *message) +{ + static const RpcRespWifiSetBandwidths init_value = RPC__RESP__WIFI_SET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_bandwidths__get_packed_size + (const RpcRespWifiSetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_bandwidths__pack + (const RpcRespWifiSetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_bandwidths__pack_to_buffer + (const RpcRespWifiSetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBandwidths * + rpc__resp__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBandwidths *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_bandwidths__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_bandwidths__free_unpacked + (RpcRespWifiSetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_bandwidths__init + (RpcReqWifiGetBandwidths *message) +{ + static const RpcReqWifiGetBandwidths init_value = RPC__REQ__WIFI_GET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_bandwidths__get_packed_size + (const RpcReqWifiGetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_bandwidths__pack + (const RpcReqWifiGetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_bandwidths__pack_to_buffer + (const RpcReqWifiGetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBandwidths * + rpc__req__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBandwidths *) + protobuf_c_message_unpack (&rpc__req__wifi_get_bandwidths__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_bandwidths__free_unpacked + (RpcReqWifiGetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_bandwidths__init + (RpcRespWifiGetBandwidths *message) +{ + static const RpcRespWifiGetBandwidths init_value = RPC__RESP__WIFI_GET_BANDWIDTHS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_bandwidths__get_packed_size + (const RpcRespWifiGetBandwidths *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_bandwidths__pack + (const RpcRespWifiGetBandwidths *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_bandwidths__pack_to_buffer + (const RpcRespWifiGetBandwidths *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBandwidths * + rpc__resp__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBandwidths *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_bandwidths__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_bandwidths__free_unpacked + (RpcRespWifiGetBandwidths *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_bandwidths__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_band__init + (RpcReqWifiSetBand *message) +{ + static const RpcReqWifiSetBand init_value = RPC__REQ__WIFI_SET_BAND__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_band__get_packed_size + (const RpcReqWifiSetBand *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_band__pack + (const RpcReqWifiSetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_band__pack_to_buffer + (const RpcReqWifiSetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBand * + rpc__req__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBand *) + protobuf_c_message_unpack (&rpc__req__wifi_set_band__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_band__free_unpacked + (RpcReqWifiSetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_band__init + (RpcRespWifiSetBand *message) +{ + static const RpcRespWifiSetBand init_value = RPC__RESP__WIFI_SET_BAND__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_band__get_packed_size + (const RpcRespWifiSetBand *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_band__pack + (const RpcRespWifiSetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_band__pack_to_buffer + (const RpcRespWifiSetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBand * + rpc__resp__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBand *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_band__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_band__free_unpacked + (RpcRespWifiSetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_band__init + (RpcReqWifiGetBand *message) +{ + static const RpcReqWifiGetBand init_value = RPC__REQ__WIFI_GET_BAND__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_band__get_packed_size + (const RpcReqWifiGetBand *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_band__pack + (const RpcReqWifiGetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_band__pack_to_buffer + (const RpcReqWifiGetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBand * + rpc__req__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBand *) + protobuf_c_message_unpack (&rpc__req__wifi_get_band__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_band__free_unpacked + (RpcReqWifiGetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_band__init + (RpcRespWifiGetBand *message) +{ + static const RpcRespWifiGetBand init_value = RPC__RESP__WIFI_GET_BAND__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_band__get_packed_size + (const RpcRespWifiGetBand *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_band__pack + (const RpcRespWifiGetBand *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_band__pack_to_buffer + (const RpcRespWifiGetBand *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBand * + rpc__resp__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBand *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_band__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_band__free_unpacked + (RpcRespWifiGetBand *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_band__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_band_mode__init + (RpcReqWifiSetBandMode *message) +{ + static const RpcReqWifiSetBandMode init_value = RPC__REQ__WIFI_SET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_band_mode__get_packed_size + (const RpcReqWifiSetBandMode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_band_mode__pack + (const RpcReqWifiSetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_band_mode__pack_to_buffer + (const RpcReqWifiSetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetBandMode * + rpc__req__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetBandMode *) + protobuf_c_message_unpack (&rpc__req__wifi_set_band_mode__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_band_mode__free_unpacked + (RpcReqWifiSetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_band_mode__init + (RpcRespWifiSetBandMode *message) +{ + static const RpcRespWifiSetBandMode init_value = RPC__RESP__WIFI_SET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_band_mode__get_packed_size + (const RpcRespWifiSetBandMode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_band_mode__pack + (const RpcRespWifiSetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_band_mode__pack_to_buffer + (const RpcRespWifiSetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetBandMode * + rpc__resp__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetBandMode *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_band_mode__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_band_mode__free_unpacked + (RpcRespWifiSetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_band_mode__init + (RpcReqWifiGetBandMode *message) +{ + static const RpcReqWifiGetBandMode init_value = RPC__REQ__WIFI_GET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_band_mode__get_packed_size + (const RpcReqWifiGetBandMode *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_band_mode__pack + (const RpcReqWifiGetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_band_mode__pack_to_buffer + (const RpcReqWifiGetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetBandMode * + rpc__req__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetBandMode *) + protobuf_c_message_unpack (&rpc__req__wifi_get_band_mode__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_band_mode__free_unpacked + (RpcReqWifiGetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_band_mode__init + (RpcRespWifiGetBandMode *message) +{ + static const RpcRespWifiGetBandMode init_value = RPC__RESP__WIFI_GET_BAND_MODE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_band_mode__get_packed_size + (const RpcRespWifiGetBandMode *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_band_mode__pack + (const RpcRespWifiGetBandMode *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_band_mode__pack_to_buffer + (const RpcRespWifiGetBandMode *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetBandMode * + rpc__resp__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetBandMode *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_band_mode__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_band_mode__free_unpacked + (RpcRespWifiGetBandMode *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_band_mode__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_inactive_time__init + (RpcReqWifiSetInactiveTime *message) +{ + static const RpcReqWifiSetInactiveTime init_value = RPC__REQ__WIFI_SET_INACTIVE_TIME__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_inactive_time__get_packed_size + (const RpcReqWifiSetInactiveTime *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_inactive_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_inactive_time__pack + (const RpcReqWifiSetInactiveTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_inactive_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_inactive_time__pack_to_buffer + (const RpcReqWifiSetInactiveTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_inactive_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetInactiveTime * + rpc__req__wifi_set_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetInactiveTime *) + protobuf_c_message_unpack (&rpc__req__wifi_set_inactive_time__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_inactive_time__free_unpacked + (RpcReqWifiSetInactiveTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_inactive_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_inactive_time__init + (RpcRespWifiSetInactiveTime *message) +{ + static const RpcRespWifiSetInactiveTime init_value = RPC__RESP__WIFI_SET_INACTIVE_TIME__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_inactive_time__get_packed_size + (const RpcRespWifiSetInactiveTime *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_inactive_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_inactive_time__pack + (const RpcRespWifiSetInactiveTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_inactive_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_inactive_time__pack_to_buffer + (const RpcRespWifiSetInactiveTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_inactive_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetInactiveTime * + rpc__resp__wifi_set_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetInactiveTime *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_inactive_time__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_inactive_time__free_unpacked + (RpcRespWifiSetInactiveTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_inactive_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_get_inactive_time__init + (RpcReqWifiGetInactiveTime *message) +{ + static const RpcReqWifiGetInactiveTime init_value = RPC__REQ__WIFI_GET_INACTIVE_TIME__INIT; + *message = init_value; +} +size_t rpc__req__wifi_get_inactive_time__get_packed_size + (const RpcReqWifiGetInactiveTime *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_inactive_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_get_inactive_time__pack + (const RpcReqWifiGetInactiveTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_inactive_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_get_inactive_time__pack_to_buffer + (const RpcReqWifiGetInactiveTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_get_inactive_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiGetInactiveTime * + rpc__req__wifi_get_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiGetInactiveTime *) + protobuf_c_message_unpack (&rpc__req__wifi_get_inactive_time__descriptor, + allocator, len, data); +} +void rpc__req__wifi_get_inactive_time__free_unpacked + (RpcReqWifiGetInactiveTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_get_inactive_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_get_inactive_time__init + (RpcRespWifiGetInactiveTime *message) +{ + static const RpcRespWifiGetInactiveTime init_value = RPC__RESP__WIFI_GET_INACTIVE_TIME__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_get_inactive_time__get_packed_size + (const RpcRespWifiGetInactiveTime *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_inactive_time__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_get_inactive_time__pack + (const RpcRespWifiGetInactiveTime *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_inactive_time__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_get_inactive_time__pack_to_buffer + (const RpcRespWifiGetInactiveTime *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_get_inactive_time__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiGetInactiveTime * + rpc__resp__wifi_get_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiGetInactiveTime *) + protobuf_c_message_unpack (&rpc__resp__wifi_get_inactive_time__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_get_inactive_time__free_unpacked + (RpcRespWifiGetInactiveTime *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_get_inactive_time__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_itwt_setup__init + (RpcReqWifiStaItwtSetup *message) +{ + static const RpcReqWifiStaItwtSetup init_value = RPC__REQ__WIFI_STA_ITWT_SETUP__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_itwt_setup__get_packed_size + (const RpcReqWifiStaItwtSetup *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_setup__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_itwt_setup__pack + (const RpcReqWifiStaItwtSetup *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_setup__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_itwt_setup__pack_to_buffer + (const RpcReqWifiStaItwtSetup *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_setup__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaItwtSetup * + rpc__req__wifi_sta_itwt_setup__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaItwtSetup *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_itwt_setup__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_itwt_setup__free_unpacked + (RpcReqWifiStaItwtSetup *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_setup__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_itwt_setup__init + (RpcRespWifiStaItwtSetup *message) +{ + static const RpcRespWifiStaItwtSetup init_value = RPC__RESP__WIFI_STA_ITWT_SETUP__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_itwt_setup__get_packed_size + (const RpcRespWifiStaItwtSetup *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_setup__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_itwt_setup__pack + (const RpcRespWifiStaItwtSetup *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_setup__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_itwt_setup__pack_to_buffer + (const RpcRespWifiStaItwtSetup *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_setup__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaItwtSetup * + rpc__resp__wifi_sta_itwt_setup__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaItwtSetup *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_itwt_setup__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_itwt_setup__free_unpacked + (RpcRespWifiStaItwtSetup *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_setup__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_itwt_teardown__init + (RpcReqWifiStaItwtTeardown *message) +{ + static const RpcReqWifiStaItwtTeardown init_value = RPC__REQ__WIFI_STA_ITWT_TEARDOWN__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_itwt_teardown__get_packed_size + (const RpcReqWifiStaItwtTeardown *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_teardown__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_itwt_teardown__pack + (const RpcReqWifiStaItwtTeardown *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_teardown__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_itwt_teardown__pack_to_buffer + (const RpcReqWifiStaItwtTeardown *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_teardown__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaItwtTeardown * + rpc__req__wifi_sta_itwt_teardown__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaItwtTeardown *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_itwt_teardown__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_itwt_teardown__free_unpacked + (RpcReqWifiStaItwtTeardown *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_teardown__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_itwt_teardown__init + (RpcRespWifiStaItwtTeardown *message) +{ + static const RpcRespWifiStaItwtTeardown init_value = RPC__RESP__WIFI_STA_ITWT_TEARDOWN__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_itwt_teardown__get_packed_size + (const RpcRespWifiStaItwtTeardown *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_teardown__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_itwt_teardown__pack + (const RpcRespWifiStaItwtTeardown *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_teardown__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_itwt_teardown__pack_to_buffer + (const RpcRespWifiStaItwtTeardown *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_teardown__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaItwtTeardown * + rpc__resp__wifi_sta_itwt_teardown__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaItwtTeardown *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_itwt_teardown__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_itwt_teardown__free_unpacked + (RpcRespWifiStaItwtTeardown *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_teardown__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_itwt_suspend__init + (RpcReqWifiStaItwtSuspend *message) +{ + static const RpcReqWifiStaItwtSuspend init_value = RPC__REQ__WIFI_STA_ITWT_SUSPEND__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_itwt_suspend__get_packed_size + (const RpcReqWifiStaItwtSuspend *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_suspend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_itwt_suspend__pack + (const RpcReqWifiStaItwtSuspend *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_suspend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_itwt_suspend__pack_to_buffer + (const RpcReqWifiStaItwtSuspend *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_suspend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaItwtSuspend * + rpc__req__wifi_sta_itwt_suspend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaItwtSuspend *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_itwt_suspend__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_itwt_suspend__free_unpacked + (RpcReqWifiStaItwtSuspend *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_suspend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_itwt_suspend__init + (RpcRespWifiStaItwtSuspend *message) +{ + static const RpcRespWifiStaItwtSuspend init_value = RPC__RESP__WIFI_STA_ITWT_SUSPEND__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_itwt_suspend__get_packed_size + (const RpcRespWifiStaItwtSuspend *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_suspend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_itwt_suspend__pack + (const RpcRespWifiStaItwtSuspend *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_suspend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_itwt_suspend__pack_to_buffer + (const RpcRespWifiStaItwtSuspend *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_suspend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaItwtSuspend * + rpc__resp__wifi_sta_itwt_suspend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaItwtSuspend *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_itwt_suspend__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_itwt_suspend__free_unpacked + (RpcRespWifiStaItwtSuspend *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_suspend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_itwt_get_flow_id_status__init + (RpcReqWifiStaItwtGetFlowIdStatus *message) +{ + static const RpcReqWifiStaItwtGetFlowIdStatus init_value = RPC__REQ__WIFI_STA_ITWT_GET_FLOW_ID_STATUS__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_itwt_get_flow_id_status__get_packed_size + (const RpcReqWifiStaItwtGetFlowIdStatus *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_itwt_get_flow_id_status__pack + (const RpcReqWifiStaItwtGetFlowIdStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_itwt_get_flow_id_status__pack_to_buffer + (const RpcReqWifiStaItwtGetFlowIdStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaItwtGetFlowIdStatus * + rpc__req__wifi_sta_itwt_get_flow_id_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaItwtGetFlowIdStatus *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_itwt_get_flow_id_status__free_unpacked + (RpcReqWifiStaItwtGetFlowIdStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_itwt_get_flow_id_status__init + (RpcRespWifiStaItwtGetFlowIdStatus *message) +{ + static const RpcRespWifiStaItwtGetFlowIdStatus init_value = RPC__RESP__WIFI_STA_ITWT_GET_FLOW_ID_STATUS__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__get_packed_size + (const RpcRespWifiStaItwtGetFlowIdStatus *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__pack + (const RpcRespWifiStaItwtGetFlowIdStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__pack_to_buffer + (const RpcRespWifiStaItwtGetFlowIdStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaItwtGetFlowIdStatus * + rpc__resp__wifi_sta_itwt_get_flow_id_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaItwtGetFlowIdStatus *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_itwt_get_flow_id_status__free_unpacked + (RpcRespWifiStaItwtGetFlowIdStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_itwt_send_probe_req__init + (RpcReqWifiStaItwtSendProbeReq *message) +{ + static const RpcReqWifiStaItwtSendProbeReq init_value = RPC__REQ__WIFI_STA_ITWT_SEND_PROBE_REQ__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_itwt_send_probe_req__get_packed_size + (const RpcReqWifiStaItwtSendProbeReq *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_send_probe_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_itwt_send_probe_req__pack + (const RpcReqWifiStaItwtSendProbeReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_send_probe_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_itwt_send_probe_req__pack_to_buffer + (const RpcReqWifiStaItwtSendProbeReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_send_probe_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaItwtSendProbeReq * + rpc__req__wifi_sta_itwt_send_probe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaItwtSendProbeReq *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_itwt_send_probe_req__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_itwt_send_probe_req__free_unpacked + (RpcReqWifiStaItwtSendProbeReq *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_send_probe_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_itwt_send_probe_req__init + (RpcRespWifiStaItwtSendProbeReq *message) +{ + static const RpcRespWifiStaItwtSendProbeReq init_value = RPC__RESP__WIFI_STA_ITWT_SEND_PROBE_REQ__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_itwt_send_probe_req__get_packed_size + (const RpcRespWifiStaItwtSendProbeReq *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_send_probe_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_itwt_send_probe_req__pack + (const RpcRespWifiStaItwtSendProbeReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_send_probe_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_itwt_send_probe_req__pack_to_buffer + (const RpcRespWifiStaItwtSendProbeReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_send_probe_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaItwtSendProbeReq * + rpc__resp__wifi_sta_itwt_send_probe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaItwtSendProbeReq *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_itwt_send_probe_req__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_itwt_send_probe_req__free_unpacked + (RpcRespWifiStaItwtSendProbeReq *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_send_probe_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_itwt_set_target_wake_time_offset__init + (RpcReqWifiStaItwtSetTargetWakeTimeOffset *message) +{ + static const RpcReqWifiStaItwtSetTargetWakeTimeOffset init_value = RPC__REQ__WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__get_packed_size + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__pack + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__pack_to_buffer + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaItwtSetTargetWakeTimeOffset * + rpc__req__wifi_sta_itwt_set_target_wake_time_offset__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaItwtSetTargetWakeTimeOffset *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_itwt_set_target_wake_time_offset__free_unpacked + (RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__init + (RpcRespWifiStaItwtSetTargetWakeTimeOffset *message) +{ + static const RpcRespWifiStaItwtSetTargetWakeTimeOffset init_value = RPC__RESP__WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__get_packed_size + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__pack + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__pack_to_buffer + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaItwtSetTargetWakeTimeOffset * + rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaItwtSetTargetWakeTimeOffset *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__free_unpacked + (RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_twt_config__init + (RpcReqWifiStaTwtConfig *message) +{ + static const RpcReqWifiStaTwtConfig init_value = RPC__REQ__WIFI_STA_TWT_CONFIG__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_twt_config__get_packed_size + (const RpcReqWifiStaTwtConfig *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_twt_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_twt_config__pack + (const RpcReqWifiStaTwtConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_twt_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_twt_config__pack_to_buffer + (const RpcReqWifiStaTwtConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_twt_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaTwtConfig * + rpc__req__wifi_sta_twt_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaTwtConfig *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_twt_config__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_twt_config__free_unpacked + (RpcReqWifiStaTwtConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_twt_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_twt_config__init + (RpcRespWifiStaTwtConfig *message) +{ + static const RpcRespWifiStaTwtConfig init_value = RPC__RESP__WIFI_STA_TWT_CONFIG__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_twt_config__get_packed_size + (const RpcRespWifiStaTwtConfig *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_twt_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_twt_config__pack + (const RpcRespWifiStaTwtConfig *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_twt_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_twt_config__pack_to_buffer + (const RpcRespWifiStaTwtConfig *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_twt_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaTwtConfig * + rpc__resp__wifi_sta_twt_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaTwtConfig *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_twt_config__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_twt_config__free_unpacked + (RpcRespWifiStaTwtConfig *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_twt_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_coprocessor_fw_version__init + (RpcReqGetCoprocessorFwVersion *message) +{ + static const RpcReqGetCoprocessorFwVersion init_value = RPC__REQ__GET_COPROCESSOR_FW_VERSION__INIT; + *message = init_value; +} +size_t rpc__req__get_coprocessor_fw_version__get_packed_size + (const RpcReqGetCoprocessorFwVersion *message) +{ + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_coprocessor_fw_version__pack + (const RpcReqGetCoprocessorFwVersion *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_coprocessor_fw_version__pack_to_buffer + (const RpcReqGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetCoprocessorFwVersion * + rpc__req__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetCoprocessorFwVersion *) + protobuf_c_message_unpack (&rpc__req__get_coprocessor_fw_version__descriptor, + allocator, len, data); +} +void rpc__req__get_coprocessor_fw_version__free_unpacked + (RpcReqGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_coprocessor_fw_version__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_coprocessor_fw_version__init + (RpcRespGetCoprocessorFwVersion *message) +{ + static const RpcRespGetCoprocessorFwVersion init_value = RPC__RESP__GET_COPROCESSOR_FW_VERSION__INIT; + *message = init_value; +} +size_t rpc__resp__get_coprocessor_fw_version__get_packed_size + (const RpcRespGetCoprocessorFwVersion *message) +{ + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_coprocessor_fw_version__pack + (const RpcRespGetCoprocessorFwVersion *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_coprocessor_fw_version__pack_to_buffer + (const RpcRespGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetCoprocessorFwVersion * + rpc__resp__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetCoprocessorFwVersion *) + protobuf_c_message_unpack (&rpc__resp__get_coprocessor_fw_version__descriptor, + allocator, len, data); +} +void rpc__resp__get_coprocessor_fw_version__free_unpacked + (RpcRespGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_coprocessor_fw_version__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__set_dhcp_dns_status__init + (RpcReqSetDhcpDnsStatus *message) +{ + static const RpcReqSetDhcpDnsStatus init_value = RPC__REQ__SET_DHCP_DNS_STATUS__INIT; + *message = init_value; +} +size_t rpc__req__set_dhcp_dns_status__get_packed_size + (const RpcReqSetDhcpDnsStatus *message) +{ + assert(message->base.descriptor == &rpc__req__set_dhcp_dns_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__set_dhcp_dns_status__pack + (const RpcReqSetDhcpDnsStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__set_dhcp_dns_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__set_dhcp_dns_status__pack_to_buffer + (const RpcReqSetDhcpDnsStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__set_dhcp_dns_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSetDhcpDnsStatus * + rpc__req__set_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSetDhcpDnsStatus *) + protobuf_c_message_unpack (&rpc__req__set_dhcp_dns_status__descriptor, + allocator, len, data); +} +void rpc__req__set_dhcp_dns_status__free_unpacked + (RpcReqSetDhcpDnsStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__set_dhcp_dns_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__set_dhcp_dns_status__init + (RpcRespSetDhcpDnsStatus *message) +{ + static const RpcRespSetDhcpDnsStatus init_value = RPC__RESP__SET_DHCP_DNS_STATUS__INIT; + *message = init_value; +} +size_t rpc__resp__set_dhcp_dns_status__get_packed_size + (const RpcRespSetDhcpDnsStatus *message) +{ + assert(message->base.descriptor == &rpc__resp__set_dhcp_dns_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__set_dhcp_dns_status__pack + (const RpcRespSetDhcpDnsStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__set_dhcp_dns_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__set_dhcp_dns_status__pack_to_buffer + (const RpcRespSetDhcpDnsStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__set_dhcp_dns_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSetDhcpDnsStatus * + rpc__resp__set_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSetDhcpDnsStatus *) + protobuf_c_message_unpack (&rpc__resp__set_dhcp_dns_status__descriptor, + allocator, len, data); +} +void rpc__resp__set_dhcp_dns_status__free_unpacked + (RpcRespSetDhcpDnsStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__set_dhcp_dns_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__get_dhcp_dns_status__init + (RpcReqGetDhcpDnsStatus *message) +{ + static const RpcReqGetDhcpDnsStatus init_value = RPC__REQ__GET_DHCP_DNS_STATUS__INIT; + *message = init_value; +} +size_t rpc__req__get_dhcp_dns_status__get_packed_size + (const RpcReqGetDhcpDnsStatus *message) +{ + assert(message->base.descriptor == &rpc__req__get_dhcp_dns_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__get_dhcp_dns_status__pack + (const RpcReqGetDhcpDnsStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__get_dhcp_dns_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__get_dhcp_dns_status__pack_to_buffer + (const RpcReqGetDhcpDnsStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__get_dhcp_dns_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqGetDhcpDnsStatus * + rpc__req__get_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqGetDhcpDnsStatus *) + protobuf_c_message_unpack (&rpc__req__get_dhcp_dns_status__descriptor, + allocator, len, data); +} +void rpc__req__get_dhcp_dns_status__free_unpacked + (RpcReqGetDhcpDnsStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__get_dhcp_dns_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__get_dhcp_dns_status__init + (RpcRespGetDhcpDnsStatus *message) +{ + static const RpcRespGetDhcpDnsStatus init_value = RPC__RESP__GET_DHCP_DNS_STATUS__INIT; + *message = init_value; +} +size_t rpc__resp__get_dhcp_dns_status__get_packed_size + (const RpcRespGetDhcpDnsStatus *message) +{ + assert(message->base.descriptor == &rpc__resp__get_dhcp_dns_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__get_dhcp_dns_status__pack + (const RpcRespGetDhcpDnsStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__get_dhcp_dns_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__get_dhcp_dns_status__pack_to_buffer + (const RpcRespGetDhcpDnsStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__get_dhcp_dns_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespGetDhcpDnsStatus * + rpc__resp__get_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespGetDhcpDnsStatus *) + protobuf_c_message_unpack (&rpc__resp__get_dhcp_dns_status__descriptor, + allocator, len, data); +} +void rpc__resp__get_dhcp_dns_status__free_unpacked + (RpcRespGetDhcpDnsStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__get_dhcp_dns_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__supp_dpp_init__init + (RpcReqSuppDppInit *message) +{ + static const RpcReqSuppDppInit init_value = RPC__REQ__SUPP_DPP_INIT__INIT; + *message = init_value; +} +size_t rpc__req__supp_dpp_init__get_packed_size + (const RpcReqSuppDppInit *message) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_init__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__supp_dpp_init__pack + (const RpcReqSuppDppInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_init__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__supp_dpp_init__pack_to_buffer + (const RpcReqSuppDppInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_init__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSuppDppInit * + rpc__req__supp_dpp_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSuppDppInit *) + protobuf_c_message_unpack (&rpc__req__supp_dpp_init__descriptor, + allocator, len, data); +} +void rpc__req__supp_dpp_init__free_unpacked + (RpcReqSuppDppInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__supp_dpp_init__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__supp_dpp_init__init + (RpcRespSuppDppInit *message) +{ + static const RpcRespSuppDppInit init_value = RPC__RESP__SUPP_DPP_INIT__INIT; + *message = init_value; +} +size_t rpc__resp__supp_dpp_init__get_packed_size + (const RpcRespSuppDppInit *message) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_init__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__supp_dpp_init__pack + (const RpcRespSuppDppInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_init__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__supp_dpp_init__pack_to_buffer + (const RpcRespSuppDppInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_init__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSuppDppInit * + rpc__resp__supp_dpp_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSuppDppInit *) + protobuf_c_message_unpack (&rpc__resp__supp_dpp_init__descriptor, + allocator, len, data); +} +void rpc__resp__supp_dpp_init__free_unpacked + (RpcRespSuppDppInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__supp_dpp_init__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__supp_dpp_deinit__init + (RpcReqSuppDppDeinit *message) +{ + static const RpcReqSuppDppDeinit init_value = RPC__REQ__SUPP_DPP_DEINIT__INIT; + *message = init_value; +} +size_t rpc__req__supp_dpp_deinit__get_packed_size + (const RpcReqSuppDppDeinit *message) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_deinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__supp_dpp_deinit__pack + (const RpcReqSuppDppDeinit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_deinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__supp_dpp_deinit__pack_to_buffer + (const RpcReqSuppDppDeinit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_deinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSuppDppDeinit * + rpc__req__supp_dpp_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSuppDppDeinit *) + protobuf_c_message_unpack (&rpc__req__supp_dpp_deinit__descriptor, + allocator, len, data); +} +void rpc__req__supp_dpp_deinit__free_unpacked + (RpcReqSuppDppDeinit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__supp_dpp_deinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__supp_dpp_deinit__init + (RpcRespSuppDppDeinit *message) +{ + static const RpcRespSuppDppDeinit init_value = RPC__RESP__SUPP_DPP_DEINIT__INIT; + *message = init_value; +} +size_t rpc__resp__supp_dpp_deinit__get_packed_size + (const RpcRespSuppDppDeinit *message) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_deinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__supp_dpp_deinit__pack + (const RpcRespSuppDppDeinit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_deinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__supp_dpp_deinit__pack_to_buffer + (const RpcRespSuppDppDeinit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_deinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSuppDppDeinit * + rpc__resp__supp_dpp_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSuppDppDeinit *) + protobuf_c_message_unpack (&rpc__resp__supp_dpp_deinit__descriptor, + allocator, len, data); +} +void rpc__resp__supp_dpp_deinit__free_unpacked + (RpcRespSuppDppDeinit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__supp_dpp_deinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__supp_dpp_bootstrap_gen__init + (RpcReqSuppDppBootstrapGen *message) +{ + static const RpcReqSuppDppBootstrapGen init_value = RPC__REQ__SUPP_DPP_BOOTSTRAP_GEN__INIT; + *message = init_value; +} +size_t rpc__req__supp_dpp_bootstrap_gen__get_packed_size + (const RpcReqSuppDppBootstrapGen *message) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_bootstrap_gen__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__supp_dpp_bootstrap_gen__pack + (const RpcReqSuppDppBootstrapGen *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_bootstrap_gen__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__supp_dpp_bootstrap_gen__pack_to_buffer + (const RpcReqSuppDppBootstrapGen *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_bootstrap_gen__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSuppDppBootstrapGen * + rpc__req__supp_dpp_bootstrap_gen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSuppDppBootstrapGen *) + protobuf_c_message_unpack (&rpc__req__supp_dpp_bootstrap_gen__descriptor, + allocator, len, data); +} +void rpc__req__supp_dpp_bootstrap_gen__free_unpacked + (RpcReqSuppDppBootstrapGen *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__supp_dpp_bootstrap_gen__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__supp_dpp_bootstrap_gen__init + (RpcRespSuppDppBootstrapGen *message) +{ + static const RpcRespSuppDppBootstrapGen init_value = RPC__RESP__SUPP_DPP_BOOTSTRAP_GEN__INIT; + *message = init_value; +} +size_t rpc__resp__supp_dpp_bootstrap_gen__get_packed_size + (const RpcRespSuppDppBootstrapGen *message) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_bootstrap_gen__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__supp_dpp_bootstrap_gen__pack + (const RpcRespSuppDppBootstrapGen *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_bootstrap_gen__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__supp_dpp_bootstrap_gen__pack_to_buffer + (const RpcRespSuppDppBootstrapGen *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_bootstrap_gen__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSuppDppBootstrapGen * + rpc__resp__supp_dpp_bootstrap_gen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSuppDppBootstrapGen *) + protobuf_c_message_unpack (&rpc__resp__supp_dpp_bootstrap_gen__descriptor, + allocator, len, data); +} +void rpc__resp__supp_dpp_bootstrap_gen__free_unpacked + (RpcRespSuppDppBootstrapGen *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__supp_dpp_bootstrap_gen__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__supp_dpp_start_listen__init + (RpcReqSuppDppStartListen *message) +{ + static const RpcReqSuppDppStartListen init_value = RPC__REQ__SUPP_DPP_START_LISTEN__INIT; + *message = init_value; +} +size_t rpc__req__supp_dpp_start_listen__get_packed_size + (const RpcReqSuppDppStartListen *message) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_start_listen__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__supp_dpp_start_listen__pack + (const RpcReqSuppDppStartListen *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_start_listen__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__supp_dpp_start_listen__pack_to_buffer + (const RpcReqSuppDppStartListen *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_start_listen__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSuppDppStartListen * + rpc__req__supp_dpp_start_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSuppDppStartListen *) + protobuf_c_message_unpack (&rpc__req__supp_dpp_start_listen__descriptor, + allocator, len, data); +} +void rpc__req__supp_dpp_start_listen__free_unpacked + (RpcReqSuppDppStartListen *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__supp_dpp_start_listen__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__supp_dpp_start_listen__init + (RpcRespSuppDppStartListen *message) +{ + static const RpcRespSuppDppStartListen init_value = RPC__RESP__SUPP_DPP_START_LISTEN__INIT; + *message = init_value; +} +size_t rpc__resp__supp_dpp_start_listen__get_packed_size + (const RpcRespSuppDppStartListen *message) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_start_listen__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__supp_dpp_start_listen__pack + (const RpcRespSuppDppStartListen *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_start_listen__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__supp_dpp_start_listen__pack_to_buffer + (const RpcRespSuppDppStartListen *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_start_listen__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSuppDppStartListen * + rpc__resp__supp_dpp_start_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSuppDppStartListen *) + protobuf_c_message_unpack (&rpc__resp__supp_dpp_start_listen__descriptor, + allocator, len, data); +} +void rpc__resp__supp_dpp_start_listen__free_unpacked + (RpcRespSuppDppStartListen *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__supp_dpp_start_listen__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__supp_dpp_stop_listen__init + (RpcReqSuppDppStopListen *message) +{ + static const RpcReqSuppDppStopListen init_value = RPC__REQ__SUPP_DPP_STOP_LISTEN__INIT; + *message = init_value; +} +size_t rpc__req__supp_dpp_stop_listen__get_packed_size + (const RpcReqSuppDppStopListen *message) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_stop_listen__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__supp_dpp_stop_listen__pack + (const RpcReqSuppDppStopListen *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_stop_listen__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__supp_dpp_stop_listen__pack_to_buffer + (const RpcReqSuppDppStopListen *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__supp_dpp_stop_listen__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqSuppDppStopListen * + rpc__req__supp_dpp_stop_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqSuppDppStopListen *) + protobuf_c_message_unpack (&rpc__req__supp_dpp_stop_listen__descriptor, + allocator, len, data); +} +void rpc__req__supp_dpp_stop_listen__free_unpacked + (RpcReqSuppDppStopListen *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__supp_dpp_stop_listen__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__supp_dpp_stop_listen__init + (RpcRespSuppDppStopListen *message) +{ + static const RpcRespSuppDppStopListen init_value = RPC__RESP__SUPP_DPP_STOP_LISTEN__INIT; + *message = init_value; +} +size_t rpc__resp__supp_dpp_stop_listen__get_packed_size + (const RpcRespSuppDppStopListen *message) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_stop_listen__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__supp_dpp_stop_listen__pack + (const RpcRespSuppDppStopListen *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_stop_listen__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__supp_dpp_stop_listen__pack_to_buffer + (const RpcRespSuppDppStopListen *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__supp_dpp_stop_listen__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespSuppDppStopListen * + rpc__resp__supp_dpp_stop_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespSuppDppStopListen *) + protobuf_c_message_unpack (&rpc__resp__supp_dpp_stop_listen__descriptor, + allocator, len, data); +} +void rpc__resp__supp_dpp_stop_listen__free_unpacked + (RpcRespSuppDppStopListen *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__supp_dpp_stop_listen__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__iface_mac_addr_set_get__init + (RpcReqIfaceMacAddrSetGet *message) +{ + static const RpcReqIfaceMacAddrSetGet init_value = RPC__REQ__IFACE_MAC_ADDR_SET_GET__INIT; + *message = init_value; +} +size_t rpc__req__iface_mac_addr_set_get__get_packed_size + (const RpcReqIfaceMacAddrSetGet *message) +{ + assert(message->base.descriptor == &rpc__req__iface_mac_addr_set_get__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__iface_mac_addr_set_get__pack + (const RpcReqIfaceMacAddrSetGet *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__iface_mac_addr_set_get__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__iface_mac_addr_set_get__pack_to_buffer + (const RpcReqIfaceMacAddrSetGet *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__iface_mac_addr_set_get__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqIfaceMacAddrSetGet * + rpc__req__iface_mac_addr_set_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqIfaceMacAddrSetGet *) + protobuf_c_message_unpack (&rpc__req__iface_mac_addr_set_get__descriptor, + allocator, len, data); +} +void rpc__req__iface_mac_addr_set_get__free_unpacked + (RpcReqIfaceMacAddrSetGet *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__iface_mac_addr_set_get__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__iface_mac_addr_set_get__init + (RpcRespIfaceMacAddrSetGet *message) +{ + static const RpcRespIfaceMacAddrSetGet init_value = RPC__RESP__IFACE_MAC_ADDR_SET_GET__INIT; + *message = init_value; +} +size_t rpc__resp__iface_mac_addr_set_get__get_packed_size + (const RpcRespIfaceMacAddrSetGet *message) +{ + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_set_get__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__iface_mac_addr_set_get__pack + (const RpcRespIfaceMacAddrSetGet *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_set_get__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__iface_mac_addr_set_get__pack_to_buffer + (const RpcRespIfaceMacAddrSetGet *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_set_get__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespIfaceMacAddrSetGet * + rpc__resp__iface_mac_addr_set_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespIfaceMacAddrSetGet *) + protobuf_c_message_unpack (&rpc__resp__iface_mac_addr_set_get__descriptor, + allocator, len, data); +} +void rpc__resp__iface_mac_addr_set_get__free_unpacked + (RpcRespIfaceMacAddrSetGet *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_set_get__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__iface_mac_addr_len_get__init + (RpcReqIfaceMacAddrLenGet *message) +{ + static const RpcReqIfaceMacAddrLenGet init_value = RPC__REQ__IFACE_MAC_ADDR_LEN_GET__INIT; + *message = init_value; +} +size_t rpc__req__iface_mac_addr_len_get__get_packed_size + (const RpcReqIfaceMacAddrLenGet *message) +{ + assert(message->base.descriptor == &rpc__req__iface_mac_addr_len_get__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__iface_mac_addr_len_get__pack + (const RpcReqIfaceMacAddrLenGet *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__iface_mac_addr_len_get__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__iface_mac_addr_len_get__pack_to_buffer + (const RpcReqIfaceMacAddrLenGet *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__iface_mac_addr_len_get__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqIfaceMacAddrLenGet * + rpc__req__iface_mac_addr_len_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqIfaceMacAddrLenGet *) + protobuf_c_message_unpack (&rpc__req__iface_mac_addr_len_get__descriptor, + allocator, len, data); +} +void rpc__req__iface_mac_addr_len_get__free_unpacked + (RpcReqIfaceMacAddrLenGet *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__iface_mac_addr_len_get__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__iface_mac_addr_len_get__init + (RpcRespIfaceMacAddrLenGet *message) +{ + static const RpcRespIfaceMacAddrLenGet init_value = RPC__RESP__IFACE_MAC_ADDR_LEN_GET__INIT; + *message = init_value; +} +size_t rpc__resp__iface_mac_addr_len_get__get_packed_size + (const RpcRespIfaceMacAddrLenGet *message) +{ + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_len_get__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__iface_mac_addr_len_get__pack + (const RpcRespIfaceMacAddrLenGet *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_len_get__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__iface_mac_addr_len_get__pack_to_buffer + (const RpcRespIfaceMacAddrLenGet *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_len_get__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespIfaceMacAddrLenGet * + rpc__resp__iface_mac_addr_len_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespIfaceMacAddrLenGet *) + protobuf_c_message_unpack (&rpc__resp__iface_mac_addr_len_get__descriptor, + allocator, len, data); +} +void rpc__resp__iface_mac_addr_len_get__free_unpacked + (RpcRespIfaceMacAddrLenGet *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__iface_mac_addr_len_get__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__feature_control__init + (RpcReqFeatureControl *message) +{ + static const RpcReqFeatureControl init_value = RPC__REQ__FEATURE_CONTROL__INIT; + *message = init_value; +} +size_t rpc__req__feature_control__get_packed_size + (const RpcReqFeatureControl *message) +{ + assert(message->base.descriptor == &rpc__req__feature_control__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__feature_control__pack + (const RpcReqFeatureControl *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__feature_control__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__feature_control__pack_to_buffer + (const RpcReqFeatureControl *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__feature_control__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqFeatureControl * + rpc__req__feature_control__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqFeatureControl *) + protobuf_c_message_unpack (&rpc__req__feature_control__descriptor, + allocator, len, data); +} +void rpc__req__feature_control__free_unpacked + (RpcReqFeatureControl *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__feature_control__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__feature_control__init + (RpcRespFeatureControl *message) +{ + static const RpcRespFeatureControl init_value = RPC__RESP__FEATURE_CONTROL__INIT; + *message = init_value; +} +size_t rpc__resp__feature_control__get_packed_size + (const RpcRespFeatureControl *message) +{ + assert(message->base.descriptor == &rpc__resp__feature_control__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__feature_control__pack + (const RpcRespFeatureControl *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__feature_control__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__feature_control__pack_to_buffer + (const RpcRespFeatureControl *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__feature_control__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespFeatureControl * + rpc__resp__feature_control__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespFeatureControl *) + protobuf_c_message_unpack (&rpc__resp__feature_control__descriptor, + allocator, len, data); +} +void rpc__resp__feature_control__free_unpacked + (RpcRespFeatureControl *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__feature_control__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__wifi_event_no_args__init + (RpcEventWifiEventNoArgs *message) +{ + static const RpcEventWifiEventNoArgs init_value = RPC__EVENT__WIFI_EVENT_NO_ARGS__INIT; + *message = init_value; +} +size_t rpc__event__wifi_event_no_args__get_packed_size + (const RpcEventWifiEventNoArgs *message) +{ + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__wifi_event_no_args__pack + (const RpcEventWifiEventNoArgs *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__wifi_event_no_args__pack_to_buffer + (const RpcEventWifiEventNoArgs *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventWifiEventNoArgs * + rpc__event__wifi_event_no_args__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventWifiEventNoArgs *) + protobuf_c_message_unpack (&rpc__event__wifi_event_no_args__descriptor, + allocator, len, data); +} +void rpc__event__wifi_event_no_args__free_unpacked + (RpcEventWifiEventNoArgs *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__wifi_event_no_args__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__espinit__init + (RpcEventESPInit *message) +{ + static const RpcEventESPInit init_value = RPC__EVENT__ESPINIT__INIT; + *message = init_value; +} +size_t rpc__event__espinit__get_packed_size + (const RpcEventESPInit *message) +{ + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__espinit__pack + (const RpcEventESPInit *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__espinit__pack_to_buffer + (const RpcEventESPInit *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventESPInit * + rpc__event__espinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventESPInit *) + protobuf_c_message_unpack (&rpc__event__espinit__descriptor, + allocator, len, data); +} +void rpc__event__espinit__free_unpacked + (RpcEventESPInit *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__espinit__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__heartbeat__init + (RpcEventHeartbeat *message) +{ + static const RpcEventHeartbeat init_value = RPC__EVENT__HEARTBEAT__INIT; + *message = init_value; +} +size_t rpc__event__heartbeat__get_packed_size + (const RpcEventHeartbeat *message) +{ + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__heartbeat__pack + (const RpcEventHeartbeat *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__heartbeat__pack_to_buffer + (const RpcEventHeartbeat *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventHeartbeat * + rpc__event__heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventHeartbeat *) + protobuf_c_message_unpack (&rpc__event__heartbeat__descriptor, + allocator, len, data); +} +void rpc__event__heartbeat__free_unpacked + (RpcEventHeartbeat *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__heartbeat__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__ap__sta_disconnected__init + (RpcEventAPStaDisconnected *message) +{ + static const RpcEventAPStaDisconnected init_value = RPC__EVENT__AP__STA_DISCONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__ap__sta_disconnected__get_packed_size + (const RpcEventAPStaDisconnected *message) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__ap__sta_disconnected__pack + (const RpcEventAPStaDisconnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__ap__sta_disconnected__pack_to_buffer + (const RpcEventAPStaDisconnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventAPStaDisconnected * + rpc__event__ap__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventAPStaDisconnected *) + protobuf_c_message_unpack (&rpc__event__ap__sta_disconnected__descriptor, + allocator, len, data); +} +void rpc__event__ap__sta_disconnected__free_unpacked + (RpcEventAPStaDisconnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__ap__sta_disconnected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__ap__sta_connected__init + (RpcEventAPStaConnected *message) +{ + static const RpcEventAPStaConnected init_value = RPC__EVENT__AP__STA_CONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__ap__sta_connected__get_packed_size + (const RpcEventAPStaConnected *message) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__ap__sta_connected__pack + (const RpcEventAPStaConnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__ap__sta_connected__pack_to_buffer + (const RpcEventAPStaConnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventAPStaConnected * + rpc__event__ap__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventAPStaConnected *) + protobuf_c_message_unpack (&rpc__event__ap__sta_connected__descriptor, + allocator, len, data); +} +void rpc__event__ap__sta_connected__free_unpacked + (RpcEventAPStaConnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__ap__sta_connected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_scan_done__init + (RpcEventStaScanDone *message) +{ + static const RpcEventStaScanDone init_value = RPC__EVENT__STA_SCAN_DONE__INIT; + *message = init_value; +} +size_t rpc__event__sta_scan_done__get_packed_size + (const RpcEventStaScanDone *message) +{ + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_scan_done__pack + (const RpcEventStaScanDone *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_scan_done__pack_to_buffer + (const RpcEventStaScanDone *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaScanDone * + rpc__event__sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaScanDone *) + protobuf_c_message_unpack (&rpc__event__sta_scan_done__descriptor, + allocator, len, data); +} +void rpc__event__sta_scan_done__free_unpacked + (RpcEventStaScanDone *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_scan_done__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_connected__init + (RpcEventStaConnected *message) +{ + static const RpcEventStaConnected init_value = RPC__EVENT__STA_CONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__sta_connected__get_packed_size + (const RpcEventStaConnected *message) +{ + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_connected__pack + (const RpcEventStaConnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_connected__pack_to_buffer + (const RpcEventStaConnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaConnected * + rpc__event__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaConnected *) + protobuf_c_message_unpack (&rpc__event__sta_connected__descriptor, + allocator, len, data); +} +void rpc__event__sta_connected__free_unpacked + (RpcEventStaConnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_connected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_disconnected__init + (RpcEventStaDisconnected *message) +{ + static const RpcEventStaDisconnected init_value = RPC__EVENT__STA_DISCONNECTED__INIT; + *message = init_value; +} +size_t rpc__event__sta_disconnected__get_packed_size + (const RpcEventStaDisconnected *message) +{ + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_disconnected__pack + (const RpcEventStaDisconnected *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_disconnected__pack_to_buffer + (const RpcEventStaDisconnected *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaDisconnected * + rpc__event__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaDisconnected *) + protobuf_c_message_unpack (&rpc__event__sta_disconnected__descriptor, + allocator, len, data); +} +void rpc__event__sta_disconnected__free_unpacked + (RpcEventStaDisconnected *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_disconnected__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__dhcp_dns_status__init + (RpcEventDhcpDnsStatus *message) +{ + static const RpcEventDhcpDnsStatus init_value = RPC__EVENT__DHCP_DNS_STATUS__INIT; + *message = init_value; +} +size_t rpc__event__dhcp_dns_status__get_packed_size + (const RpcEventDhcpDnsStatus *message) +{ + assert(message->base.descriptor == &rpc__event__dhcp_dns_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__dhcp_dns_status__pack + (const RpcEventDhcpDnsStatus *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__dhcp_dns_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__dhcp_dns_status__pack_to_buffer + (const RpcEventDhcpDnsStatus *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__dhcp_dns_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventDhcpDnsStatus * + rpc__event__dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventDhcpDnsStatus *) + protobuf_c_message_unpack (&rpc__event__dhcp_dns_status__descriptor, + allocator, len, data); +} +void rpc__event__dhcp_dns_status__free_unpacked + (RpcEventDhcpDnsStatus *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__dhcp_dns_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_itwt_setup__init + (RpcEventStaItwtSetup *message) +{ + static const RpcEventStaItwtSetup init_value = RPC__EVENT__STA_ITWT_SETUP__INIT; + *message = init_value; +} +size_t rpc__event__sta_itwt_setup__get_packed_size + (const RpcEventStaItwtSetup *message) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_setup__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_itwt_setup__pack + (const RpcEventStaItwtSetup *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_setup__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_itwt_setup__pack_to_buffer + (const RpcEventStaItwtSetup *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_setup__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaItwtSetup * + rpc__event__sta_itwt_setup__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaItwtSetup *) + protobuf_c_message_unpack (&rpc__event__sta_itwt_setup__descriptor, + allocator, len, data); +} +void rpc__event__sta_itwt_setup__free_unpacked + (RpcEventStaItwtSetup *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_itwt_setup__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_itwt_teardown__init + (RpcEventStaItwtTeardown *message) +{ + static const RpcEventStaItwtTeardown init_value = RPC__EVENT__STA_ITWT_TEARDOWN__INIT; + *message = init_value; +} +size_t rpc__event__sta_itwt_teardown__get_packed_size + (const RpcEventStaItwtTeardown *message) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_teardown__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_itwt_teardown__pack + (const RpcEventStaItwtTeardown *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_teardown__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_itwt_teardown__pack_to_buffer + (const RpcEventStaItwtTeardown *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_teardown__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaItwtTeardown * + rpc__event__sta_itwt_teardown__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaItwtTeardown *) + protobuf_c_message_unpack (&rpc__event__sta_itwt_teardown__descriptor, + allocator, len, data); +} +void rpc__event__sta_itwt_teardown__free_unpacked + (RpcEventStaItwtTeardown *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_itwt_teardown__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_itwt_suspend__init + (RpcEventStaItwtSuspend *message) +{ + static const RpcEventStaItwtSuspend init_value = RPC__EVENT__STA_ITWT_SUSPEND__INIT; + *message = init_value; +} +size_t rpc__event__sta_itwt_suspend__get_packed_size + (const RpcEventStaItwtSuspend *message) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_suspend__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_itwt_suspend__pack + (const RpcEventStaItwtSuspend *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_suspend__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_itwt_suspend__pack_to_buffer + (const RpcEventStaItwtSuspend *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_suspend__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaItwtSuspend * + rpc__event__sta_itwt_suspend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaItwtSuspend *) + protobuf_c_message_unpack (&rpc__event__sta_itwt_suspend__descriptor, + allocator, len, data); +} +void rpc__event__sta_itwt_suspend__free_unpacked + (RpcEventStaItwtSuspend *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_itwt_suspend__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__sta_itwt_probe__init + (RpcEventStaItwtProbe *message) +{ + static const RpcEventStaItwtProbe init_value = RPC__EVENT__STA_ITWT_PROBE__INIT; + *message = init_value; +} +size_t rpc__event__sta_itwt_probe__get_packed_size + (const RpcEventStaItwtProbe *message) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_probe__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__sta_itwt_probe__pack + (const RpcEventStaItwtProbe *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_probe__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__sta_itwt_probe__pack_to_buffer + (const RpcEventStaItwtProbe *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__sta_itwt_probe__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventStaItwtProbe * + rpc__event__sta_itwt_probe__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventStaItwtProbe *) + protobuf_c_message_unpack (&rpc__event__sta_itwt_probe__descriptor, + allocator, len, data); +} +void rpc__event__sta_itwt_probe__free_unpacked + (RpcEventStaItwtProbe *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__sta_itwt_probe__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_enterprise_enable__init + (RpcReqWifiStaEnterpriseEnable *message) +{ + static const RpcReqWifiStaEnterpriseEnable init_value = RPC__REQ__WIFI_STA_ENTERPRISE_ENABLE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_enterprise_enable__get_packed_size + (const RpcReqWifiStaEnterpriseEnable *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_enable__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_enterprise_enable__pack + (const RpcReqWifiStaEnterpriseEnable *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_enable__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_enterprise_enable__pack_to_buffer + (const RpcReqWifiStaEnterpriseEnable *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_enable__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaEnterpriseEnable * + rpc__req__wifi_sta_enterprise_enable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaEnterpriseEnable *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_enterprise_enable__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_enterprise_enable__free_unpacked + (RpcReqWifiStaEnterpriseEnable *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_enable__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_enterprise_enable__init + (RpcRespWifiStaEnterpriseEnable *message) +{ + static const RpcRespWifiStaEnterpriseEnable init_value = RPC__RESP__WIFI_STA_ENTERPRISE_ENABLE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_enterprise_enable__get_packed_size + (const RpcRespWifiStaEnterpriseEnable *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_enable__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_enterprise_enable__pack + (const RpcRespWifiStaEnterpriseEnable *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_enable__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_enterprise_enable__pack_to_buffer + (const RpcRespWifiStaEnterpriseEnable *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_enable__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaEnterpriseEnable * + rpc__resp__wifi_sta_enterprise_enable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaEnterpriseEnable *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_enterprise_enable__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_enterprise_enable__free_unpacked + (RpcRespWifiStaEnterpriseEnable *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_enable__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_sta_enterprise_disable__init + (RpcReqWifiStaEnterpriseDisable *message) +{ + static const RpcReqWifiStaEnterpriseDisable init_value = RPC__REQ__WIFI_STA_ENTERPRISE_DISABLE__INIT; + *message = init_value; +} +size_t rpc__req__wifi_sta_enterprise_disable__get_packed_size + (const RpcReqWifiStaEnterpriseDisable *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_disable__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_sta_enterprise_disable__pack + (const RpcReqWifiStaEnterpriseDisable *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_disable__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_sta_enterprise_disable__pack_to_buffer + (const RpcReqWifiStaEnterpriseDisable *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_disable__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiStaEnterpriseDisable * + rpc__req__wifi_sta_enterprise_disable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiStaEnterpriseDisable *) + protobuf_c_message_unpack (&rpc__req__wifi_sta_enterprise_disable__descriptor, + allocator, len, data); +} +void rpc__req__wifi_sta_enterprise_disable__free_unpacked + (RpcReqWifiStaEnterpriseDisable *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_sta_enterprise_disable__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_sta_enterprise_disable__init + (RpcRespWifiStaEnterpriseDisable *message) +{ + static const RpcRespWifiStaEnterpriseDisable init_value = RPC__RESP__WIFI_STA_ENTERPRISE_DISABLE__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_sta_enterprise_disable__get_packed_size + (const RpcRespWifiStaEnterpriseDisable *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_disable__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_sta_enterprise_disable__pack + (const RpcRespWifiStaEnterpriseDisable *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_disable__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_sta_enterprise_disable__pack_to_buffer + (const RpcRespWifiStaEnterpriseDisable *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_disable__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiStaEnterpriseDisable * + rpc__resp__wifi_sta_enterprise_disable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiStaEnterpriseDisable *) + protobuf_c_message_unpack (&rpc__resp__wifi_sta_enterprise_disable__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_sta_enterprise_disable__free_unpacked + (RpcRespWifiStaEnterpriseDisable *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_sta_enterprise_disable__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_identity__init + (RpcReqEapSetIdentity *message) +{ + static const RpcReqEapSetIdentity init_value = RPC__REQ__EAP_SET_IDENTITY__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_identity__get_packed_size + (const RpcReqEapSetIdentity *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_identity__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_identity__pack + (const RpcReqEapSetIdentity *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_identity__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_identity__pack_to_buffer + (const RpcReqEapSetIdentity *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_identity__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetIdentity * + rpc__req__eap_set_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetIdentity *) + protobuf_c_message_unpack (&rpc__req__eap_set_identity__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_identity__free_unpacked + (RpcReqEapSetIdentity *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_identity__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_identity__init + (RpcRespEapSetIdentity *message) +{ + static const RpcRespEapSetIdentity init_value = RPC__RESP__EAP_SET_IDENTITY__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_identity__get_packed_size + (const RpcRespEapSetIdentity *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_identity__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_identity__pack + (const RpcRespEapSetIdentity *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_identity__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_identity__pack_to_buffer + (const RpcRespEapSetIdentity *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_identity__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetIdentity * + rpc__resp__eap_set_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetIdentity *) + protobuf_c_message_unpack (&rpc__resp__eap_set_identity__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_identity__free_unpacked + (RpcRespEapSetIdentity *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_identity__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_clear_identity__init + (RpcReqEapClearIdentity *message) +{ + static const RpcReqEapClearIdentity init_value = RPC__REQ__EAP_CLEAR_IDENTITY__INIT; + *message = init_value; +} +size_t rpc__req__eap_clear_identity__get_packed_size + (const RpcReqEapClearIdentity *message) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_identity__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_clear_identity__pack + (const RpcReqEapClearIdentity *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_identity__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_clear_identity__pack_to_buffer + (const RpcReqEapClearIdentity *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_identity__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapClearIdentity * + rpc__req__eap_clear_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapClearIdentity *) + protobuf_c_message_unpack (&rpc__req__eap_clear_identity__descriptor, + allocator, len, data); +} +void rpc__req__eap_clear_identity__free_unpacked + (RpcReqEapClearIdentity *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_clear_identity__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_clear_identity__init + (RpcRespEapClearIdentity *message) +{ + static const RpcRespEapClearIdentity init_value = RPC__RESP__EAP_CLEAR_IDENTITY__INIT; + *message = init_value; +} +size_t rpc__resp__eap_clear_identity__get_packed_size + (const RpcRespEapClearIdentity *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_identity__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_clear_identity__pack + (const RpcRespEapClearIdentity *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_identity__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_clear_identity__pack_to_buffer + (const RpcRespEapClearIdentity *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_identity__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapClearIdentity * + rpc__resp__eap_clear_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapClearIdentity *) + protobuf_c_message_unpack (&rpc__resp__eap_clear_identity__descriptor, + allocator, len, data); +} +void rpc__resp__eap_clear_identity__free_unpacked + (RpcRespEapClearIdentity *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_clear_identity__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_username__init + (RpcReqEapSetUsername *message) +{ + static const RpcReqEapSetUsername init_value = RPC__REQ__EAP_SET_USERNAME__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_username__get_packed_size + (const RpcReqEapSetUsername *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_username__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_username__pack + (const RpcReqEapSetUsername *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_username__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_username__pack_to_buffer + (const RpcReqEapSetUsername *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_username__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetUsername * + rpc__req__eap_set_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetUsername *) + protobuf_c_message_unpack (&rpc__req__eap_set_username__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_username__free_unpacked + (RpcReqEapSetUsername *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_username__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_username__init + (RpcRespEapSetUsername *message) +{ + static const RpcRespEapSetUsername init_value = RPC__RESP__EAP_SET_USERNAME__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_username__get_packed_size + (const RpcRespEapSetUsername *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_username__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_username__pack + (const RpcRespEapSetUsername *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_username__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_username__pack_to_buffer + (const RpcRespEapSetUsername *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_username__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetUsername * + rpc__resp__eap_set_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetUsername *) + protobuf_c_message_unpack (&rpc__resp__eap_set_username__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_username__free_unpacked + (RpcRespEapSetUsername *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_username__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_clear_username__init + (RpcReqEapClearUsername *message) +{ + static const RpcReqEapClearUsername init_value = RPC__REQ__EAP_CLEAR_USERNAME__INIT; + *message = init_value; +} +size_t rpc__req__eap_clear_username__get_packed_size + (const RpcReqEapClearUsername *message) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_username__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_clear_username__pack + (const RpcReqEapClearUsername *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_username__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_clear_username__pack_to_buffer + (const RpcReqEapClearUsername *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_username__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapClearUsername * + rpc__req__eap_clear_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapClearUsername *) + protobuf_c_message_unpack (&rpc__req__eap_clear_username__descriptor, + allocator, len, data); +} +void rpc__req__eap_clear_username__free_unpacked + (RpcReqEapClearUsername *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_clear_username__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_clear_username__init + (RpcRespEapClearUsername *message) +{ + static const RpcRespEapClearUsername init_value = RPC__RESP__EAP_CLEAR_USERNAME__INIT; + *message = init_value; +} +size_t rpc__resp__eap_clear_username__get_packed_size + (const RpcRespEapClearUsername *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_username__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_clear_username__pack + (const RpcRespEapClearUsername *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_username__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_clear_username__pack_to_buffer + (const RpcRespEapClearUsername *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_username__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapClearUsername * + rpc__resp__eap_clear_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapClearUsername *) + protobuf_c_message_unpack (&rpc__resp__eap_clear_username__descriptor, + allocator, len, data); +} +void rpc__resp__eap_clear_username__free_unpacked + (RpcRespEapClearUsername *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_clear_username__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_password__init + (RpcReqEapSetPassword *message) +{ + static const RpcReqEapSetPassword init_value = RPC__REQ__EAP_SET_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_password__get_packed_size + (const RpcReqEapSetPassword *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_password__pack + (const RpcReqEapSetPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_password__pack_to_buffer + (const RpcReqEapSetPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetPassword * + rpc__req__eap_set_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetPassword *) + protobuf_c_message_unpack (&rpc__req__eap_set_password__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_password__free_unpacked + (RpcReqEapSetPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_password__init + (RpcRespEapSetPassword *message) +{ + static const RpcRespEapSetPassword init_value = RPC__RESP__EAP_SET_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_password__get_packed_size + (const RpcRespEapSetPassword *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_password__pack + (const RpcRespEapSetPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_password__pack_to_buffer + (const RpcRespEapSetPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetPassword * + rpc__resp__eap_set_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetPassword *) + protobuf_c_message_unpack (&rpc__resp__eap_set_password__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_password__free_unpacked + (RpcRespEapSetPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_clear_password__init + (RpcReqEapClearPassword *message) +{ + static const RpcReqEapClearPassword init_value = RPC__REQ__EAP_CLEAR_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__req__eap_clear_password__get_packed_size + (const RpcReqEapClearPassword *message) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_clear_password__pack + (const RpcReqEapClearPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_clear_password__pack_to_buffer + (const RpcReqEapClearPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapClearPassword * + rpc__req__eap_clear_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapClearPassword *) + protobuf_c_message_unpack (&rpc__req__eap_clear_password__descriptor, + allocator, len, data); +} +void rpc__req__eap_clear_password__free_unpacked + (RpcReqEapClearPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_clear_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_clear_password__init + (RpcRespEapClearPassword *message) +{ + static const RpcRespEapClearPassword init_value = RPC__RESP__EAP_CLEAR_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__resp__eap_clear_password__get_packed_size + (const RpcRespEapClearPassword *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_clear_password__pack + (const RpcRespEapClearPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_clear_password__pack_to_buffer + (const RpcRespEapClearPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapClearPassword * + rpc__resp__eap_clear_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapClearPassword *) + protobuf_c_message_unpack (&rpc__resp__eap_clear_password__descriptor, + allocator, len, data); +} +void rpc__resp__eap_clear_password__free_unpacked + (RpcRespEapClearPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_clear_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_new_password__init + (RpcReqEapSetNewPassword *message) +{ + static const RpcReqEapSetNewPassword init_value = RPC__REQ__EAP_SET_NEW_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_new_password__get_packed_size + (const RpcReqEapSetNewPassword *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_new_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_new_password__pack + (const RpcReqEapSetNewPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_new_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_new_password__pack_to_buffer + (const RpcReqEapSetNewPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_new_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetNewPassword * + rpc__req__eap_set_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetNewPassword *) + protobuf_c_message_unpack (&rpc__req__eap_set_new_password__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_new_password__free_unpacked + (RpcReqEapSetNewPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_new_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_new_password__init + (RpcRespEapSetNewPassword *message) +{ + static const RpcRespEapSetNewPassword init_value = RPC__RESP__EAP_SET_NEW_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_new_password__get_packed_size + (const RpcRespEapSetNewPassword *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_new_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_new_password__pack + (const RpcRespEapSetNewPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_new_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_new_password__pack_to_buffer + (const RpcRespEapSetNewPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_new_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetNewPassword * + rpc__resp__eap_set_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetNewPassword *) + protobuf_c_message_unpack (&rpc__resp__eap_set_new_password__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_new_password__free_unpacked + (RpcRespEapSetNewPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_new_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_clear_new_password__init + (RpcReqEapClearNewPassword *message) +{ + static const RpcReqEapClearNewPassword init_value = RPC__REQ__EAP_CLEAR_NEW_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__req__eap_clear_new_password__get_packed_size + (const RpcReqEapClearNewPassword *message) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_new_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_clear_new_password__pack + (const RpcReqEapClearNewPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_new_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_clear_new_password__pack_to_buffer + (const RpcReqEapClearNewPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_new_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapClearNewPassword * + rpc__req__eap_clear_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapClearNewPassword *) + protobuf_c_message_unpack (&rpc__req__eap_clear_new_password__descriptor, + allocator, len, data); +} +void rpc__req__eap_clear_new_password__free_unpacked + (RpcReqEapClearNewPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_clear_new_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_clear_new_password__init + (RpcRespEapClearNewPassword *message) +{ + static const RpcRespEapClearNewPassword init_value = RPC__RESP__EAP_CLEAR_NEW_PASSWORD__INIT; + *message = init_value; +} +size_t rpc__resp__eap_clear_new_password__get_packed_size + (const RpcRespEapClearNewPassword *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_new_password__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_clear_new_password__pack + (const RpcRespEapClearNewPassword *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_new_password__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_clear_new_password__pack_to_buffer + (const RpcRespEapClearNewPassword *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_new_password__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapClearNewPassword * + rpc__resp__eap_clear_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapClearNewPassword *) + protobuf_c_message_unpack (&rpc__resp__eap_clear_new_password__descriptor, + allocator, len, data); +} +void rpc__resp__eap_clear_new_password__free_unpacked + (RpcRespEapClearNewPassword *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_clear_new_password__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_ca_cert__init + (RpcReqEapSetCaCert *message) +{ + static const RpcReqEapSetCaCert init_value = RPC__REQ__EAP_SET_CA_CERT__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_ca_cert__get_packed_size + (const RpcReqEapSetCaCert *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_ca_cert__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_ca_cert__pack + (const RpcReqEapSetCaCert *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_ca_cert__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_ca_cert__pack_to_buffer + (const RpcReqEapSetCaCert *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_ca_cert__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetCaCert * + rpc__req__eap_set_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetCaCert *) + protobuf_c_message_unpack (&rpc__req__eap_set_ca_cert__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_ca_cert__free_unpacked + (RpcReqEapSetCaCert *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_ca_cert__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_ca_cert__init + (RpcRespEapSetCaCert *message) +{ + static const RpcRespEapSetCaCert init_value = RPC__RESP__EAP_SET_CA_CERT__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_ca_cert__get_packed_size + (const RpcRespEapSetCaCert *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_ca_cert__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_ca_cert__pack + (const RpcRespEapSetCaCert *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_ca_cert__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_ca_cert__pack_to_buffer + (const RpcRespEapSetCaCert *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_ca_cert__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetCaCert * + rpc__resp__eap_set_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetCaCert *) + protobuf_c_message_unpack (&rpc__resp__eap_set_ca_cert__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_ca_cert__free_unpacked + (RpcRespEapSetCaCert *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_ca_cert__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_clear_ca_cert__init + (RpcReqEapClearCaCert *message) +{ + static const RpcReqEapClearCaCert init_value = RPC__REQ__EAP_CLEAR_CA_CERT__INIT; + *message = init_value; +} +size_t rpc__req__eap_clear_ca_cert__get_packed_size + (const RpcReqEapClearCaCert *message) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_ca_cert__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_clear_ca_cert__pack + (const RpcReqEapClearCaCert *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_ca_cert__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_clear_ca_cert__pack_to_buffer + (const RpcReqEapClearCaCert *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_ca_cert__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapClearCaCert * + rpc__req__eap_clear_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapClearCaCert *) + protobuf_c_message_unpack (&rpc__req__eap_clear_ca_cert__descriptor, + allocator, len, data); +} +void rpc__req__eap_clear_ca_cert__free_unpacked + (RpcReqEapClearCaCert *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_clear_ca_cert__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_clear_ca_cert__init + (RpcRespEapClearCaCert *message) +{ + static const RpcRespEapClearCaCert init_value = RPC__RESP__EAP_CLEAR_CA_CERT__INIT; + *message = init_value; +} +size_t rpc__resp__eap_clear_ca_cert__get_packed_size + (const RpcRespEapClearCaCert *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_ca_cert__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_clear_ca_cert__pack + (const RpcRespEapClearCaCert *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_ca_cert__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_clear_ca_cert__pack_to_buffer + (const RpcRespEapClearCaCert *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_ca_cert__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapClearCaCert * + rpc__resp__eap_clear_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapClearCaCert *) + protobuf_c_message_unpack (&rpc__resp__eap_clear_ca_cert__descriptor, + allocator, len, data); +} +void rpc__resp__eap_clear_ca_cert__free_unpacked + (RpcRespEapClearCaCert *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_clear_ca_cert__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_certificate_and_key__init + (RpcReqEapSetCertificateAndKey *message) +{ + static const RpcReqEapSetCertificateAndKey init_value = RPC__REQ__EAP_SET_CERTIFICATE_AND_KEY__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_certificate_and_key__get_packed_size + (const RpcReqEapSetCertificateAndKey *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_certificate_and_key__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_certificate_and_key__pack + (const RpcReqEapSetCertificateAndKey *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_certificate_and_key__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_certificate_and_key__pack_to_buffer + (const RpcReqEapSetCertificateAndKey *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_certificate_and_key__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetCertificateAndKey * + rpc__req__eap_set_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetCertificateAndKey *) + protobuf_c_message_unpack (&rpc__req__eap_set_certificate_and_key__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_certificate_and_key__free_unpacked + (RpcReqEapSetCertificateAndKey *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_certificate_and_key__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_certificate_and_key__init + (RpcRespEapSetCertificateAndKey *message) +{ + static const RpcRespEapSetCertificateAndKey init_value = RPC__RESP__EAP_SET_CERTIFICATE_AND_KEY__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_certificate_and_key__get_packed_size + (const RpcRespEapSetCertificateAndKey *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_certificate_and_key__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_certificate_and_key__pack + (const RpcRespEapSetCertificateAndKey *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_certificate_and_key__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_certificate_and_key__pack_to_buffer + (const RpcRespEapSetCertificateAndKey *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_certificate_and_key__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetCertificateAndKey * + rpc__resp__eap_set_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetCertificateAndKey *) + protobuf_c_message_unpack (&rpc__resp__eap_set_certificate_and_key__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_certificate_and_key__free_unpacked + (RpcRespEapSetCertificateAndKey *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_certificate_and_key__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_clear_certificate_and_key__init + (RpcReqEapClearCertificateAndKey *message) +{ + static const RpcReqEapClearCertificateAndKey init_value = RPC__REQ__EAP_CLEAR_CERTIFICATE_AND_KEY__INIT; + *message = init_value; +} +size_t rpc__req__eap_clear_certificate_and_key__get_packed_size + (const RpcReqEapClearCertificateAndKey *message) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_certificate_and_key__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_clear_certificate_and_key__pack + (const RpcReqEapClearCertificateAndKey *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_certificate_and_key__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_clear_certificate_and_key__pack_to_buffer + (const RpcReqEapClearCertificateAndKey *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_clear_certificate_and_key__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapClearCertificateAndKey * + rpc__req__eap_clear_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapClearCertificateAndKey *) + protobuf_c_message_unpack (&rpc__req__eap_clear_certificate_and_key__descriptor, + allocator, len, data); +} +void rpc__req__eap_clear_certificate_and_key__free_unpacked + (RpcReqEapClearCertificateAndKey *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_clear_certificate_and_key__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_clear_certificate_and_key__init + (RpcRespEapClearCertificateAndKey *message) +{ + static const RpcRespEapClearCertificateAndKey init_value = RPC__RESP__EAP_CLEAR_CERTIFICATE_AND_KEY__INIT; + *message = init_value; +} +size_t rpc__resp__eap_clear_certificate_and_key__get_packed_size + (const RpcRespEapClearCertificateAndKey *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_certificate_and_key__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_clear_certificate_and_key__pack + (const RpcRespEapClearCertificateAndKey *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_certificate_and_key__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_clear_certificate_and_key__pack_to_buffer + (const RpcRespEapClearCertificateAndKey *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_clear_certificate_and_key__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapClearCertificateAndKey * + rpc__resp__eap_clear_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapClearCertificateAndKey *) + protobuf_c_message_unpack (&rpc__resp__eap_clear_certificate_and_key__descriptor, + allocator, len, data); +} +void rpc__resp__eap_clear_certificate_and_key__free_unpacked + (RpcRespEapClearCertificateAndKey *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_clear_certificate_and_key__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_disable_time_check__init + (RpcReqEapSetDisableTimeCheck *message) +{ + static const RpcReqEapSetDisableTimeCheck init_value = RPC__REQ__EAP_SET_DISABLE_TIME_CHECK__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_disable_time_check__get_packed_size + (const RpcReqEapSetDisableTimeCheck *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_disable_time_check__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_disable_time_check__pack + (const RpcReqEapSetDisableTimeCheck *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_disable_time_check__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_disable_time_check__pack_to_buffer + (const RpcReqEapSetDisableTimeCheck *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_disable_time_check__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetDisableTimeCheck * + rpc__req__eap_set_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetDisableTimeCheck *) + protobuf_c_message_unpack (&rpc__req__eap_set_disable_time_check__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_disable_time_check__free_unpacked + (RpcReqEapSetDisableTimeCheck *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_disable_time_check__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_disable_time_check__init + (RpcRespEapSetDisableTimeCheck *message) +{ + static const RpcRespEapSetDisableTimeCheck init_value = RPC__RESP__EAP_SET_DISABLE_TIME_CHECK__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_disable_time_check__get_packed_size + (const RpcRespEapSetDisableTimeCheck *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_disable_time_check__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_disable_time_check__pack + (const RpcRespEapSetDisableTimeCheck *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_disable_time_check__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_disable_time_check__pack_to_buffer + (const RpcRespEapSetDisableTimeCheck *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_disable_time_check__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetDisableTimeCheck * + rpc__resp__eap_set_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetDisableTimeCheck *) + protobuf_c_message_unpack (&rpc__resp__eap_set_disable_time_check__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_disable_time_check__free_unpacked + (RpcRespEapSetDisableTimeCheck *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_disable_time_check__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_get_disable_time_check__init + (RpcReqEapGetDisableTimeCheck *message) +{ + static const RpcReqEapGetDisableTimeCheck init_value = RPC__REQ__EAP_GET_DISABLE_TIME_CHECK__INIT; + *message = init_value; +} +size_t rpc__req__eap_get_disable_time_check__get_packed_size + (const RpcReqEapGetDisableTimeCheck *message) +{ + assert(message->base.descriptor == &rpc__req__eap_get_disable_time_check__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_get_disable_time_check__pack + (const RpcReqEapGetDisableTimeCheck *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_get_disable_time_check__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_get_disable_time_check__pack_to_buffer + (const RpcReqEapGetDisableTimeCheck *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_get_disable_time_check__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapGetDisableTimeCheck * + rpc__req__eap_get_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapGetDisableTimeCheck *) + protobuf_c_message_unpack (&rpc__req__eap_get_disable_time_check__descriptor, + allocator, len, data); +} +void rpc__req__eap_get_disable_time_check__free_unpacked + (RpcReqEapGetDisableTimeCheck *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_get_disable_time_check__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_get_disable_time_check__init + (RpcRespEapGetDisableTimeCheck *message) +{ + static const RpcRespEapGetDisableTimeCheck init_value = RPC__RESP__EAP_GET_DISABLE_TIME_CHECK__INIT; + *message = init_value; +} +size_t rpc__resp__eap_get_disable_time_check__get_packed_size + (const RpcRespEapGetDisableTimeCheck *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_get_disable_time_check__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_get_disable_time_check__pack + (const RpcRespEapGetDisableTimeCheck *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_get_disable_time_check__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_get_disable_time_check__pack_to_buffer + (const RpcRespEapGetDisableTimeCheck *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_get_disable_time_check__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapGetDisableTimeCheck * + rpc__resp__eap_get_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapGetDisableTimeCheck *) + protobuf_c_message_unpack (&rpc__resp__eap_get_disable_time_check__descriptor, + allocator, len, data); +} +void rpc__resp__eap_get_disable_time_check__free_unpacked + (RpcRespEapGetDisableTimeCheck *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_get_disable_time_check__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_ttls_phase2_method__init + (RpcReqEapSetTtlsPhase2Method *message) +{ + static const RpcReqEapSetTtlsPhase2Method init_value = RPC__REQ__EAP_SET_TTLS_PHASE2_METHOD__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_ttls_phase2_method__get_packed_size + (const RpcReqEapSetTtlsPhase2Method *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_ttls_phase2_method__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_ttls_phase2_method__pack + (const RpcReqEapSetTtlsPhase2Method *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_ttls_phase2_method__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_ttls_phase2_method__pack_to_buffer + (const RpcReqEapSetTtlsPhase2Method *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_ttls_phase2_method__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetTtlsPhase2Method * + rpc__req__eap_set_ttls_phase2_method__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetTtlsPhase2Method *) + protobuf_c_message_unpack (&rpc__req__eap_set_ttls_phase2_method__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_ttls_phase2_method__free_unpacked + (RpcReqEapSetTtlsPhase2Method *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_ttls_phase2_method__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_ttls_phase2_method__init + (RpcRespEapSetTtlsPhase2Method *message) +{ + static const RpcRespEapSetTtlsPhase2Method init_value = RPC__RESP__EAP_SET_TTLS_PHASE2_METHOD__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_ttls_phase2_method__get_packed_size + (const RpcRespEapSetTtlsPhase2Method *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_ttls_phase2_method__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_ttls_phase2_method__pack + (const RpcRespEapSetTtlsPhase2Method *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_ttls_phase2_method__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_ttls_phase2_method__pack_to_buffer + (const RpcRespEapSetTtlsPhase2Method *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_ttls_phase2_method__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetTtlsPhase2Method * + rpc__resp__eap_set_ttls_phase2_method__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetTtlsPhase2Method *) + protobuf_c_message_unpack (&rpc__resp__eap_set_ttls_phase2_method__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_ttls_phase2_method__free_unpacked + (RpcRespEapSetTtlsPhase2Method *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_ttls_phase2_method__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_suiteb192bit_certification__init + (RpcReqEapSetSuiteb192bitCertification *message) +{ + static const RpcReqEapSetSuiteb192bitCertification init_value = RPC__REQ__EAP_SET_SUITEB192BIT_CERTIFICATION__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_suiteb192bit_certification__get_packed_size + (const RpcReqEapSetSuiteb192bitCertification *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_suiteb192bit_certification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_suiteb192bit_certification__pack + (const RpcReqEapSetSuiteb192bitCertification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_suiteb192bit_certification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_suiteb192bit_certification__pack_to_buffer + (const RpcReqEapSetSuiteb192bitCertification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_suiteb192bit_certification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetSuiteb192bitCertification * + rpc__req__eap_set_suiteb192bit_certification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetSuiteb192bitCertification *) + protobuf_c_message_unpack (&rpc__req__eap_set_suiteb192bit_certification__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_suiteb192bit_certification__free_unpacked + (RpcReqEapSetSuiteb192bitCertification *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_suiteb192bit_certification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_suiteb192bit_certification__init + (RpcRespEapSetSuiteb192bitCertification *message) +{ + static const RpcRespEapSetSuiteb192bitCertification init_value = RPC__RESP__EAP_SET_SUITEB192BIT_CERTIFICATION__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_suiteb192bit_certification__get_packed_size + (const RpcRespEapSetSuiteb192bitCertification *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_suiteb192bit_certification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_suiteb192bit_certification__pack + (const RpcRespEapSetSuiteb192bitCertification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_suiteb192bit_certification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_suiteb192bit_certification__pack_to_buffer + (const RpcRespEapSetSuiteb192bitCertification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_suiteb192bit_certification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetSuiteb192bitCertification * + rpc__resp__eap_set_suiteb192bit_certification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetSuiteb192bitCertification *) + protobuf_c_message_unpack (&rpc__resp__eap_set_suiteb192bit_certification__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_suiteb192bit_certification__free_unpacked + (RpcRespEapSetSuiteb192bitCertification *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_suiteb192bit_certification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_pac_file__init + (RpcReqEapSetPacFile *message) +{ + static const RpcReqEapSetPacFile init_value = RPC__REQ__EAP_SET_PAC_FILE__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_pac_file__get_packed_size + (const RpcReqEapSetPacFile *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_pac_file__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_pac_file__pack + (const RpcReqEapSetPacFile *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_pac_file__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_pac_file__pack_to_buffer + (const RpcReqEapSetPacFile *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_pac_file__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetPacFile * + rpc__req__eap_set_pac_file__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetPacFile *) + protobuf_c_message_unpack (&rpc__req__eap_set_pac_file__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_pac_file__free_unpacked + (RpcReqEapSetPacFile *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_pac_file__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_pac_file__init + (RpcRespEapSetPacFile *message) +{ + static const RpcRespEapSetPacFile init_value = RPC__RESP__EAP_SET_PAC_FILE__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_pac_file__get_packed_size + (const RpcRespEapSetPacFile *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_pac_file__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_pac_file__pack + (const RpcRespEapSetPacFile *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_pac_file__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_pac_file__pack_to_buffer + (const RpcRespEapSetPacFile *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_pac_file__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetPacFile * + rpc__resp__eap_set_pac_file__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetPacFile *) + protobuf_c_message_unpack (&rpc__resp__eap_set_pac_file__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_pac_file__free_unpacked + (RpcRespEapSetPacFile *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_pac_file__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_fast_params__init + (RpcReqEapSetFastParams *message) +{ + static const RpcReqEapSetFastParams init_value = RPC__REQ__EAP_SET_FAST_PARAMS__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_fast_params__get_packed_size + (const RpcReqEapSetFastParams *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_fast_params__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_fast_params__pack + (const RpcReqEapSetFastParams *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_fast_params__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_fast_params__pack_to_buffer + (const RpcReqEapSetFastParams *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_fast_params__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetFastParams * + rpc__req__eap_set_fast_params__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetFastParams *) + protobuf_c_message_unpack (&rpc__req__eap_set_fast_params__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_fast_params__free_unpacked + (RpcReqEapSetFastParams *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_fast_params__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_fast_params__init + (RpcRespEapSetFastParams *message) +{ + static const RpcRespEapSetFastParams init_value = RPC__RESP__EAP_SET_FAST_PARAMS__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_fast_params__get_packed_size + (const RpcRespEapSetFastParams *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_fast_params__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_fast_params__pack + (const RpcRespEapSetFastParams *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_fast_params__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_fast_params__pack_to_buffer + (const RpcRespEapSetFastParams *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_fast_params__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetFastParams * + rpc__resp__eap_set_fast_params__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetFastParams *) + protobuf_c_message_unpack (&rpc__resp__eap_set_fast_params__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_fast_params__free_unpacked + (RpcRespEapSetFastParams *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_fast_params__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_use_default_cert_bundle__init + (RpcReqEapUseDefaultCertBundle *message) +{ + static const RpcReqEapUseDefaultCertBundle init_value = RPC__REQ__EAP_USE_DEFAULT_CERT_BUNDLE__INIT; + *message = init_value; +} +size_t rpc__req__eap_use_default_cert_bundle__get_packed_size + (const RpcReqEapUseDefaultCertBundle *message) +{ + assert(message->base.descriptor == &rpc__req__eap_use_default_cert_bundle__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_use_default_cert_bundle__pack + (const RpcReqEapUseDefaultCertBundle *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_use_default_cert_bundle__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_use_default_cert_bundle__pack_to_buffer + (const RpcReqEapUseDefaultCertBundle *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_use_default_cert_bundle__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapUseDefaultCertBundle * + rpc__req__eap_use_default_cert_bundle__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapUseDefaultCertBundle *) + protobuf_c_message_unpack (&rpc__req__eap_use_default_cert_bundle__descriptor, + allocator, len, data); +} +void rpc__req__eap_use_default_cert_bundle__free_unpacked + (RpcReqEapUseDefaultCertBundle *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_use_default_cert_bundle__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_use_default_cert_bundle__init + (RpcRespEapUseDefaultCertBundle *message) +{ + static const RpcRespEapUseDefaultCertBundle init_value = RPC__RESP__EAP_USE_DEFAULT_CERT_BUNDLE__INIT; + *message = init_value; +} +size_t rpc__resp__eap_use_default_cert_bundle__get_packed_size + (const RpcRespEapUseDefaultCertBundle *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_use_default_cert_bundle__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_use_default_cert_bundle__pack + (const RpcRespEapUseDefaultCertBundle *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_use_default_cert_bundle__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_use_default_cert_bundle__pack_to_buffer + (const RpcRespEapUseDefaultCertBundle *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_use_default_cert_bundle__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapUseDefaultCertBundle * + rpc__resp__eap_use_default_cert_bundle__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapUseDefaultCertBundle *) + protobuf_c_message_unpack (&rpc__resp__eap_use_default_cert_bundle__descriptor, + allocator, len, data); +} +void rpc__resp__eap_use_default_cert_bundle__free_unpacked + (RpcRespEapUseDefaultCertBundle *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_use_default_cert_bundle__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__wifi_set_okc_support__init + (RpcReqWifiSetOkcSupport *message) +{ + static const RpcReqWifiSetOkcSupport init_value = RPC__REQ__WIFI_SET_OKC_SUPPORT__INIT; + *message = init_value; +} +size_t rpc__req__wifi_set_okc_support__get_packed_size + (const RpcReqWifiSetOkcSupport *message) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_okc_support__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__wifi_set_okc_support__pack + (const RpcReqWifiSetOkcSupport *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_okc_support__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__wifi_set_okc_support__pack_to_buffer + (const RpcReqWifiSetOkcSupport *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__wifi_set_okc_support__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqWifiSetOkcSupport * + rpc__req__wifi_set_okc_support__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqWifiSetOkcSupport *) + protobuf_c_message_unpack (&rpc__req__wifi_set_okc_support__descriptor, + allocator, len, data); +} +void rpc__req__wifi_set_okc_support__free_unpacked + (RpcReqWifiSetOkcSupport *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__wifi_set_okc_support__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__wifi_set_okc_support__init + (RpcRespWifiSetOkcSupport *message) +{ + static const RpcRespWifiSetOkcSupport init_value = RPC__RESP__WIFI_SET_OKC_SUPPORT__INIT; + *message = init_value; +} +size_t rpc__resp__wifi_set_okc_support__get_packed_size + (const RpcRespWifiSetOkcSupport *message) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_okc_support__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__wifi_set_okc_support__pack + (const RpcRespWifiSetOkcSupport *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_okc_support__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__wifi_set_okc_support__pack_to_buffer + (const RpcRespWifiSetOkcSupport *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__wifi_set_okc_support__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespWifiSetOkcSupport * + rpc__resp__wifi_set_okc_support__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespWifiSetOkcSupport *) + protobuf_c_message_unpack (&rpc__resp__wifi_set_okc_support__descriptor, + allocator, len, data); +} +void rpc__resp__wifi_set_okc_support__free_unpacked + (RpcRespWifiSetOkcSupport *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__wifi_set_okc_support__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_domain_name__init + (RpcReqEapSetDomainName *message) +{ + static const RpcReqEapSetDomainName init_value = RPC__REQ__EAP_SET_DOMAIN_NAME__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_domain_name__get_packed_size + (const RpcReqEapSetDomainName *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_domain_name__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_domain_name__pack + (const RpcReqEapSetDomainName *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_domain_name__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_domain_name__pack_to_buffer + (const RpcReqEapSetDomainName *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_domain_name__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetDomainName * + rpc__req__eap_set_domain_name__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetDomainName *) + protobuf_c_message_unpack (&rpc__req__eap_set_domain_name__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_domain_name__free_unpacked + (RpcReqEapSetDomainName *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_domain_name__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_domain_name__init + (RpcRespEapSetDomainName *message) +{ + static const RpcRespEapSetDomainName init_value = RPC__RESP__EAP_SET_DOMAIN_NAME__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_domain_name__get_packed_size + (const RpcRespEapSetDomainName *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_domain_name__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_domain_name__pack + (const RpcRespEapSetDomainName *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_domain_name__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_domain_name__pack_to_buffer + (const RpcRespEapSetDomainName *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_domain_name__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetDomainName * + rpc__resp__eap_set_domain_name__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetDomainName *) + protobuf_c_message_unpack (&rpc__resp__eap_set_domain_name__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_domain_name__free_unpacked + (RpcRespEapSetDomainName *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_domain_name__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__req__eap_set_eap_methods__init + (RpcReqEapSetEapMethods *message) +{ + static const RpcReqEapSetEapMethods init_value = RPC__REQ__EAP_SET_EAP_METHODS__INIT; + *message = init_value; +} +size_t rpc__req__eap_set_eap_methods__get_packed_size + (const RpcReqEapSetEapMethods *message) +{ + assert(message->base.descriptor == &rpc__req__eap_set_eap_methods__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__req__eap_set_eap_methods__pack + (const RpcReqEapSetEapMethods *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__req__eap_set_eap_methods__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__req__eap_set_eap_methods__pack_to_buffer + (const RpcReqEapSetEapMethods *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__req__eap_set_eap_methods__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcReqEapSetEapMethods * + rpc__req__eap_set_eap_methods__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcReqEapSetEapMethods *) + protobuf_c_message_unpack (&rpc__req__eap_set_eap_methods__descriptor, + allocator, len, data); +} +void rpc__req__eap_set_eap_methods__free_unpacked + (RpcReqEapSetEapMethods *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__req__eap_set_eap_methods__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__resp__eap_set_eap_methods__init + (RpcRespEapSetEapMethods *message) +{ + static const RpcRespEapSetEapMethods init_value = RPC__RESP__EAP_SET_EAP_METHODS__INIT; + *message = init_value; +} +size_t rpc__resp__eap_set_eap_methods__get_packed_size + (const RpcRespEapSetEapMethods *message) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_eap_methods__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__resp__eap_set_eap_methods__pack + (const RpcRespEapSetEapMethods *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_eap_methods__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__resp__eap_set_eap_methods__pack_to_buffer + (const RpcRespEapSetEapMethods *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__resp__eap_set_eap_methods__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcRespEapSetEapMethods * + rpc__resp__eap_set_eap_methods__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcRespEapSetEapMethods *) + protobuf_c_message_unpack (&rpc__resp__eap_set_eap_methods__descriptor, + allocator, len, data); +} +void rpc__resp__eap_set_eap_methods__free_unpacked + (RpcRespEapSetEapMethods *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__resp__eap_set_eap_methods__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__supp_dpp_uri_ready__init + (RpcEventSuppDppUriReady *message) +{ + static const RpcEventSuppDppUriReady init_value = RPC__EVENT__SUPP_DPP_URI_READY__INIT; + *message = init_value; +} +size_t rpc__event__supp_dpp_uri_ready__get_packed_size + (const RpcEventSuppDppUriReady *message) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_uri_ready__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__supp_dpp_uri_ready__pack + (const RpcEventSuppDppUriReady *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_uri_ready__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__supp_dpp_uri_ready__pack_to_buffer + (const RpcEventSuppDppUriReady *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_uri_ready__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventSuppDppUriReady * + rpc__event__supp_dpp_uri_ready__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventSuppDppUriReady *) + protobuf_c_message_unpack (&rpc__event__supp_dpp_uri_ready__descriptor, + allocator, len, data); +} +void rpc__event__supp_dpp_uri_ready__free_unpacked + (RpcEventSuppDppUriReady *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__supp_dpp_uri_ready__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__supp_dpp_cfg_recvd__init + (RpcEventSuppDppCfgRecvd *message) +{ + static const RpcEventSuppDppCfgRecvd init_value = RPC__EVENT__SUPP_DPP_CFG_RECVD__INIT; + *message = init_value; +} +size_t rpc__event__supp_dpp_cfg_recvd__get_packed_size + (const RpcEventSuppDppCfgRecvd *message) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_cfg_recvd__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__supp_dpp_cfg_recvd__pack + (const RpcEventSuppDppCfgRecvd *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_cfg_recvd__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__supp_dpp_cfg_recvd__pack_to_buffer + (const RpcEventSuppDppCfgRecvd *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_cfg_recvd__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventSuppDppCfgRecvd * + rpc__event__supp_dpp_cfg_recvd__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventSuppDppCfgRecvd *) + protobuf_c_message_unpack (&rpc__event__supp_dpp_cfg_recvd__descriptor, + allocator, len, data); +} +void rpc__event__supp_dpp_cfg_recvd__free_unpacked + (RpcEventSuppDppCfgRecvd *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__supp_dpp_cfg_recvd__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__supp_dpp_fail__init + (RpcEventSuppDppFail *message) +{ + static const RpcEventSuppDppFail init_value = RPC__EVENT__SUPP_DPP_FAIL__INIT; + *message = init_value; +} +size_t rpc__event__supp_dpp_fail__get_packed_size + (const RpcEventSuppDppFail *message) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_fail__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__supp_dpp_fail__pack + (const RpcEventSuppDppFail *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_fail__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__supp_dpp_fail__pack_to_buffer + (const RpcEventSuppDppFail *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__supp_dpp_fail__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventSuppDppFail * + rpc__event__supp_dpp_fail__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventSuppDppFail *) + protobuf_c_message_unpack (&rpc__event__supp_dpp_fail__descriptor, + allocator, len, data); +} +void rpc__event__supp_dpp_fail__free_unpacked + (RpcEventSuppDppFail *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__supp_dpp_fail__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__wifi_dpp_uri_ready__init + (RpcEventWifiDppUriReady *message) +{ + static const RpcEventWifiDppUriReady init_value = RPC__EVENT__WIFI_DPP_URI_READY__INIT; + *message = init_value; +} +size_t rpc__event__wifi_dpp_uri_ready__get_packed_size + (const RpcEventWifiDppUriReady *message) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_uri_ready__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__wifi_dpp_uri_ready__pack + (const RpcEventWifiDppUriReady *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_uri_ready__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__wifi_dpp_uri_ready__pack_to_buffer + (const RpcEventWifiDppUriReady *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_uri_ready__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventWifiDppUriReady * + rpc__event__wifi_dpp_uri_ready__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventWifiDppUriReady *) + protobuf_c_message_unpack (&rpc__event__wifi_dpp_uri_ready__descriptor, + allocator, len, data); +} +void rpc__event__wifi_dpp_uri_ready__free_unpacked + (RpcEventWifiDppUriReady *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__wifi_dpp_uri_ready__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__wifi_dpp_cfg_recvd__init + (RpcEventWifiDppCfgRecvd *message) +{ + static const RpcEventWifiDppCfgRecvd init_value = RPC__EVENT__WIFI_DPP_CFG_RECVD__INIT; + *message = init_value; +} +size_t rpc__event__wifi_dpp_cfg_recvd__get_packed_size + (const RpcEventWifiDppCfgRecvd *message) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_cfg_recvd__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__wifi_dpp_cfg_recvd__pack + (const RpcEventWifiDppCfgRecvd *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_cfg_recvd__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__wifi_dpp_cfg_recvd__pack_to_buffer + (const RpcEventWifiDppCfgRecvd *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_cfg_recvd__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventWifiDppCfgRecvd * + rpc__event__wifi_dpp_cfg_recvd__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventWifiDppCfgRecvd *) + protobuf_c_message_unpack (&rpc__event__wifi_dpp_cfg_recvd__descriptor, + allocator, len, data); +} +void rpc__event__wifi_dpp_cfg_recvd__free_unpacked + (RpcEventWifiDppCfgRecvd *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__wifi_dpp_cfg_recvd__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__event__wifi_dpp_fail__init + (RpcEventWifiDppFail *message) +{ + static const RpcEventWifiDppFail init_value = RPC__EVENT__WIFI_DPP_FAIL__INIT; + *message = init_value; +} +size_t rpc__event__wifi_dpp_fail__get_packed_size + (const RpcEventWifiDppFail *message) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_fail__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__event__wifi_dpp_fail__pack + (const RpcEventWifiDppFail *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_fail__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__event__wifi_dpp_fail__pack_to_buffer + (const RpcEventWifiDppFail *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__event__wifi_dpp_fail__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +RpcEventWifiDppFail * + rpc__event__wifi_dpp_fail__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (RpcEventWifiDppFail *) + protobuf_c_message_unpack (&rpc__event__wifi_dpp_fail__descriptor, + allocator, len, data); +} +void rpc__event__wifi_dpp_fail__free_unpacked + (RpcEventWifiDppFail *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__event__wifi_dpp_fail__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void rpc__init + (Rpc *message) +{ + static const Rpc init_value = RPC__INIT; + *message = init_value; +} +size_t rpc__get_packed_size + (const Rpc *message) +{ + assert(message->base.descriptor == &rpc__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t rpc__pack + (const Rpc *message, + uint8_t *out) +{ + assert(message->base.descriptor == &rpc__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t rpc__pack_to_buffer + (const Rpc *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &rpc__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Rpc * + rpc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Rpc *) + protobuf_c_message_unpack (&rpc__descriptor, + allocator, len, data); +} +void rpc__free_unpacked + (Rpc *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &rpc__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor wifi_init_config__field_descriptors[24] = +{ + { + "static_rx_buf_num", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, static_rx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dynamic_rx_buf_num", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, dynamic_rx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tx_buf_type", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, tx_buf_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "static_tx_buf_num", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, static_tx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dynamic_tx_buf_num", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, dynamic_tx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cache_tx_buf_num", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, cache_tx_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "csi_enable", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, csi_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ampdu_rx_enable", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, ampdu_rx_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ampdu_tx_enable", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, ampdu_tx_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "amsdu_tx_enable", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, amsdu_tx_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nvs_enable", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, nvs_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nano_enable", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, nano_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_ba_win", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, rx_ba_win), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "wifi_task_core_id", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, wifi_task_core_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "beacon_max_len", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, beacon_max_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mgmt_sbuf_num", + 16, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, mgmt_sbuf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_caps", + 17, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, feature_caps), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_disconnected_pm", + 18, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, sta_disconnected_pm), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "espnow_max_encrypt_num", + 19, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, espnow_max_encrypt_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "magic", + 20, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, magic), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_mgmt_buf_type", + 21, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, rx_mgmt_buf_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_mgmt_buf_num", + 22, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, rx_mgmt_buf_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tx_hetb_queue_num", + 23, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, tx_hetb_queue_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dump_hesigb_enable", + 24, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiInitConfig, dump_hesigb_enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_init_config__field_indices_by_name[] = { + 7, /* field[7] = ampdu_rx_enable */ + 8, /* field[8] = ampdu_tx_enable */ + 9, /* field[9] = amsdu_tx_enable */ + 14, /* field[14] = beacon_max_len */ + 5, /* field[5] = cache_tx_buf_num */ + 6, /* field[6] = csi_enable */ + 23, /* field[23] = dump_hesigb_enable */ + 1, /* field[1] = dynamic_rx_buf_num */ + 4, /* field[4] = dynamic_tx_buf_num */ + 18, /* field[18] = espnow_max_encrypt_num */ + 16, /* field[16] = feature_caps */ + 19, /* field[19] = magic */ + 15, /* field[15] = mgmt_sbuf_num */ + 11, /* field[11] = nano_enable */ + 10, /* field[10] = nvs_enable */ + 12, /* field[12] = rx_ba_win */ + 21, /* field[21] = rx_mgmt_buf_num */ + 20, /* field[20] = rx_mgmt_buf_type */ + 17, /* field[17] = sta_disconnected_pm */ + 0, /* field[0] = static_rx_buf_num */ + 3, /* field[3] = static_tx_buf_num */ + 2, /* field[2] = tx_buf_type */ + 22, /* field[22] = tx_hetb_queue_num */ + 13, /* field[13] = wifi_task_core_id */ +}; +static const ProtobufCIntRange wifi_init_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 24 } +}; +const ProtobufCMessageDescriptor wifi_init_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_init_config", + "WifiInitConfig", + "WifiInitConfig", + "", + sizeof(WifiInitConfig), + 24, + wifi_init_config__field_descriptors, + wifi_init_config__field_indices_by_name, + 1, wifi_init_config__number_ranges, + (ProtobufCMessageInit) wifi_init_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_country__field_descriptors[5] = +{ + { + "cc", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCountry, cc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "schan", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, schan), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nchan", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, nchan), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "max_tx_power", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, max_tx_power), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "policy", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiCountry, policy), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_country__field_indices_by_name[] = { + 0, /* field[0] = cc */ + 3, /* field[3] = max_tx_power */ + 2, /* field[2] = nchan */ + 4, /* field[4] = policy */ + 1, /* field[1] = schan */ +}; +static const ProtobufCIntRange wifi_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_country", + "WifiCountry", + "WifiCountry", + "", + sizeof(WifiCountry), + 5, + wifi_country__field_descriptors, + wifi_country__field_indices_by_name, + 1, wifi_country__number_ranges, + (ProtobufCMessageInit) wifi_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_active_scan_time__field_descriptors[2] = +{ + { + "min", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiActiveScanTime, min), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "max", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiActiveScanTime, max), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_active_scan_time__field_indices_by_name[] = { + 1, /* field[1] = max */ + 0, /* field[0] = min */ +}; +static const ProtobufCIntRange wifi_active_scan_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_active_scan_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_active_scan_time", + "WifiActiveScanTime", + "WifiActiveScanTime", + "", + sizeof(WifiActiveScanTime), + 2, + wifi_active_scan_time__field_descriptors, + wifi_active_scan_time__field_indices_by_name, + 1, wifi_active_scan_time__number_ranges, + (ProtobufCMessageInit) wifi_active_scan_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_time__field_descriptors[2] = +{ + { + "active", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiScanTime, active), + &wifi_active_scan_time__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "passive", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanTime, passive), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_time__field_indices_by_name[] = { + 0, /* field[0] = active */ + 1, /* field[1] = passive */ +}; +static const ProtobufCIntRange wifi_scan_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_scan_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_time", + "WifiScanTime", + "WifiScanTime", + "", + sizeof(WifiScanTime), + 2, + wifi_scan_time__field_descriptors, + wifi_scan_time__field_indices_by_name, + 1, wifi_scan_time__number_ranges, + (ProtobufCMessageInit) wifi_scan_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_channel_bitmap__field_descriptors[2] = +{ + { + "ghz_2_channels", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanChannelBitmap, ghz_2_channels), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ghz_5_channels", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanChannelBitmap, ghz_5_channels), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_channel_bitmap__field_indices_by_name[] = { + 0, /* field[0] = ghz_2_channels */ + 1, /* field[1] = ghz_5_channels */ +}; +static const ProtobufCIntRange wifi_scan_channel_bitmap__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_scan_channel_bitmap__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_channel_bitmap", + "WifiScanChannelBitmap", + "WifiScanChannelBitmap", + "", + sizeof(WifiScanChannelBitmap), + 2, + wifi_scan_channel_bitmap__field_descriptors, + wifi_scan_channel_bitmap__field_indices_by_name, + 1, wifi_scan_channel_bitmap__number_ranges, + (ProtobufCMessageInit) wifi_scan_channel_bitmap__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_config__field_descriptors[8] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "show_hidden", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, show_hidden), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_type", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, scan_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_time", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, scan_time), + &wifi_scan_time__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "home_chan_dwell_time", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, home_chan_dwell_time), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel_bitmap", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiScanConfig, channel_bitmap), + &wifi_scan_channel_bitmap__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_config__field_indices_by_name[] = { + 1, /* field[1] = bssid */ + 2, /* field[2] = channel */ + 7, /* field[7] = channel_bitmap */ + 6, /* field[6] = home_chan_dwell_time */ + 5, /* field[5] = scan_time */ + 4, /* field[4] = scan_type */ + 3, /* field[3] = show_hidden */ + 0, /* field[0] = ssid */ +}; +static const ProtobufCIntRange wifi_scan_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 8 } +}; +const ProtobufCMessageDescriptor wifi_scan_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_config", + "WifiScanConfig", + "WifiScanConfig", + "", + sizeof(WifiScanConfig), + 8, + wifi_scan_config__field_descriptors, + wifi_scan_config__field_indices_by_name, + 1, wifi_scan_config__number_ranges, + (ProtobufCMessageInit) wifi_scan_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_he_ap_info__field_descriptors[2] = +{ + { + "bitmask", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiHeApInfo, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid_index", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiHeApInfo, bssid_index), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_he_ap_info__field_indices_by_name[] = { + 0, /* field[0] = bitmask */ + 1, /* field[1] = bssid_index */ +}; +static const ProtobufCIntRange wifi_he_ap_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_he_ap_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_he_ap_info", + "WifiHeApInfo", + "WifiHeApInfo", + "", + sizeof(WifiHeApInfo), + 2, + wifi_he_ap_info__field_descriptors, + wifi_he_ap_info__field_indices_by_name, + 1, wifi_he_ap_info__number_ranges, + (ProtobufCMessageInit) wifi_he_ap_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ap_record__field_descriptors[15] = +{ + { + "bssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "primary", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, primary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "second", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, second), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pairwise_cipher", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, pairwise_cipher), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "group_cipher", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, group_cipher), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ant", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, ant), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "country", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, country), + &wifi_country__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "he_ap", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, he_ap), + &wifi_he_ap_info__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidth", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, bandwidth), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "vht_ch_freq1", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, vht_ch_freq1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "vht_ch_freq2", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApRecord, vht_ch_freq2), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ap_record__field_indices_by_name[] = { + 8, /* field[8] = ant */ + 5, /* field[5] = authmode */ + 12, /* field[12] = bandwidth */ + 9, /* field[9] = bitmask */ + 0, /* field[0] = bssid */ + 10, /* field[10] = country */ + 7, /* field[7] = group_cipher */ + 11, /* field[11] = he_ap */ + 6, /* field[6] = pairwise_cipher */ + 2, /* field[2] = primary */ + 4, /* field[4] = rssi */ + 3, /* field[3] = second */ + 1, /* field[1] = ssid */ + 13, /* field[13] = vht_ch_freq1 */ + 14, /* field[14] = vht_ch_freq2 */ +}; +static const ProtobufCIntRange wifi_ap_record__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 15 } +}; +const ProtobufCMessageDescriptor wifi_ap_record__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ap_record", + "WifiApRecord", + "WifiApRecord", + "", + sizeof(WifiApRecord), + 15, + wifi_ap_record__field_descriptors, + wifi_ap_record__field_indices_by_name, + 1, wifi_ap_record__number_ranges, + (ProtobufCMessageInit) wifi_ap_record__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_scan_threshold__field_descriptors[3] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiScanThreshold, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiScanThreshold, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi_5g_adjustment", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiScanThreshold, rssi_5g_adjustment), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_scan_threshold__field_indices_by_name[] = { + 1, /* field[1] = authmode */ + 0, /* field[0] = rssi */ + 2, /* field[2] = rssi_5g_adjustment */ +}; +static const ProtobufCIntRange wifi_scan_threshold__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor wifi_scan_threshold__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_scan_threshold", + "WifiScanThreshold", + "WifiScanThreshold", + "", + sizeof(WifiScanThreshold), + 3, + wifi_scan_threshold__field_descriptors, + wifi_scan_threshold__field_indices_by_name, + 1, wifi_scan_threshold__number_ranges, + (ProtobufCMessageInit) wifi_scan_threshold__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_pmf_config__field_descriptors[2] = +{ + { + "capable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiPmfConfig, capable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "required", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiPmfConfig, required), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_pmf_config__field_indices_by_name[] = { + 0, /* field[0] = capable */ + 1, /* field[1] = required */ +}; +static const ProtobufCIntRange wifi_pmf_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_pmf_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_pmf_config", + "WifiPmfConfig", + "WifiPmfConfig", + "", + sizeof(WifiPmfConfig), + 2, + wifi_pmf_config__field_descriptors, + wifi_pmf_config__field_indices_by_name, + 1, wifi_pmf_config__number_ranges, + (ProtobufCMessageInit) wifi_pmf_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_bss_max_idle_config__field_descriptors[2] = +{ + { + "period", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiBssMaxIdleConfig, period), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protected_keep_alive", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiBssMaxIdleConfig, protected_keep_alive), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_bss_max_idle_config__field_indices_by_name[] = { + 0, /* field[0] = period */ + 1, /* field[1] = protected_keep_alive */ +}; +static const ProtobufCIntRange wifi_bss_max_idle_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_bss_max_idle_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_bss_max_idle_config", + "WifiBssMaxIdleConfig", + "WifiBssMaxIdleConfig", + "", + sizeof(WifiBssMaxIdleConfig), + 2, + wifi_bss_max_idle_config__field_descriptors, + wifi_bss_max_idle_config__field_indices_by_name, + 1, wifi_bss_max_idle_config__number_ranges, + (ProtobufCMessageInit) wifi_bss_max_idle_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ap_config__field_descriptors[18] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "password", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_len", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ssid_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_hidden", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ssid_hidden), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "max_connection", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, max_connection), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "beacon_interval", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, beacon_interval), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pairwise_cipher", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, pairwise_cipher), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ftm_responder", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, ftm_responder), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pmf_cfg", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, pmf_cfg), + &wifi_pmf_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_pwe_h2e", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, sae_pwe_h2e), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "csa_count", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, csa_count), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dtim_period", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, dtim_period), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "transition_disable", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, transition_disable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_ext", + 16, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, sae_ext), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bss_max_idle_cfg", + 17, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, bss_max_idle_cfg), + &wifi_bss_max_idle_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "gtk_rekey_interval", + 18, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiApConfig, gtk_rekey_interval), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ap_config__field_indices_by_name[] = { + 4, /* field[4] = authmode */ + 7, /* field[7] = beacon_interval */ + 16, /* field[16] = bss_max_idle_cfg */ + 3, /* field[3] = channel */ + 12, /* field[12] = csa_count */ + 13, /* field[13] = dtim_period */ + 9, /* field[9] = ftm_responder */ + 17, /* field[17] = gtk_rekey_interval */ + 6, /* field[6] = max_connection */ + 8, /* field[8] = pairwise_cipher */ + 1, /* field[1] = password */ + 10, /* field[10] = pmf_cfg */ + 15, /* field[15] = sae_ext */ + 11, /* field[11] = sae_pwe_h2e */ + 0, /* field[0] = ssid */ + 5, /* field[5] = ssid_hidden */ + 2, /* field[2] = ssid_len */ + 14, /* field[14] = transition_disable */ +}; +static const ProtobufCIntRange wifi_ap_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 18 } +}; +const ProtobufCMessageDescriptor wifi_ap_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ap_config", + "WifiApConfig", + "WifiApConfig", + "", + sizeof(WifiApConfig), + 18, + wifi_ap_config__field_descriptors, + wifi_ap_config__field_indices_by_name, + 1, wifi_ap_config__number_ranges, + (ProtobufCMessageInit) wifi_ap_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_sta_config__field_descriptors[16] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "password", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_method", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, scan_method), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid_set", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, bssid_set), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "listen_interval", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, listen_interval), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sort_method", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sort_method), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "threshold", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, threshold), + &wifi_scan_threshold__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pmf_cfg", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, pmf_cfg), + &wifi_pmf_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_pwe_h2e", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sae_pwe_h2e), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "failure_retry_cnt", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, failure_retry_cnt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "he_bitmask", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, he_bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_h2e_identifier", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sae_h2e_identifier), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sae_pk_mode", + 16, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaConfig, sae_pk_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_sta_config__field_indices_by_name[] = { + 10, /* field[10] = bitmask */ + 4, /* field[4] = bssid */ + 3, /* field[3] = bssid_set */ + 5, /* field[5] = channel */ + 12, /* field[12] = failure_retry_cnt */ + 13, /* field[13] = he_bitmask */ + 6, /* field[6] = listen_interval */ + 1, /* field[1] = password */ + 9, /* field[9] = pmf_cfg */ + 14, /* field[14] = sae_h2e_identifier */ + 15, /* field[15] = sae_pk_mode */ + 11, /* field[11] = sae_pwe_h2e */ + 2, /* field[2] = scan_method */ + 7, /* field[7] = sort_method */ + 0, /* field[0] = ssid */ + 8, /* field[8] = threshold */ +}; +static const ProtobufCIntRange wifi_sta_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 16 } +}; +const ProtobufCMessageDescriptor wifi_sta_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_sta_config", + "WifiStaConfig", + "WifiStaConfig", + "", + sizeof(WifiStaConfig), + 16, + wifi_sta_config__field_descriptors, + wifi_sta_config__field_indices_by_name, + 1, wifi_sta_config__number_ranges, + (ProtobufCMessageInit) wifi_sta_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_config__field_descriptors[2] = +{ + { + "ap", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiConfig, u_case), + offsetof(WifiConfig, ap), + &wifi_ap_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiConfig, u_case), + offsetof(WifiConfig, sta), + &wifi_sta_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_config__field_indices_by_name[] = { + 0, /* field[0] = ap */ + 1, /* field[1] = sta */ +}; +static const ProtobufCIntRange wifi_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_config", + "WifiConfig", + "WifiConfig", + "", + sizeof(WifiConfig), + 2, + wifi_config__field_descriptors, + wifi_config__field_indices_by_name, + 1, wifi_config__number_ranges, + (ProtobufCMessageInit) wifi_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_sta_info__field_descriptors[3] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiStaInfo, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaInfo, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiStaInfo, bitmask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_sta_info__field_indices_by_name[] = { + 2, /* field[2] = bitmask */ + 0, /* field[0] = mac */ + 1, /* field[1] = rssi */ +}; +static const ProtobufCIntRange wifi_sta_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor wifi_sta_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_sta_info", + "WifiStaInfo", + "WifiStaInfo", + "", + sizeof(WifiStaInfo), + 3, + wifi_sta_info__field_descriptors, + wifi_sta_info__field_indices_by_name, + 1, wifi_sta_info__number_ranges, + (ProtobufCMessageInit) wifi_sta_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_sta_list__field_descriptors[2] = +{ + { + "sta", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiStaList, n_sta), + offsetof(WifiStaList, sta), + &wifi_sta_info__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "num", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiStaList, num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_sta_list__field_indices_by_name[] = { + 1, /* field[1] = num */ + 0, /* field[0] = sta */ +}; +static const ProtobufCIntRange wifi_sta_list__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_sta_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_sta_list", + "WifiStaList", + "WifiStaList", + "", + sizeof(WifiStaList), + 2, + wifi_sta_list__field_descriptors, + wifi_sta_list__field_indices_by_name, + 1, wifi_sta_list__number_ranges, + (ProtobufCMessageInit) wifi_sta_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_pkt_rx_ctrl__field_descriptors[19] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rate", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, rate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sig_mode", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, sig_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mcs", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, mcs), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cwb", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, cwb), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "smoothing", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, smoothing), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "not_sounding", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, not_sounding), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aggregation", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, aggregation), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "stbc", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, stbc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "fec_coding", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, fec_coding), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sgi", + 11, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, sgi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "noise_floor", + 12, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, noise_floor), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ampdu_cnt", + 13, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, ampdu_cnt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 14, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "secondary_channel", + 15, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, secondary_channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "timestamp", + 16, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, timestamp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ant", + 17, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, ant), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sig_len", + 18, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, sig_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_state", + 19, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPktRxCtrl, rx_state), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_pkt_rx_ctrl__field_indices_by_name[] = { + 7, /* field[7] = aggregation */ + 12, /* field[12] = ampdu_cnt */ + 16, /* field[16] = ant */ + 13, /* field[13] = channel */ + 4, /* field[4] = cwb */ + 9, /* field[9] = fec_coding */ + 3, /* field[3] = mcs */ + 11, /* field[11] = noise_floor */ + 6, /* field[6] = not_sounding */ + 1, /* field[1] = rate */ + 0, /* field[0] = rssi */ + 18, /* field[18] = rx_state */ + 14, /* field[14] = secondary_channel */ + 10, /* field[10] = sgi */ + 17, /* field[17] = sig_len */ + 2, /* field[2] = sig_mode */ + 5, /* field[5] = smoothing */ + 8, /* field[8] = stbc */ + 15, /* field[15] = timestamp */ +}; +static const ProtobufCIntRange wifi_pkt_rx_ctrl__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 19 } +}; +const ProtobufCMessageDescriptor wifi_pkt_rx_ctrl__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_pkt_rx_ctrl", + "WifiPktRxCtrl", + "WifiPktRxCtrl", + "", + sizeof(WifiPktRxCtrl), + 19, + wifi_pkt_rx_ctrl__field_descriptors, + wifi_pkt_rx_ctrl__field_indices_by_name, + 1, wifi_pkt_rx_ctrl__number_ranges, + (ProtobufCMessageInit) wifi_pkt_rx_ctrl__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_promiscuous_pkt__field_descriptors[2] = +{ + { + "rx_ctrl", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiPromiscuousPkt, rx_ctrl), + &wifi_pkt_rx_ctrl__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "payload", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiPromiscuousPkt, payload), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_promiscuous_pkt__field_indices_by_name[] = { + 1, /* field[1] = payload */ + 0, /* field[0] = rx_ctrl */ +}; +static const ProtobufCIntRange wifi_promiscuous_pkt__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_promiscuous_pkt__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_promiscuous_pkt", + "WifiPromiscuousPkt", + "WifiPromiscuousPkt", + "", + sizeof(WifiPromiscuousPkt), + 2, + wifi_promiscuous_pkt__field_descriptors, + wifi_promiscuous_pkt__field_indices_by_name, + 1, wifi_promiscuous_pkt__number_ranges, + (ProtobufCMessageInit) wifi_promiscuous_pkt__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_promiscuous_filter__field_descriptors[1] = +{ + { + "filter_mask", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiPromiscuousFilter, filter_mask), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_promiscuous_filter__field_indices_by_name[] = { + 0, /* field[0] = filter_mask */ +}; +static const ProtobufCIntRange wifi_promiscuous_filter__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_promiscuous_filter__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_promiscuous_filter", + "WifiPromiscuousFilter", + "WifiPromiscuousFilter", + "", + sizeof(WifiPromiscuousFilter), + 1, + wifi_promiscuous_filter__field_descriptors, + wifi_promiscuous_filter__field_indices_by_name, + 1, wifi_promiscuous_filter__number_ranges, + (ProtobufCMessageInit) wifi_promiscuous_filter__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_csi_config__field_descriptors[7] = +{ + { + "lltf_en", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, lltf_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "htltf_en", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, htltf_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "stbc_htltf2_en", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, stbc_htltf2_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ltf_merge_en", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, ltf_merge_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel_filter_en", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, channel_filter_en), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "manu_scale", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, manu_scale), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "shift", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCsiConfig, shift), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_csi_config__field_indices_by_name[] = { + 4, /* field[4] = channel_filter_en */ + 1, /* field[1] = htltf_en */ + 0, /* field[0] = lltf_en */ + 3, /* field[3] = ltf_merge_en */ + 5, /* field[5] = manu_scale */ + 6, /* field[6] = shift */ + 2, /* field[2] = stbc_htltf2_en */ +}; +static const ProtobufCIntRange wifi_csi_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_csi_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_csi_config", + "WifiCsiConfig", + "WifiCsiConfig", + "", + sizeof(WifiCsiConfig), + 7, + wifi_csi_config__field_descriptors, + wifi_csi_config__field_indices_by_name, + 1, wifi_csi_config__number_ranges, + (ProtobufCMessageInit) wifi_csi_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_csi_info__field_descriptors[6] = +{ + { + "rx_ctrl", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, rx_ctrl), + &wifi_pkt_rx_ctrl__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dmac", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, dmac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "first_word_invalid", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, first_word_invalid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "buf", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, buf), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiCsiInfo, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_csi_info__field_indices_by_name[] = { + 4, /* field[4] = buf */ + 2, /* field[2] = dmac */ + 3, /* field[3] = first_word_invalid */ + 5, /* field[5] = len */ + 1, /* field[1] = mac */ + 0, /* field[0] = rx_ctrl */ +}; +static const ProtobufCIntRange wifi_csi_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor wifi_csi_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_csi_info", + "WifiCsiInfo", + "WifiCsiInfo", + "", + sizeof(WifiCsiInfo), + 6, + wifi_csi_info__field_descriptors, + wifi_csi_info__field_indices_by_name, + 1, wifi_csi_info__number_ranges, + (ProtobufCMessageInit) wifi_csi_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ant_gpio__field_descriptors[2] = +{ + { + "gpio_select", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntGpio, gpio_select), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "gpio_num", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntGpio, gpio_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ant_gpio__field_indices_by_name[] = { + 1, /* field[1] = gpio_num */ + 0, /* field[0] = gpio_select */ +}; +static const ProtobufCIntRange wifi_ant_gpio__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_ant_gpio__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ant_gpio", + "WifiAntGpio", + "WifiAntGpio", + "", + sizeof(WifiAntGpio), + 2, + wifi_ant_gpio__field_descriptors, + wifi_ant_gpio__field_indices_by_name, + 1, wifi_ant_gpio__number_ranges, + (ProtobufCMessageInit) wifi_ant_gpio__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ant_gpio_config__field_descriptors[1] = +{ + { + "gpio_cfgs", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiAntGpioConfig, n_gpio_cfgs), + offsetof(WifiAntGpioConfig, gpio_cfgs), + &wifi_ant_gpio__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ant_gpio_config__field_indices_by_name[] = { + 0, /* field[0] = gpio_cfgs */ +}; +static const ProtobufCIntRange wifi_ant_gpio_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_ant_gpio_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ant_gpio_config", + "WifiAntGpioConfig", + "WifiAntGpioConfig", + "", + sizeof(WifiAntGpioConfig), + 1, + wifi_ant_gpio_config__field_descriptors, + wifi_ant_gpio_config__field_indices_by_name, + 1, wifi_ant_gpio_config__number_ranges, + (ProtobufCMessageInit) wifi_ant_gpio_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ant_config__field_descriptors[5] = +{ + { + "rx_ant_mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, rx_ant_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rx_ant_default", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, rx_ant_default), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tx_ant_mode", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, tx_ant_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled_ant0", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, enabled_ant0), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled_ant1", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiAntConfig, enabled_ant1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ant_config__field_indices_by_name[] = { + 3, /* field[3] = enabled_ant0 */ + 4, /* field[4] = enabled_ant1 */ + 1, /* field[1] = rx_ant_default */ + 0, /* field[0] = rx_ant_mode */ + 2, /* field[2] = tx_ant_mode */ +}; +static const ProtobufCIntRange wifi_ant_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_ant_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ant_config", + "WifiAntConfig", + "WifiAntConfig", + "", + sizeof(WifiAntConfig), + 5, + wifi_ant_config__field_descriptors, + wifi_ant_config__field_indices_by_name, + 1, wifi_ant_config__number_ranges, + (ProtobufCMessageInit) wifi_ant_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_action_tx_req__field_descriptors[5] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dest_mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, dest_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "no_ack", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, no_ack), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data_len", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, data_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiActionTxReq, data), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_action_tx_req__field_indices_by_name[] = { + 4, /* field[4] = data */ + 3, /* field[3] = data_len */ + 1, /* field[1] = dest_mac */ + 0, /* field[0] = ifx */ + 2, /* field[2] = no_ack */ +}; +static const ProtobufCIntRange wifi_action_tx_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_action_tx_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_action_tx_req", + "WifiActionTxReq", + "WifiActionTxReq", + "", + sizeof(WifiActionTxReq), + 5, + wifi_action_tx_req__field_descriptors, + wifi_action_tx_req__field_indices_by_name, + 1, wifi_action_tx_req__number_ranges, + (ProtobufCMessageInit) wifi_action_tx_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ftm_initiator_cfg__field_descriptors[4] = +{ + { + "resp_mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, resp_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "frm_count", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, frm_count), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "burst_period", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmInitiatorCfg, burst_period), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ftm_initiator_cfg__field_indices_by_name[] = { + 3, /* field[3] = burst_period */ + 1, /* field[1] = channel */ + 2, /* field[2] = frm_count */ + 0, /* field[0] = resp_mac */ +}; +static const ProtobufCIntRange wifi_ftm_initiator_cfg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor wifi_ftm_initiator_cfg__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ftm_initiator_cfg", + "WifiFtmInitiatorCfg", + "WifiFtmInitiatorCfg", + "", + sizeof(WifiFtmInitiatorCfg), + 4, + wifi_ftm_initiator_cfg__field_descriptors, + wifi_ftm_initiator_cfg__field_indices_by_name, + 1, wifi_ftm_initiator_cfg__number_ranges, + (ProtobufCMessageInit) wifi_ftm_initiator_cfg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_scan_done__field_descriptors[3] = +{ + { + "status", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaScanDone, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "number", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaScanDone, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_id", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaScanDone, scan_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_scan_done__field_indices_by_name[] = { + 1, /* field[1] = number */ + 2, /* field[2] = scan_id */ + 0, /* field[0] = status */ +}; +static const ProtobufCIntRange wifi_event_sta_scan_done__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_scan_done__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_scan_done", + "WifiEventStaScanDone", + "WifiEventStaScanDone", + "", + sizeof(WifiEventStaScanDone), + 3, + wifi_event_sta_scan_done__field_descriptors, + wifi_event_sta_scan_done__field_indices_by_name, + 1, wifi_event_sta_scan_done__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_scan_done__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_connected__field_descriptors[6] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, ssid_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, channel), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "authmode", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, authmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaConnected, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_connected__field_indices_by_name[] = { + 5, /* field[5] = aid */ + 4, /* field[4] = authmode */ + 2, /* field[2] = bssid */ + 3, /* field[3] = channel */ + 0, /* field[0] = ssid */ + 1, /* field[1] = ssid_len */ +}; +static const ProtobufCIntRange wifi_event_sta_connected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_connected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_connected", + "WifiEventStaConnected", + "WifiEventStaConnected", + "", + sizeof(WifiEventStaConnected), + 6, + wifi_event_sta_connected__field_descriptors, + wifi_event_sta_connected__field_indices_by_name, + 1, wifi_event_sta_connected__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_connected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_disconnected__field_descriptors[5] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, ssid_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bssid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, bssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaDisconnected, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_disconnected__field_indices_by_name[] = { + 2, /* field[2] = bssid */ + 3, /* field[3] = reason */ + 4, /* field[4] = rssi */ + 0, /* field[0] = ssid */ + 1, /* field[1] = ssid_len */ +}; +static const ProtobufCIntRange wifi_event_sta_disconnected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_disconnected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_disconnected", + "WifiEventStaDisconnected", + "WifiEventStaDisconnected", + "", + sizeof(WifiEventStaDisconnected), + 5, + wifi_event_sta_disconnected__field_descriptors, + wifi_event_sta_disconnected__field_indices_by_name, + 1, wifi_event_sta_disconnected__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_disconnected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_authmode_change__field_descriptors[2] = +{ + { + "old_mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaAuthmodeChange, old_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "new_mode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaAuthmodeChange, new_mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_authmode_change__field_indices_by_name[] = { + 1, /* field[1] = new_mode */ + 0, /* field[0] = old_mode */ +}; +static const ProtobufCIntRange wifi_event_sta_authmode_change__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_authmode_change__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_authmode_change", + "WifiEventStaAuthmodeChange", + "WifiEventStaAuthmodeChange", + "", + sizeof(WifiEventStaAuthmodeChange), + 2, + wifi_event_sta_authmode_change__field_descriptors, + wifi_event_sta_authmode_change__field_indices_by_name, + 1, wifi_event_sta_authmode_change__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_authmode_change__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_wps_er_pin__field_descriptors[1] = +{ + { + "pin_code", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventStaWpsErPin, pin_code), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_wps_er_pin__field_indices_by_name[] = { + 0, /* field[0] = pin_code */ +}; +static const ProtobufCIntRange wifi_event_sta_wps_er_pin__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_wps_er_pin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_wps_er_pin", + "WifiEventStaWpsErPin", + "WifiEventStaWpsErPin", + "", + sizeof(WifiEventStaWpsErPin), + 1, + wifi_event_sta_wps_er_pin__field_descriptors, + wifi_event_sta_wps_er_pin__field_indices_by_name, + 1, wifi_event_sta_wps_er_pin__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_wps_er_pin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor ap_cred__field_descriptors[2] = +{ + { + "ssid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(ApCred, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "passphrase", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(ApCred, passphrase), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ap_cred__field_indices_by_name[] = { + 1, /* field[1] = passphrase */ + 0, /* field[0] = ssid */ +}; +static const ProtobufCIntRange ap_cred__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor ap_cred__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ap_cred", + "ApCred", + "ApCred", + "", + sizeof(ApCred), + 2, + ap_cred__field_descriptors, + ap_cred__field_indices_by_name, + 1, ap_cred__number_ranges, + (ProtobufCMessageInit) ap_cred__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_sta_wps_er_success__field_descriptors[2] = +{ + { + "ap_cred_cnt", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventStaWpsErSuccess, ap_cred_cnt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_creds", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiEventStaWpsErSuccess, n_ap_creds), + offsetof(WifiEventStaWpsErSuccess, ap_creds), + &ap_cred__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_sta_wps_er_success__field_indices_by_name[] = { + 0, /* field[0] = ap_cred_cnt */ + 1, /* field[1] = ap_creds */ +}; +static const ProtobufCIntRange wifi_event_sta_wps_er_success__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_sta_wps_er_success__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_sta_wps_er_success", + "WifiEventStaWpsErSuccess", + "WifiEventStaWpsErSuccess", + "", + sizeof(WifiEventStaWpsErSuccess), + 2, + wifi_event_sta_wps_er_success__field_descriptors, + wifi_event_sta_wps_er_success__field_indices_by_name, + 1, wifi_event_sta_wps_er_success__number_ranges, + (ProtobufCMessageInit) wifi_event_sta_wps_er_success__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_probe_req_rx__field_descriptors[2] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventApProbeReqRx, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventApProbeReqRx, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_probe_req_rx__field_indices_by_name[] = { + 1, /* field[1] = mac */ + 0, /* field[0] = rssi */ +}; +static const ProtobufCIntRange wifi_event_ap_probe_req_rx__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_probe_req_rx__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_probe_req_rx", + "WifiEventApProbeReqRx", + "WifiEventApProbeReqRx", + "", + sizeof(WifiEventApProbeReqRx), + 2, + wifi_event_ap_probe_req_rx__field_descriptors, + wifi_event_ap_probe_req_rx__field_indices_by_name, + 1, wifi_event_ap_probe_req_rx__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_probe_req_rx__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_bss_rssi_low__field_descriptors[1] = +{ + { + "rssi", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventBssRssiLow, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_bss_rssi_low__field_indices_by_name[] = { + 0, /* field[0] = rssi */ +}; +static const ProtobufCIntRange wifi_event_bss_rssi_low__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_bss_rssi_low__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_bss_rssi_low", + "WifiEventBssRssiLow", + "WifiEventBssRssiLow", + "", + sizeof(WifiEventBssRssiLow), + 1, + wifi_event_bss_rssi_low__field_descriptors, + wifi_event_bss_rssi_low__field_indices_by_name, + 1, wifi_event_bss_rssi_low__number_ranges, + (ProtobufCMessageInit) wifi_event_bss_rssi_low__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_ftm_report_entry__field_descriptors[7] = +{ + { + "dlog_token", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, dlog_token), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rtt", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, rtt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t1", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t2", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t2), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t3", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t3), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "t4", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(WifiFtmReportEntry, t4), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_ftm_report_entry__field_indices_by_name[] = { + 0, /* field[0] = dlog_token */ + 1, /* field[1] = rssi */ + 2, /* field[2] = rtt */ + 3, /* field[3] = t1 */ + 4, /* field[4] = t2 */ + 5, /* field[5] = t3 */ + 6, /* field[6] = t4 */ +}; +static const ProtobufCIntRange wifi_ftm_report_entry__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_ftm_report_entry__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_ftm_report_entry", + "WifiFtmReportEntry", + "WifiFtmReportEntry", + "", + sizeof(WifiFtmReportEntry), + 7, + wifi_ftm_report_entry__field_descriptors, + wifi_ftm_report_entry__field_indices_by_name, + 1, wifi_ftm_report_entry__number_ranges, + (ProtobufCMessageInit) wifi_ftm_report_entry__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ftm_report__field_descriptors[7] = +{ + { + "peer_mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, peer_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rtt_raw", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, rtt_raw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rtt_est", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, rtt_est), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dist_est", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, dist_est), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ftm_report_data", + 6, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(WifiEventFtmReport, n_ftm_report_data), + offsetof(WifiEventFtmReport, ftm_report_data), + &wifi_ftm_report_entry__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ftm_report_num_entries", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventFtmReport, ftm_report_num_entries), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ftm_report__field_indices_by_name[] = { + 4, /* field[4] = dist_est */ + 5, /* field[5] = ftm_report_data */ + 6, /* field[6] = ftm_report_num_entries */ + 0, /* field[0] = peer_mac */ + 3, /* field[3] = rtt_est */ + 2, /* field[2] = rtt_raw */ + 1, /* field[1] = status */ +}; +static const ProtobufCIntRange wifi_event_ftm_report__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor wifi_event_ftm_report__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ftm_report", + "WifiEventFtmReport", + "WifiEventFtmReport", + "", + sizeof(WifiEventFtmReport), + 7, + wifi_event_ftm_report__field_descriptors, + wifi_event_ftm_report__field_indices_by_name, + 1, wifi_event_ftm_report__number_ranges, + (ProtobufCMessageInit) wifi_event_ftm_report__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_action_tx_status__field_descriptors[4] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "context", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, context), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "da", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, da), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventActionTxStatus, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_action_tx_status__field_indices_by_name[] = { + 1, /* field[1] = context */ + 2, /* field[2] = da */ + 0, /* field[0] = ifx */ + 3, /* field[3] = status */ +}; +static const ProtobufCIntRange wifi_event_action_tx_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor wifi_event_action_tx_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_action_tx_status", + "WifiEventActionTxStatus", + "WifiEventActionTxStatus", + "", + sizeof(WifiEventActionTxStatus), + 4, + wifi_event_action_tx_status__field_descriptors, + wifi_event_action_tx_status__field_indices_by_name, + 1, wifi_event_action_tx_status__number_ranges, + (ProtobufCMessageInit) wifi_event_action_tx_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_roc_done__field_descriptors[1] = +{ + { + "context", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiEventRocDone, context), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_roc_done__field_indices_by_name[] = { + 0, /* field[0] = context */ +}; +static const ProtobufCIntRange wifi_event_roc_done__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_roc_done__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_roc_done", + "WifiEventRocDone", + "WifiEventRocDone", + "", + sizeof(WifiEventRocDone), + 1, + wifi_event_roc_done__field_descriptors, + wifi_event_roc_done__field_indices_by_name, + 1, wifi_event_roc_done__number_ranges, + (ProtobufCMessageInit) wifi_event_roc_done__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_wps_rg_pin__field_descriptors[1] = +{ + { + "pin_code", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgPin, pin_code), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_wps_rg_pin__field_indices_by_name[] = { + 0, /* field[0] = pin_code */ +}; +static const ProtobufCIntRange wifi_event_ap_wps_rg_pin__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_pin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_wps_rg_pin", + "WifiEventApWpsRgPin", + "WifiEventApWpsRgPin", + "", + sizeof(WifiEventApWpsRgPin), + 1, + wifi_event_ap_wps_rg_pin__field_descriptors, + wifi_event_ap_wps_rg_pin__field_indices_by_name, + 1, wifi_event_ap_wps_rg_pin__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_wps_rg_pin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_wps_rg_fail_reason__field_descriptors[2] = +{ + { + "reason", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgFailReason, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "peer_macaddr", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgFailReason, peer_macaddr), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_wps_rg_fail_reason__field_indices_by_name[] = { + 1, /* field[1] = peer_macaddr */ + 0, /* field[0] = reason */ +}; +static const ProtobufCIntRange wifi_event_ap_wps_rg_fail_reason__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_fail_reason__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_wps_rg_fail_reason", + "WifiEventApWpsRgFailReason", + "WifiEventApWpsRgFailReason", + "", + sizeof(WifiEventApWpsRgFailReason), + 2, + wifi_event_ap_wps_rg_fail_reason__field_descriptors, + wifi_event_ap_wps_rg_fail_reason__field_indices_by_name, + 1, wifi_event_ap_wps_rg_fail_reason__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_wps_rg_fail_reason__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_event_ap_wps_rg_success__field_descriptors[1] = +{ + { + "peer_macaddr", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(WifiEventApWpsRgSuccess, peer_macaddr), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_event_ap_wps_rg_success__field_indices_by_name[] = { + 0, /* field[0] = peer_macaddr */ +}; +static const ProtobufCIntRange wifi_event_ap_wps_rg_success__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_success__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_event_ap_wps_rg_success", + "WifiEventApWpsRgSuccess", + "WifiEventApWpsRgSuccess", + "", + sizeof(WifiEventApWpsRgSuccess), + 1, + wifi_event_ap_wps_rg_success__field_descriptors, + wifi_event_ap_wps_rg_success__field_indices_by_name, + 1, wifi_event_ap_wps_rg_success__number_ranges, + (ProtobufCMessageInit) wifi_event_ap_wps_rg_success__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_protocols__field_descriptors[2] = +{ + { + "ghz_2g", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiProtocols, ghz_2g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ghz_5g", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiProtocols, ghz_5g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_protocols__field_indices_by_name[] = { + 0, /* field[0] = ghz_2g */ + 1, /* field[1] = ghz_5g */ +}; +static const ProtobufCIntRange wifi_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_protocols", + "WifiProtocols", + "WifiProtocols", + "", + sizeof(WifiProtocols), + 2, + wifi_protocols__field_descriptors, + wifi_protocols__field_indices_by_name, + 1, wifi_protocols__number_ranges, + (ProtobufCMessageInit) wifi_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_bandwidths__field_descriptors[2] = +{ + { + "ghz_2g", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiBandwidths, ghz_2g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ghz_5g", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiBandwidths, ghz_5g), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_bandwidths__field_indices_by_name[] = { + 0, /* field[0] = ghz_2g */ + 1, /* field[1] = ghz_5g */ +}; +static const ProtobufCIntRange wifi_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_bandwidths", + "WifiBandwidths", + "WifiBandwidths", + "", + sizeof(WifiBandwidths), + 2, + wifi_bandwidths__field_descriptors, + wifi_bandwidths__field_indices_by_name, + 1, wifi_bandwidths__number_ranges, + (ProtobufCMessageInit) wifi_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_itwt_setup_config__field_descriptors[6] = +{ + { + "setup_cmd", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiItwtSetupConfig, setup_cmd), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bitmask_1", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiItwtSetupConfig, bitmask_1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "min_wake_dura", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiItwtSetupConfig, min_wake_dura), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "wake_invl_mant", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiItwtSetupConfig, wake_invl_mant), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "twt_id", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiItwtSetupConfig, twt_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "timeout_time_ms", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(WifiItwtSetupConfig, timeout_time_ms), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_itwt_setup_config__field_indices_by_name[] = { + 1, /* field[1] = bitmask_1 */ + 2, /* field[2] = min_wake_dura */ + 0, /* field[0] = setup_cmd */ + 5, /* field[5] = timeout_time_ms */ + 4, /* field[4] = twt_id */ + 3, /* field[3] = wake_invl_mant */ +}; +static const ProtobufCIntRange wifi_itwt_setup_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor wifi_itwt_setup_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_itwt_setup_config", + "WifiItwtSetupConfig", + "WifiItwtSetupConfig", + "", + sizeof(WifiItwtSetupConfig), + 6, + wifi_itwt_setup_config__field_descriptors, + wifi_itwt_setup_config__field_indices_by_name, + 1, wifi_itwt_setup_config__number_ranges, + (ProtobufCMessageInit) wifi_itwt_setup_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor wifi_twt_config__field_descriptors[2] = +{ + { + "post_wakeup_event", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiTwtConfig, post_wakeup_event), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "twt_enable_keep_alive", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(WifiTwtConfig, twt_enable_keep_alive), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned wifi_twt_config__field_indices_by_name[] = { + 0, /* field[0] = post_wakeup_event */ + 1, /* field[1] = twt_enable_keep_alive */ +}; +static const ProtobufCIntRange wifi_twt_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor wifi_twt_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "wifi_twt_config", + "WifiTwtConfig", + "WifiTwtConfig", + "", + sizeof(WifiTwtConfig), + 2, + wifi_twt_config__field_descriptors, + wifi_twt_config__field_indices_by_name, + 1, wifi_twt_config__number_ranges, + (ProtobufCMessageInit) wifi_twt_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor connected_stalist__field_descriptors[2] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(ConnectedSTAList, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(ConnectedSTAList, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned connected_stalist__field_indices_by_name[] = { + 0, /* field[0] = mac */ + 1, /* field[1] = rssi */ +}; +static const ProtobufCIntRange connected_stalist__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor connected_stalist__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "ConnectedSTAList", + "ConnectedSTAList", + "ConnectedSTAList", + "", + sizeof(ConnectedSTAList), + 2, + connected_stalist__field_descriptors, + connected_stalist__field_indices_by_name, + 1, connected_stalist__number_ranges, + (ProtobufCMessageInit) connected_stalist__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eap_fast_config__field_descriptors[3] = +{ + { + "fast_provisioning", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(EapFastConfig, fast_provisioning), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "fast_max_pac_list_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(EapFastConfig, fast_max_pac_list_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "fast_pac_format_binary", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(EapFastConfig, fast_pac_format_binary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eap_fast_config__field_indices_by_name[] = { + 1, /* field[1] = fast_max_pac_list_len */ + 2, /* field[2] = fast_pac_format_binary */ + 0, /* field[0] = fast_provisioning */ +}; +static const ProtobufCIntRange eap_fast_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor eap_fast_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "eap_fast_config", + "EapFastConfig", + "EapFastConfig", + "", + sizeof(EapFastConfig), + 3, + eap_fast_config__field_descriptors, + eap_fast_config__field_indices_by_name, + 1, eap_fast_config__number_ranges, + (ProtobufCMessageInit) eap_fast_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__get_mac_address__field_descriptors[1] = +{ + { + "mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqGetMacAddress, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__get_mac_address__field_indices_by_name[] = { + 0, /* field[0] = mode */ +}; +static const ProtobufCIntRange rpc__req__get_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__get_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetMacAddress", + "RpcReqGetMacAddress", + "RpcReqGetMacAddress", + "", + sizeof(RpcReqGetMacAddress), + 1, + rpc__req__get_mac_address__field_descriptors, + rpc__req__get_mac_address__field_indices_by_name, + 1, rpc__req__get_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__req__get_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_mac_address__field_descriptors[2] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMacAddress, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMacAddress, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_mac_address__field_indices_by_name[] = { + 0, /* field[0] = mac */ + 1, /* field[1] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetMacAddress", + "RpcRespGetMacAddress", + "RpcRespGetMacAddress", + "", + sizeof(RpcRespGetMacAddress), + 2, + rpc__resp__get_mac_address__field_descriptors, + rpc__resp__get_mac_address__field_indices_by_name, + 1, rpc__resp__get_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__get_mode__field_descriptors NULL +#define rpc__req__get_mode__field_indices_by_name NULL +#define rpc__req__get_mode__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__get_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetMode", + "RpcReqGetMode", + "RpcReqGetMode", + "", + sizeof(RpcReqGetMode), + 0, + rpc__req__get_mode__field_descriptors, + rpc__req__get_mode__field_indices_by_name, + 0, rpc__req__get_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__get_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_mode__field_descriptors[2] = +{ + { + "mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMode, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_mode__field_indices_by_name[] = { + 0, /* field[0] = mode */ + 1, /* field[1] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetMode", + "RpcRespGetMode", + "RpcRespGetMode", + "", + sizeof(RpcRespGetMode), + 2, + rpc__resp__get_mode__field_descriptors, + rpc__resp__get_mode__field_indices_by_name, + 1, rpc__resp__get_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_mode__field_descriptors[1] = +{ + { + "mode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetMode, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_mode__field_indices_by_name[] = { + 0, /* field[0] = mode */ +}; +static const ProtobufCIntRange rpc__req__set_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__set_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetMode", + "RpcReqSetMode", + "RpcReqSetMode", + "", + sizeof(RpcReqSetMode), + 1, + rpc__req__set_mode__field_descriptors, + rpc__req__set_mode__field_indices_by_name, + 1, rpc__req__set_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__set_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_mode__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_mode__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetMode", + "RpcRespSetMode", + "RpcRespSetMode", + "", + sizeof(RpcRespSetMode), + 1, + rpc__resp__set_mode__field_descriptors, + rpc__resp__set_mode__field_indices_by_name, + 1, rpc__resp__set_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__get_ps__field_descriptors NULL +#define rpc__req__get_ps__field_indices_by_name NULL +#define rpc__req__get_ps__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__get_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetPs", + "RpcReqGetPs", + "RpcReqGetPs", + "", + sizeof(RpcReqGetPs), + 0, + rpc__req__get_ps__field_descriptors, + rpc__req__get_ps__field_indices_by_name, + 0, rpc__req__get_ps__number_ranges, + (ProtobufCMessageInit) rpc__req__get_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_ps__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetPs, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetPs, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_ps__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = type */ +}; +static const ProtobufCIntRange rpc__resp__get_ps__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetPs", + "RpcRespGetPs", + "RpcRespGetPs", + "", + sizeof(RpcRespGetPs), + 2, + rpc__resp__get_ps__field_descriptors, + rpc__resp__get_ps__field_indices_by_name, + 1, rpc__resp__get_ps__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_ps__field_descriptors[1] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetPs, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_ps__field_indices_by_name[] = { + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange rpc__req__set_ps__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__set_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetPs", + "RpcReqSetPs", + "RpcReqSetPs", + "", + sizeof(RpcReqSetPs), + 1, + rpc__req__set_ps__field_descriptors, + rpc__req__set_ps__field_indices_by_name, + 1, rpc__req__set_ps__number_ranges, + (ProtobufCMessageInit) rpc__req__set_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_ps__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetPs, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_ps__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_ps__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_ps__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetPs", + "RpcRespSetPs", + "RpcRespSetPs", + "", + sizeof(RpcRespSetPs), + 1, + rpc__resp__set_ps__field_descriptors, + rpc__resp__set_ps__field_indices_by_name, + 1, rpc__resp__set_ps__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_ps__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_mac_address__field_descriptors[2] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSetMacAddress, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetMacAddress, mode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_mac_address__field_indices_by_name[] = { + 0, /* field[0] = mac */ + 1, /* field[1] = mode */ +}; +static const ProtobufCIntRange rpc__req__set_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__set_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetMacAddress", + "RpcReqSetMacAddress", + "RpcReqSetMacAddress", + "", + sizeof(RpcReqSetMacAddress), + 2, + rpc__req__set_mac_address__field_descriptors, + rpc__req__set_mac_address__field_indices_by_name, + 1, rpc__req__set_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__req__set_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_mac_address__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetMacAddress, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_mac_address__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_mac_address__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_mac_address__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetMacAddress", + "RpcRespSetMacAddress", + "RpcRespSetMacAddress", + "", + sizeof(RpcRespSetMacAddress), + 1, + rpc__resp__set_mac_address__field_descriptors, + rpc__resp__set_mac_address__field_indices_by_name, + 1, rpc__resp__set_mac_address__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_mac_address__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__otabegin__field_descriptors NULL +#define rpc__req__otabegin__field_indices_by_name NULL +#define rpc__req__otabegin__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__otabegin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_OTABegin", + "RpcReqOTABegin", + "RpcReqOTABegin", + "", + sizeof(RpcReqOTABegin), + 0, + rpc__req__otabegin__field_descriptors, + rpc__req__otabegin__field_indices_by_name, + 0, rpc__req__otabegin__number_ranges, + (ProtobufCMessageInit) rpc__req__otabegin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__otabegin__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespOTABegin, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__otabegin__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__otabegin__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__otabegin__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_OTABegin", + "RpcRespOTABegin", + "RpcRespOTABegin", + "", + sizeof(RpcRespOTABegin), + 1, + rpc__resp__otabegin__field_descriptors, + rpc__resp__otabegin__field_indices_by_name, + 1, rpc__resp__otabegin__number_ranges, + (ProtobufCMessageInit) rpc__resp__otabegin__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__otawrite__field_descriptors[1] = +{ + { + "ota_data", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqOTAWrite, ota_data), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__otawrite__field_indices_by_name[] = { + 0, /* field[0] = ota_data */ +}; +static const ProtobufCIntRange rpc__req__otawrite__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__otawrite__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_OTAWrite", + "RpcReqOTAWrite", + "RpcReqOTAWrite", + "", + sizeof(RpcReqOTAWrite), + 1, + rpc__req__otawrite__field_descriptors, + rpc__req__otawrite__field_indices_by_name, + 1, rpc__req__otawrite__number_ranges, + (ProtobufCMessageInit) rpc__req__otawrite__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__otawrite__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespOTAWrite, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__otawrite__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__otawrite__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__otawrite__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_OTAWrite", + "RpcRespOTAWrite", + "RpcRespOTAWrite", + "", + sizeof(RpcRespOTAWrite), + 1, + rpc__resp__otawrite__field_descriptors, + rpc__resp__otawrite__field_indices_by_name, + 1, rpc__resp__otawrite__number_ranges, + (ProtobufCMessageInit) rpc__resp__otawrite__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__otaend__field_descriptors NULL +#define rpc__req__otaend__field_indices_by_name NULL +#define rpc__req__otaend__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__otaend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_OTAEnd", + "RpcReqOTAEnd", + "RpcReqOTAEnd", + "", + sizeof(RpcReqOTAEnd), + 0, + rpc__req__otaend__field_descriptors, + rpc__req__otaend__field_indices_by_name, + 0, rpc__req__otaend__number_ranges, + (ProtobufCMessageInit) rpc__req__otaend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__otaend__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespOTAEnd, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__otaend__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__otaend__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__otaend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_OTAEnd", + "RpcRespOTAEnd", + "RpcRespOTAEnd", + "", + sizeof(RpcRespOTAEnd), + 1, + rpc__resp__otaend__field_descriptors, + rpc__resp__otaend__field_indices_by_name, + 1, rpc__resp__otaend__number_ranges, + (ProtobufCMessageInit) rpc__resp__otaend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_max_tx_power__field_descriptors[1] = +{ + { + "power", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetMaxTxPower, power), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_max_tx_power__field_indices_by_name[] = { + 0, /* field[0] = power */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_max_tx_power__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetMaxTxPower", + "RpcReqWifiSetMaxTxPower", + "RpcReqWifiSetMaxTxPower", + "", + sizeof(RpcReqWifiSetMaxTxPower), + 1, + rpc__req__wifi_set_max_tx_power__field_descriptors, + rpc__req__wifi_set_max_tx_power__field_indices_by_name, + 1, rpc__req__wifi_set_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_max_tx_power__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetMaxTxPower, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_max_tx_power__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_max_tx_power__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetMaxTxPower", + "RpcRespWifiSetMaxTxPower", + "RpcRespWifiSetMaxTxPower", + "", + sizeof(RpcRespWifiSetMaxTxPower), + 1, + rpc__resp__wifi_set_max_tx_power__field_descriptors, + rpc__resp__wifi_set_max_tx_power__field_indices_by_name, + 1, rpc__resp__wifi_set_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_max_tx_power__field_descriptors NULL +#define rpc__req__wifi_get_max_tx_power__field_indices_by_name NULL +#define rpc__req__wifi_get_max_tx_power__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetMaxTxPower", + "RpcReqWifiGetMaxTxPower", + "RpcReqWifiGetMaxTxPower", + "", + sizeof(RpcReqWifiGetMaxTxPower), + 0, + rpc__req__wifi_get_max_tx_power__field_descriptors, + rpc__req__wifi_get_max_tx_power__field_indices_by_name, + 0, rpc__req__wifi_get_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_max_tx_power__field_descriptors[2] = +{ + { + "power", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetMaxTxPower, power), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetMaxTxPower, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_max_tx_power__field_indices_by_name[] = { + 0, /* field[0] = power */ + 1, /* field[1] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_max_tx_power__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_max_tx_power__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetMaxTxPower", + "RpcRespWifiGetMaxTxPower", + "RpcRespWifiGetMaxTxPower", + "", + sizeof(RpcRespWifiGetMaxTxPower), + 2, + rpc__resp__wifi_get_max_tx_power__field_descriptors, + rpc__resp__wifi_get_max_tx_power__field_indices_by_name, + 1, rpc__resp__wifi_get_max_tx_power__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_max_tx_power__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__config_heartbeat__field_descriptors[2] = +{ + { + "enable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqConfigHeartbeat, enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "duration", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqConfigHeartbeat, duration), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__config_heartbeat__field_indices_by_name[] = { + 1, /* field[1] = duration */ + 0, /* field[0] = enable */ +}; +static const ProtobufCIntRange rpc__req__config_heartbeat__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__config_heartbeat__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_ConfigHeartbeat", + "RpcReqConfigHeartbeat", + "RpcReqConfigHeartbeat", + "", + sizeof(RpcReqConfigHeartbeat), + 2, + rpc__req__config_heartbeat__field_descriptors, + rpc__req__config_heartbeat__field_indices_by_name, + 1, rpc__req__config_heartbeat__number_ranges, + (ProtobufCMessageInit) rpc__req__config_heartbeat__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__config_heartbeat__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespConfigHeartbeat, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__config_heartbeat__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__config_heartbeat__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__config_heartbeat__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_ConfigHeartbeat", + "RpcRespConfigHeartbeat", + "RpcRespConfigHeartbeat", + "", + sizeof(RpcRespConfigHeartbeat), + 1, + rpc__resp__config_heartbeat__field_descriptors, + rpc__resp__config_heartbeat__field_indices_by_name, + 1, rpc__resp__config_heartbeat__number_ranges, + (ProtobufCMessageInit) rpc__resp__config_heartbeat__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_init__field_descriptors[1] = +{ + { + "cfg", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiInit, cfg), + &wifi_init_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_init__field_indices_by_name[] = { + 0, /* field[0] = cfg */ +}; +static const ProtobufCIntRange rpc__req__wifi_init__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_init__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiInit", + "RpcReqWifiInit", + "RpcReqWifiInit", + "", + sizeof(RpcReqWifiInit), + 1, + rpc__req__wifi_init__field_descriptors, + rpc__req__wifi_init__field_indices_by_name, + 1, rpc__req__wifi_init__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_init__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_init__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiInit, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_init__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_init__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_init__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiInit", + "RpcRespWifiInit", + "RpcRespWifiInit", + "", + sizeof(RpcRespWifiInit), + 1, + rpc__resp__wifi_init__field_descriptors, + rpc__resp__wifi_init__field_indices_by_name, + 1, rpc__resp__wifi_init__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_init__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_deinit__field_descriptors NULL +#define rpc__req__wifi_deinit__field_indices_by_name NULL +#define rpc__req__wifi_deinit__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_deinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiDeinit", + "RpcReqWifiDeinit", + "RpcReqWifiDeinit", + "", + sizeof(RpcReqWifiDeinit), + 0, + rpc__req__wifi_deinit__field_descriptors, + rpc__req__wifi_deinit__field_indices_by_name, + 0, rpc__req__wifi_deinit__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_deinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_deinit__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDeinit, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_deinit__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_deinit__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_deinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiDeinit", + "RpcRespWifiDeinit", + "RpcRespWifiDeinit", + "", + sizeof(RpcRespWifiDeinit), + 1, + rpc__resp__wifi_deinit__field_descriptors, + rpc__resp__wifi_deinit__field_indices_by_name, + 1, rpc__resp__wifi_deinit__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_deinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_config__field_descriptors[2] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetConfig, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cfg", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetConfig, cfg), + &wifi_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_config__field_indices_by_name[] = { + 1, /* field[1] = cfg */ + 0, /* field[0] = iface */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetConfig", + "RpcReqWifiSetConfig", + "RpcReqWifiSetConfig", + "", + sizeof(RpcReqWifiSetConfig), + 2, + rpc__req__wifi_set_config__field_descriptors, + rpc__req__wifi_set_config__field_indices_by_name, + 1, rpc__req__wifi_set_config__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_config__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetConfig, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_config__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetConfig", + "RpcRespWifiSetConfig", + "RpcRespWifiSetConfig", + "", + sizeof(RpcRespWifiSetConfig), + 1, + rpc__resp__wifi_set_config__field_descriptors, + rpc__resp__wifi_set_config__field_indices_by_name, + 1, rpc__resp__wifi_set_config__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_config__field_descriptors[1] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetConfig, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_config__field_indices_by_name[] = { + 0, /* field[0] = iface */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetConfig", + "RpcReqWifiGetConfig", + "RpcReqWifiGetConfig", + "", + sizeof(RpcReqWifiGetConfig), + 1, + rpc__req__wifi_get_config__field_descriptors, + rpc__req__wifi_get_config__field_indices_by_name, + 1, rpc__req__wifi_get_config__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_config__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetConfig, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "iface", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetConfig, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cfg", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetConfig, cfg), + &wifi_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_config__field_indices_by_name[] = { + 2, /* field[2] = cfg */ + 1, /* field[1] = iface */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetConfig", + "RpcRespWifiGetConfig", + "RpcRespWifiGetConfig", + "", + sizeof(RpcRespWifiGetConfig), + 3, + rpc__resp__wifi_get_config__field_descriptors, + rpc__resp__wifi_get_config__field_indices_by_name, + 1, rpc__resp__wifi_get_config__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_connect__field_descriptors NULL +#define rpc__req__wifi_connect__field_indices_by_name NULL +#define rpc__req__wifi_connect__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiConnect", + "RpcReqWifiConnect", + "RpcReqWifiConnect", + "", + sizeof(RpcReqWifiConnect), + 0, + rpc__req__wifi_connect__field_descriptors, + rpc__req__wifi_connect__field_indices_by_name, + 0, rpc__req__wifi_connect__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_connect__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiConnect, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_connect__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_connect__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiConnect", + "RpcRespWifiConnect", + "RpcRespWifiConnect", + "", + sizeof(RpcRespWifiConnect), + 1, + rpc__resp__wifi_connect__field_descriptors, + rpc__resp__wifi_connect__field_indices_by_name, + 1, rpc__resp__wifi_connect__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_disconnect__field_descriptors NULL +#define rpc__req__wifi_disconnect__field_indices_by_name NULL +#define rpc__req__wifi_disconnect__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_disconnect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiDisconnect", + "RpcReqWifiDisconnect", + "RpcReqWifiDisconnect", + "", + sizeof(RpcReqWifiDisconnect), + 0, + rpc__req__wifi_disconnect__field_descriptors, + rpc__req__wifi_disconnect__field_indices_by_name, + 0, rpc__req__wifi_disconnect__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_disconnect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_disconnect__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDisconnect, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_disconnect__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_disconnect__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_disconnect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiDisconnect", + "RpcRespWifiDisconnect", + "RpcRespWifiDisconnect", + "", + sizeof(RpcRespWifiDisconnect), + 1, + rpc__resp__wifi_disconnect__field_descriptors, + rpc__resp__wifi_disconnect__field_indices_by_name, + 1, rpc__resp__wifi_disconnect__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_disconnect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_start__field_descriptors NULL +#define rpc__req__wifi_start__field_indices_by_name NULL +#define rpc__req__wifi_start__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStart", + "RpcReqWifiStart", + "RpcReqWifiStart", + "", + sizeof(RpcReqWifiStart), + 0, + rpc__req__wifi_start__field_descriptors, + rpc__req__wifi_start__field_indices_by_name, + 0, rpc__req__wifi_start__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_start__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStart, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_start__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_start__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStart", + "RpcRespWifiStart", + "RpcRespWifiStart", + "", + sizeof(RpcRespWifiStart), + 1, + rpc__resp__wifi_start__field_descriptors, + rpc__resp__wifi_start__field_indices_by_name, + 1, rpc__resp__wifi_start__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_stop__field_descriptors NULL +#define rpc__req__wifi_stop__field_indices_by_name NULL +#define rpc__req__wifi_stop__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStop", + "RpcReqWifiStop", + "RpcReqWifiStop", + "", + sizeof(RpcReqWifiStop), + 0, + rpc__req__wifi_stop__field_descriptors, + rpc__req__wifi_stop__field_indices_by_name, + 0, rpc__req__wifi_stop__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_stop__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStop, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_stop__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_stop__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStop", + "RpcRespWifiStop", + "RpcRespWifiStop", + "", + sizeof(RpcRespWifiStop), + 1, + rpc__resp__wifi_stop__field_descriptors, + rpc__resp__wifi_stop__field_indices_by_name, + 1, rpc__resp__wifi_stop__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_scan_start__field_descriptors[3] = +{ + { + "config", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanStart, config), + &wifi_scan_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "block", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanStart, block), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "config_set", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanStart, config_set), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_scan_start__field_indices_by_name[] = { + 1, /* field[1] = block */ + 0, /* field[0] = config */ + 2, /* field[2] = config_set */ +}; +static const ProtobufCIntRange rpc__req__wifi_scan_start__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_scan_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanStart", + "RpcReqWifiScanStart", + "RpcReqWifiScanStart", + "", + sizeof(RpcReqWifiScanStart), + 3, + rpc__req__wifi_scan_start__field_descriptors, + rpc__req__wifi_scan_start__field_indices_by_name, + 1, rpc__req__wifi_scan_start__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_start__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanStart, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_start__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_start__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_start__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanStart", + "RpcRespWifiScanStart", + "RpcRespWifiScanStart", + "", + sizeof(RpcRespWifiScanStart), + 1, + rpc__resp__wifi_scan_start__field_descriptors, + rpc__resp__wifi_scan_start__field_indices_by_name, + 1, rpc__resp__wifi_scan_start__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_start__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_scan_stop__field_descriptors NULL +#define rpc__req__wifi_scan_stop__field_indices_by_name NULL +#define rpc__req__wifi_scan_stop__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_scan_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanStop", + "RpcReqWifiScanStop", + "RpcReqWifiScanStop", + "", + sizeof(RpcReqWifiScanStop), + 0, + rpc__req__wifi_scan_stop__field_descriptors, + rpc__req__wifi_scan_stop__field_indices_by_name, + 0, rpc__req__wifi_scan_stop__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_stop__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanStop, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_stop__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_stop__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_stop__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanStop", + "RpcRespWifiScanStop", + "RpcRespWifiScanStop", + "", + sizeof(RpcRespWifiScanStop), + 1, + rpc__resp__wifi_scan_stop__field_descriptors, + rpc__resp__wifi_scan_stop__field_indices_by_name, + 1, rpc__resp__wifi_scan_stop__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_stop__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_scan_get_ap_num__field_descriptors NULL +#define rpc__req__wifi_scan_get_ap_num__field_indices_by_name NULL +#define rpc__req__wifi_scan_get_ap_num__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_num__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanGetApNum", + "RpcReqWifiScanGetApNum", + "RpcReqWifiScanGetApNum", + "", + sizeof(RpcReqWifiScanGetApNum), + 0, + rpc__req__wifi_scan_get_ap_num__field_descriptors, + rpc__req__wifi_scan_get_ap_num__field_indices_by_name, + 0, rpc__req__wifi_scan_get_ap_num__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_get_ap_num__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_get_ap_num__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApNum, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "number", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApNum, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_get_ap_num__field_indices_by_name[] = { + 1, /* field[1] = number */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_get_ap_num__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_num__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanGetApNum", + "RpcRespWifiScanGetApNum", + "RpcRespWifiScanGetApNum", + "", + sizeof(RpcRespWifiScanGetApNum), + 2, + rpc__resp__wifi_scan_get_ap_num__field_descriptors, + rpc__resp__wifi_scan_get_ap_num__field_indices_by_name, + 1, rpc__resp__wifi_scan_get_ap_num__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_get_ap_num__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_scan_get_ap_records__field_descriptors[1] = +{ + { + "number", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiScanGetApRecords, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_scan_get_ap_records__field_indices_by_name[] = { + 0, /* field[0] = number */ +}; +static const ProtobufCIntRange rpc__req__wifi_scan_get_ap_records__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_records__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanGetApRecords", + "RpcReqWifiScanGetApRecords", + "RpcReqWifiScanGetApRecords", + "", + sizeof(RpcReqWifiScanGetApRecords), + 1, + rpc__req__wifi_scan_get_ap_records__field_descriptors, + rpc__req__wifi_scan_get_ap_records__field_indices_by_name, + 1, rpc__req__wifi_scan_get_ap_records__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_get_ap_records__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_get_ap_records__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecords, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "number", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecords, number), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_records", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(RpcRespWifiScanGetApRecords, n_ap_records), + offsetof(RpcRespWifiScanGetApRecords, ap_records), + &wifi_ap_record__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_get_ap_records__field_indices_by_name[] = { + 2, /* field[2] = ap_records */ + 1, /* field[1] = number */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_get_ap_records__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_records__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanGetApRecords", + "RpcRespWifiScanGetApRecords", + "RpcRespWifiScanGetApRecords", + "", + sizeof(RpcRespWifiScanGetApRecords), + 3, + rpc__resp__wifi_scan_get_ap_records__field_descriptors, + rpc__resp__wifi_scan_get_ap_records__field_indices_by_name, + 1, rpc__resp__wifi_scan_get_ap_records__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_get_ap_records__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_scan_get_ap_record__field_descriptors NULL +#define rpc__req__wifi_scan_get_ap_record__field_indices_by_name NULL +#define rpc__req__wifi_scan_get_ap_record__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_record__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiScanGetApRecord", + "RpcReqWifiScanGetApRecord", + "RpcReqWifiScanGetApRecord", + "", + sizeof(RpcReqWifiScanGetApRecord), + 0, + rpc__req__wifi_scan_get_ap_record__field_descriptors, + rpc__req__wifi_scan_get_ap_record__field_indices_by_name, + 0, rpc__req__wifi_scan_get_ap_record__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_scan_get_ap_record__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_scan_get_ap_record__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecord, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_record", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiScanGetApRecord, ap_record), + &wifi_ap_record__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_scan_get_ap_record__field_indices_by_name[] = { + 1, /* field[1] = ap_record */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_scan_get_ap_record__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_record__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiScanGetApRecord", + "RpcRespWifiScanGetApRecord", + "RpcRespWifiScanGetApRecord", + "", + sizeof(RpcRespWifiScanGetApRecord), + 2, + rpc__resp__wifi_scan_get_ap_record__field_descriptors, + rpc__resp__wifi_scan_get_ap_record__field_indices_by_name, + 1, rpc__resp__wifi_scan_get_ap_record__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_scan_get_ap_record__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_clear_ap_list__field_descriptors NULL +#define rpc__req__wifi_clear_ap_list__field_indices_by_name NULL +#define rpc__req__wifi_clear_ap_list__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_clear_ap_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiClearApList", + "RpcReqWifiClearApList", + "RpcReqWifiClearApList", + "", + sizeof(RpcReqWifiClearApList), + 0, + rpc__req__wifi_clear_ap_list__field_descriptors, + rpc__req__wifi_clear_ap_list__field_indices_by_name, + 0, rpc__req__wifi_clear_ap_list__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_clear_ap_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_clear_ap_list__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiClearApList, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_clear_ap_list__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_clear_ap_list__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_clear_ap_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiClearApList", + "RpcRespWifiClearApList", + "RpcRespWifiClearApList", + "", + sizeof(RpcRespWifiClearApList), + 1, + rpc__resp__wifi_clear_ap_list__field_descriptors, + rpc__resp__wifi_clear_ap_list__field_indices_by_name, + 1, rpc__resp__wifi_clear_ap_list__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_clear_ap_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_restore__field_descriptors NULL +#define rpc__req__wifi_restore__field_indices_by_name NULL +#define rpc__req__wifi_restore__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_restore__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiRestore", + "RpcReqWifiRestore", + "RpcReqWifiRestore", + "", + sizeof(RpcReqWifiRestore), + 0, + rpc__req__wifi_restore__field_descriptors, + rpc__req__wifi_restore__field_indices_by_name, + 0, rpc__req__wifi_restore__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_restore__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_restore__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiRestore, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_restore__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_restore__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_restore__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiRestore", + "RpcRespWifiRestore", + "RpcRespWifiRestore", + "", + sizeof(RpcRespWifiRestore), + 1, + rpc__resp__wifi_restore__field_descriptors, + rpc__resp__wifi_restore__field_indices_by_name, + 1, rpc__resp__wifi_restore__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_restore__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_clear_fast_connect__field_descriptors NULL +#define rpc__req__wifi_clear_fast_connect__field_indices_by_name NULL +#define rpc__req__wifi_clear_fast_connect__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_clear_fast_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiClearFastConnect", + "RpcReqWifiClearFastConnect", + "RpcReqWifiClearFastConnect", + "", + sizeof(RpcReqWifiClearFastConnect), + 0, + rpc__req__wifi_clear_fast_connect__field_descriptors, + rpc__req__wifi_clear_fast_connect__field_indices_by_name, + 0, rpc__req__wifi_clear_fast_connect__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_clear_fast_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_clear_fast_connect__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiClearFastConnect, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_clear_fast_connect__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_clear_fast_connect__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_clear_fast_connect__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiClearFastConnect", + "RpcRespWifiClearFastConnect", + "RpcRespWifiClearFastConnect", + "", + sizeof(RpcRespWifiClearFastConnect), + 1, + rpc__resp__wifi_clear_fast_connect__field_descriptors, + rpc__resp__wifi_clear_fast_connect__field_indices_by_name, + 1, rpc__resp__wifi_clear_fast_connect__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_clear_fast_connect__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_deauth_sta__field_descriptors[1] = +{ + { + "aid", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiDeauthSta, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_deauth_sta__field_indices_by_name[] = { + 0, /* field[0] = aid */ +}; +static const ProtobufCIntRange rpc__req__wifi_deauth_sta__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_deauth_sta__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiDeauthSta", + "RpcReqWifiDeauthSta", + "RpcReqWifiDeauthSta", + "", + sizeof(RpcReqWifiDeauthSta), + 1, + rpc__req__wifi_deauth_sta__field_descriptors, + rpc__req__wifi_deauth_sta__field_indices_by_name, + 1, rpc__req__wifi_deauth_sta__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_deauth_sta__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_deauth_sta__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDeauthSta, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiDeauthSta, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_deauth_sta__field_indices_by_name[] = { + 1, /* field[1] = aid */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_deauth_sta__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_deauth_sta__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiDeauthSta", + "RpcRespWifiDeauthSta", + "RpcRespWifiDeauthSta", + "", + sizeof(RpcRespWifiDeauthSta), + 2, + rpc__resp__wifi_deauth_sta__field_descriptors, + rpc__resp__wifi_deauth_sta__field_indices_by_name, + 1, rpc__resp__wifi_deauth_sta__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_deauth_sta__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_ap_info__field_descriptors NULL +#define rpc__req__wifi_sta_get_ap_info__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_ap_info__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_ap_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetApInfo", + "RpcReqWifiStaGetApInfo", + "RpcReqWifiStaGetApInfo", + "", + sizeof(RpcReqWifiStaGetApInfo), + 0, + rpc__req__wifi_sta_get_ap_info__field_descriptors, + rpc__req__wifi_sta_get_ap_info__field_indices_by_name, + 0, rpc__req__wifi_sta_get_ap_info__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_ap_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_ap_info__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetApInfo, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ap_record", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetApInfo, ap_record), + &wifi_ap_record__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_ap_info__field_indices_by_name[] = { + 1, /* field[1] = ap_record */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_ap_info__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_ap_info__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetApInfo", + "RpcRespWifiStaGetApInfo", + "RpcRespWifiStaGetApInfo", + "", + sizeof(RpcRespWifiStaGetApInfo), + 2, + rpc__resp__wifi_sta_get_ap_info__field_descriptors, + rpc__resp__wifi_sta_get_ap_info__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_ap_info__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_ap_info__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_protocol__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocol, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocol_bitmap", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocol, protocol_bitmap), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_protocol__field_indices_by_name[] = { + 0, /* field[0] = ifx */ + 1, /* field[1] = protocol_bitmap */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetProtocol", + "RpcReqWifiSetProtocol", + "RpcReqWifiSetProtocol", + "", + sizeof(RpcReqWifiSetProtocol), + 2, + rpc__req__wifi_set_protocol__field_descriptors, + rpc__req__wifi_set_protocol__field_indices_by_name, + 1, rpc__req__wifi_set_protocol__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_protocol__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetProtocol, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_protocol__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetProtocol", + "RpcRespWifiSetProtocol", + "RpcRespWifiSetProtocol", + "", + sizeof(RpcRespWifiSetProtocol), + 1, + rpc__resp__wifi_set_protocol__field_descriptors, + rpc__resp__wifi_set_protocol__field_indices_by_name, + 1, rpc__resp__wifi_set_protocol__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_protocol__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetProtocol, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_protocol__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetProtocol", + "RpcReqWifiGetProtocol", + "RpcReqWifiGetProtocol", + "", + sizeof(RpcReqWifiGetProtocol), + 1, + rpc__req__wifi_get_protocol__field_descriptors, + rpc__req__wifi_get_protocol__field_indices_by_name, + 1, rpc__req__wifi_get_protocol__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_protocol__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocol, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocol_bitmap", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocol, protocol_bitmap), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_protocol__field_indices_by_name[] = { + 1, /* field[1] = protocol_bitmap */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_protocol__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocol__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetProtocol", + "RpcRespWifiGetProtocol", + "RpcRespWifiGetProtocol", + "", + sizeof(RpcRespWifiGetProtocol), + 2, + rpc__resp__wifi_get_protocol__field_descriptors, + rpc__resp__wifi_get_protocol__field_indices_by_name, + 1, rpc__resp__wifi_get_protocol__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_protocol__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_bandwidth__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidth, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bw", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidth, bw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_bandwidth__field_indices_by_name[] = { + 1, /* field[1] = bw */ + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBandwidth", + "RpcReqWifiSetBandwidth", + "RpcReqWifiSetBandwidth", + "", + sizeof(RpcReqWifiSetBandwidth), + 2, + rpc__req__wifi_set_bandwidth__field_descriptors, + rpc__req__wifi_set_bandwidth__field_indices_by_name, + 1, rpc__req__wifi_set_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_bandwidth__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandwidth, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_bandwidth__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBandwidth", + "RpcRespWifiSetBandwidth", + "RpcRespWifiSetBandwidth", + "", + sizeof(RpcRespWifiSetBandwidth), + 1, + rpc__resp__wifi_set_bandwidth__field_descriptors, + rpc__resp__wifi_set_bandwidth__field_indices_by_name, + 1, rpc__resp__wifi_set_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_bandwidth__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetBandwidth, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_bandwidth__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBandwidth", + "RpcReqWifiGetBandwidth", + "RpcReqWifiGetBandwidth", + "", + sizeof(RpcReqWifiGetBandwidth), + 1, + rpc__req__wifi_get_bandwidth__field_descriptors, + rpc__req__wifi_get_bandwidth__field_indices_by_name, + 1, rpc__req__wifi_get_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_bandwidth__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidth, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bw", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidth, bw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_bandwidth__field_indices_by_name[] = { + 1, /* field[1] = bw */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_bandwidth__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidth__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBandwidth", + "RpcRespWifiGetBandwidth", + "RpcRespWifiGetBandwidth", + "", + sizeof(RpcRespWifiGetBandwidth), + 2, + rpc__resp__wifi_get_bandwidth__field_descriptors, + rpc__resp__wifi_get_bandwidth__field_indices_by_name, + 1, rpc__resp__wifi_get_bandwidth__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_bandwidth__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_channel__field_descriptors[2] = +{ + { + "primary", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetChannel, primary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "second", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetChannel, second), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_channel__field_indices_by_name[] = { + 0, /* field[0] = primary */ + 1, /* field[1] = second */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_channel__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetChannel", + "RpcReqWifiSetChannel", + "RpcReqWifiSetChannel", + "", + sizeof(RpcReqWifiSetChannel), + 2, + rpc__req__wifi_set_channel__field_descriptors, + rpc__req__wifi_set_channel__field_indices_by_name, + 1, rpc__req__wifi_set_channel__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_channel__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetChannel, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_channel__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_channel__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetChannel", + "RpcRespWifiSetChannel", + "RpcRespWifiSetChannel", + "", + sizeof(RpcRespWifiSetChannel), + 1, + rpc__resp__wifi_set_channel__field_descriptors, + rpc__resp__wifi_set_channel__field_indices_by_name, + 1, rpc__resp__wifi_set_channel__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_channel__field_descriptors NULL +#define rpc__req__wifi_get_channel__field_indices_by_name NULL +#define rpc__req__wifi_get_channel__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetChannel", + "RpcReqWifiGetChannel", + "RpcReqWifiGetChannel", + "", + sizeof(RpcReqWifiGetChannel), + 0, + rpc__req__wifi_get_channel__field_descriptors, + rpc__req__wifi_get_channel__field_indices_by_name, + 0, rpc__req__wifi_get_channel__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_channel__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetChannel, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "primary", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetChannel, primary), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "second", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetChannel, second), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_channel__field_indices_by_name[] = { + 1, /* field[1] = primary */ + 0, /* field[0] = resp */ + 2, /* field[2] = second */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_channel__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_channel__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetChannel", + "RpcRespWifiGetChannel", + "RpcRespWifiGetChannel", + "", + sizeof(RpcRespWifiGetChannel), + 3, + rpc__resp__wifi_get_channel__field_descriptors, + rpc__resp__wifi_get_channel__field_indices_by_name, + 1, rpc__resp__wifi_get_channel__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_channel__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_storage__field_descriptors[1] = +{ + { + "storage", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetStorage, storage), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_storage__field_indices_by_name[] = { + 0, /* field[0] = storage */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_storage__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_storage__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetStorage", + "RpcReqWifiSetStorage", + "RpcReqWifiSetStorage", + "", + sizeof(RpcReqWifiSetStorage), + 1, + rpc__req__wifi_set_storage__field_descriptors, + rpc__req__wifi_set_storage__field_indices_by_name, + 1, rpc__req__wifi_set_storage__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_storage__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_storage__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetStorage, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_storage__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_storage__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_storage__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetStorage", + "RpcRespWifiSetStorage", + "RpcRespWifiSetStorage", + "", + sizeof(RpcRespWifiSetStorage), + 1, + rpc__resp__wifi_set_storage__field_descriptors, + rpc__resp__wifi_set_storage__field_indices_by_name, + 1, rpc__resp__wifi_set_storage__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_storage__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_country_code__field_descriptors[2] = +{ + { + "country", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetCountryCode, country), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ieee80211d_enabled", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetCountryCode, ieee80211d_enabled), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_country_code__field_indices_by_name[] = { + 0, /* field[0] = country */ + 1, /* field[1] = ieee80211d_enabled */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_country_code__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetCountryCode", + "RpcReqWifiSetCountryCode", + "RpcReqWifiSetCountryCode", + "", + sizeof(RpcReqWifiSetCountryCode), + 2, + rpc__req__wifi_set_country_code__field_descriptors, + rpc__req__wifi_set_country_code__field_indices_by_name, + 1, rpc__req__wifi_set_country_code__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_country_code__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetCountryCode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_country_code__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_country_code__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetCountryCode", + "RpcRespWifiSetCountryCode", + "RpcRespWifiSetCountryCode", + "", + sizeof(RpcRespWifiSetCountryCode), + 1, + rpc__resp__wifi_set_country_code__field_descriptors, + rpc__resp__wifi_set_country_code__field_indices_by_name, + 1, rpc__resp__wifi_set_country_code__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_country_code__field_descriptors NULL +#define rpc__req__wifi_get_country_code__field_indices_by_name NULL +#define rpc__req__wifi_get_country_code__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetCountryCode", + "RpcReqWifiGetCountryCode", + "RpcReqWifiGetCountryCode", + "", + sizeof(RpcReqWifiGetCountryCode), + 0, + rpc__req__wifi_get_country_code__field_descriptors, + rpc__req__wifi_get_country_code__field_indices_by_name, + 0, rpc__req__wifi_get_country_code__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_country_code__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountryCode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "country", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountryCode, country), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_country_code__field_indices_by_name[] = { + 1, /* field[1] = country */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_country_code__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_country_code__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetCountryCode", + "RpcRespWifiGetCountryCode", + "RpcRespWifiGetCountryCode", + "", + sizeof(RpcRespWifiGetCountryCode), + 2, + rpc__resp__wifi_get_country_code__field_descriptors, + rpc__resp__wifi_get_country_code__field_indices_by_name, + 1, rpc__resp__wifi_get_country_code__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_country_code__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_country__field_descriptors[1] = +{ + { + "country", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetCountry, country), + &wifi_country__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_country__field_indices_by_name[] = { + 0, /* field[0] = country */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetCountry", + "RpcReqWifiSetCountry", + "RpcReqWifiSetCountry", + "", + sizeof(RpcReqWifiSetCountry), + 1, + rpc__req__wifi_set_country__field_descriptors, + rpc__req__wifi_set_country__field_indices_by_name, + 1, rpc__req__wifi_set_country__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_country__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetCountry, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_country__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetCountry", + "RpcRespWifiSetCountry", + "RpcRespWifiSetCountry", + "", + sizeof(RpcRespWifiSetCountry), + 1, + rpc__resp__wifi_set_country__field_descriptors, + rpc__resp__wifi_set_country__field_indices_by_name, + 1, rpc__resp__wifi_set_country__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_country__field_descriptors NULL +#define rpc__req__wifi_get_country__field_indices_by_name NULL +#define rpc__req__wifi_get_country__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetCountry", + "RpcReqWifiGetCountry", + "RpcReqWifiGetCountry", + "", + sizeof(RpcReqWifiGetCountry), + 0, + rpc__req__wifi_get_country__field_descriptors, + rpc__req__wifi_get_country__field_indices_by_name, + 0, rpc__req__wifi_get_country__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_country__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountry, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "country", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetCountry, country), + &wifi_country__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_country__field_indices_by_name[] = { + 1, /* field[1] = country */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_country__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_country__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetCountry", + "RpcRespWifiGetCountry", + "RpcRespWifiGetCountry", + "", + sizeof(RpcRespWifiGetCountry), + 2, + rpc__resp__wifi_get_country__field_descriptors, + rpc__resp__wifi_get_country__field_indices_by_name, + 1, rpc__resp__wifi_get_country__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_country__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_ap_get_sta_list__field_descriptors NULL +#define rpc__req__wifi_ap_get_sta_list__field_indices_by_name NULL +#define rpc__req__wifi_ap_get_sta_list__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiApGetStaList", + "RpcReqWifiApGetStaList", + "RpcReqWifiApGetStaList", + "", + sizeof(RpcReqWifiApGetStaList), + 0, + rpc__req__wifi_ap_get_sta_list__field_descriptors, + rpc__req__wifi_ap_get_sta_list__field_indices_by_name, + 0, rpc__req__wifi_ap_get_sta_list__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_ap_get_sta_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_ap_get_sta_list__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaList, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_list", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaList, sta_list), + &wifi_sta_list__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_ap_get_sta_list__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sta_list */ +}; +static const ProtobufCIntRange rpc__resp__wifi_ap_get_sta_list__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_list__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiApGetStaList", + "RpcRespWifiApGetStaList", + "RpcRespWifiApGetStaList", + "", + sizeof(RpcRespWifiApGetStaList), + 2, + rpc__resp__wifi_ap_get_sta_list__field_descriptors, + rpc__resp__wifi_ap_get_sta_list__field_indices_by_name, + 1, rpc__resp__wifi_ap_get_sta_list__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_ap_get_sta_list__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_ap_get_sta_aid__field_descriptors[1] = +{ + { + "mac", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiApGetStaAid, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_ap_get_sta_aid__field_indices_by_name[] = { + 0, /* field[0] = mac */ +}; +static const ProtobufCIntRange rpc__req__wifi_ap_get_sta_aid__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiApGetStaAid", + "RpcReqWifiApGetStaAid", + "RpcReqWifiApGetStaAid", + "", + sizeof(RpcReqWifiApGetStaAid), + 1, + rpc__req__wifi_ap_get_sta_aid__field_descriptors, + rpc__req__wifi_ap_get_sta_aid__field_indices_by_name, + 1, rpc__req__wifi_ap_get_sta_aid__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_ap_get_sta_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_negotiated_phymode__field_descriptors NULL +#define rpc__req__wifi_sta_get_negotiated_phymode__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_negotiated_phymode__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_negotiated_phymode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetNegotiatedPhymode", + "RpcReqWifiStaGetNegotiatedPhymode", + "RpcReqWifiStaGetNegotiatedPhymode", + "", + sizeof(RpcReqWifiStaGetNegotiatedPhymode), + 0, + rpc__req__wifi_sta_get_negotiated_phymode__field_descriptors, + rpc__req__wifi_sta_get_negotiated_phymode__field_indices_by_name, + 0, rpc__req__wifi_sta_get_negotiated_phymode__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_negotiated_phymode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetNegotiatedPhymode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "phymode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetNegotiatedPhymode, phymode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_negotiated_phymode__field_indices_by_name[] = { + 1, /* field[1] = phymode */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_negotiated_phymode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetNegotiatedPhymode", + "RpcRespWifiStaGetNegotiatedPhymode", + "RpcRespWifiStaGetNegotiatedPhymode", + "", + sizeof(RpcRespWifiStaGetNegotiatedPhymode), + 2, + rpc__resp__wifi_sta_get_negotiated_phymode__field_descriptors, + rpc__resp__wifi_sta_get_negotiated_phymode__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_negotiated_phymode__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_negotiated_phymode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_ap_get_sta_aid__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaAid, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiApGetStaAid, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_ap_get_sta_aid__field_indices_by_name[] = { + 1, /* field[1] = aid */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_ap_get_sta_aid__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiApGetStaAid", + "RpcRespWifiApGetStaAid", + "RpcRespWifiApGetStaAid", + "", + sizeof(RpcRespWifiApGetStaAid), + 2, + rpc__resp__wifi_ap_get_sta_aid__field_descriptors, + rpc__resp__wifi_ap_get_sta_aid__field_indices_by_name, + 1, rpc__resp__wifi_ap_get_sta_aid__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_ap_get_sta_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_rssi__field_descriptors NULL +#define rpc__req__wifi_sta_get_rssi__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_rssi__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_rssi__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetRssi", + "RpcReqWifiStaGetRssi", + "RpcReqWifiStaGetRssi", + "", + sizeof(RpcReqWifiStaGetRssi), + 0, + rpc__req__wifi_sta_get_rssi__field_descriptors, + rpc__req__wifi_sta_get_rssi__field_indices_by_name, + 0, rpc__req__wifi_sta_get_rssi__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_rssi__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_rssi__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetRssi, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetRssi, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_rssi__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = rssi */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_rssi__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_rssi__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetRssi", + "RpcRespWifiStaGetRssi", + "RpcRespWifiStaGetRssi", + "", + sizeof(RpcRespWifiStaGetRssi), + 2, + rpc__resp__wifi_sta_get_rssi__field_descriptors, + rpc__resp__wifi_sta_get_rssi__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_rssi__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_rssi__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_get_aid__field_descriptors NULL +#define rpc__req__wifi_sta_get_aid__field_indices_by_name NULL +#define rpc__req__wifi_sta_get_aid__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaGetAid", + "RpcReqWifiStaGetAid", + "RpcReqWifiStaGetAid", + "", + sizeof(RpcReqWifiStaGetAid), + 0, + rpc__req__wifi_sta_get_aid__field_descriptors, + rpc__req__wifi_sta_get_aid__field_indices_by_name, + 0, rpc__req__wifi_sta_get_aid__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_get_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_get_aid__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetAid, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaGetAid, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_get_aid__field_indices_by_name[] = { + 1, /* field[1] = aid */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_get_aid__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_aid__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaGetAid", + "RpcRespWifiStaGetAid", + "RpcRespWifiStaGetAid", + "", + sizeof(RpcRespWifiStaGetAid), + 2, + rpc__resp__wifi_sta_get_aid__field_descriptors, + rpc__resp__wifi_sta_get_aid__field_indices_by_name, + 1, rpc__resp__wifi_sta_get_aid__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_get_aid__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_protocols__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocols", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetProtocols, protocols), + &wifi_protocols__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_protocols__field_indices_by_name[] = { + 0, /* field[0] = ifx */ + 1, /* field[1] = protocols */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetProtocols", + "RpcReqWifiSetProtocols", + "RpcReqWifiSetProtocols", + "", + sizeof(RpcReqWifiSetProtocols), + 2, + rpc__req__wifi_set_protocols__field_descriptors, + rpc__req__wifi_set_protocols__field_indices_by_name, + 1, rpc__req__wifi_set_protocols__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_protocols__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetProtocols, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_protocols__field_indices_by_name[] = { + 1, /* field[1] = ifx */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetProtocols", + "RpcRespWifiSetProtocols", + "RpcRespWifiSetProtocols", + "", + sizeof(RpcRespWifiSetProtocols), + 2, + rpc__resp__wifi_set_protocols__field_descriptors, + rpc__resp__wifi_set_protocols__field_indices_by_name, + 1, rpc__resp__wifi_set_protocols__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_protocols__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_protocols__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetProtocols", + "RpcReqWifiGetProtocols", + "RpcReqWifiGetProtocols", + "", + sizeof(RpcReqWifiGetProtocols), + 1, + rpc__req__wifi_get_protocols__field_descriptors, + rpc__req__wifi_get_protocols__field_indices_by_name, + 1, rpc__req__wifi_get_protocols__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_protocols__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocols, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocols, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "protocols", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetProtocols, protocols), + &wifi_protocols__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_protocols__field_indices_by_name[] = { + 1, /* field[1] = ifx */ + 2, /* field[2] = protocols */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_protocols__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocols__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetProtocols", + "RpcRespWifiGetProtocols", + "RpcRespWifiGetProtocols", + "", + sizeof(RpcRespWifiGetProtocols), + 3, + rpc__resp__wifi_get_protocols__field_descriptors, + rpc__resp__wifi_get_protocols__field_indices_by_name, + 1, rpc__resp__wifi_get_protocols__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_protocols__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_bandwidths__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidths", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandwidths, bandwidths), + &wifi_bandwidths__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_bandwidths__field_indices_by_name[] = { + 1, /* field[1] = bandwidths */ + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBandwidths", + "RpcReqWifiSetBandwidths", + "RpcReqWifiSetBandwidths", + "", + sizeof(RpcReqWifiSetBandwidths), + 2, + rpc__req__wifi_set_bandwidths__field_descriptors, + rpc__req__wifi_set_bandwidths__field_indices_by_name, + 1, rpc__req__wifi_set_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_bandwidths__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandwidths, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_bandwidths__field_indices_by_name[] = { + 1, /* field[1] = ifx */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBandwidths", + "RpcRespWifiSetBandwidths", + "RpcRespWifiSetBandwidths", + "", + sizeof(RpcRespWifiSetBandwidths), + 2, + rpc__resp__wifi_set_bandwidths__field_descriptors, + rpc__resp__wifi_set_bandwidths__field_indices_by_name, + 1, rpc__resp__wifi_set_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_bandwidths__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_bandwidths__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBandwidths", + "RpcReqWifiGetBandwidths", + "RpcReqWifiGetBandwidths", + "", + sizeof(RpcReqWifiGetBandwidths), + 1, + rpc__req__wifi_get_bandwidths__field_descriptors, + rpc__req__wifi_get_bandwidths__field_indices_by_name, + 1, rpc__req__wifi_get_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_bandwidths__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidths, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ifx", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidths, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidths", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandwidths, bandwidths), + &wifi_bandwidths__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_bandwidths__field_indices_by_name[] = { + 2, /* field[2] = bandwidths */ + 1, /* field[1] = ifx */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_bandwidths__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidths__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBandwidths", + "RpcRespWifiGetBandwidths", + "RpcRespWifiGetBandwidths", + "", + sizeof(RpcRespWifiGetBandwidths), + 3, + rpc__resp__wifi_get_bandwidths__field_descriptors, + rpc__resp__wifi_get_bandwidths__field_indices_by_name, + 1, rpc__resp__wifi_get_bandwidths__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_bandwidths__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_band__field_descriptors[1] = +{ + { + "band", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBand, band), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_band__field_indices_by_name[] = { + 0, /* field[0] = band */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_band__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBand", + "RpcReqWifiSetBand", + "RpcReqWifiSetBand", + "", + sizeof(RpcReqWifiSetBand), + 1, + rpc__req__wifi_set_band__field_descriptors, + rpc__req__wifi_set_band__field_indices_by_name, + 1, rpc__req__wifi_set_band__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_band__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBand, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_band__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_band__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBand", + "RpcRespWifiSetBand", + "RpcRespWifiSetBand", + "", + sizeof(RpcRespWifiSetBand), + 1, + rpc__resp__wifi_set_band__field_descriptors, + rpc__resp__wifi_set_band__field_indices_by_name, + 1, rpc__resp__wifi_set_band__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_band__field_descriptors NULL +#define rpc__req__wifi_get_band__field_indices_by_name NULL +#define rpc__req__wifi_get_band__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBand", + "RpcReqWifiGetBand", + "RpcReqWifiGetBand", + "", + sizeof(RpcReqWifiGetBand), + 0, + rpc__req__wifi_get_band__field_descriptors, + rpc__req__wifi_get_band__field_indices_by_name, + 0, rpc__req__wifi_get_band__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_band__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBand, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "band", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBand, band), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_band__field_indices_by_name[] = { + 1, /* field[1] = band */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_band__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_band__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBand", + "RpcRespWifiGetBand", + "RpcRespWifiGetBand", + "", + sizeof(RpcRespWifiGetBand), + 2, + rpc__resp__wifi_get_band__field_descriptors, + rpc__resp__wifi_get_band__field_indices_by_name, + 1, rpc__resp__wifi_get_band__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_band__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_band_mode__field_descriptors[1] = +{ + { + "bandmode", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetBandMode, bandmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_band_mode__field_indices_by_name[] = { + 0, /* field[0] = bandmode */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_band_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetBandMode", + "RpcReqWifiSetBandMode", + "RpcReqWifiSetBandMode", + "", + sizeof(RpcReqWifiSetBandMode), + 1, + rpc__req__wifi_set_band_mode__field_descriptors, + rpc__req__wifi_set_band_mode__field_indices_by_name, + 1, rpc__req__wifi_set_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_band_mode__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetBandMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_band_mode__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_band_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetBandMode", + "RpcRespWifiSetBandMode", + "RpcRespWifiSetBandMode", + "", + sizeof(RpcRespWifiSetBandMode), + 1, + rpc__resp__wifi_set_band_mode__field_descriptors, + rpc__resp__wifi_set_band_mode__field_indices_by_name, + 1, rpc__resp__wifi_set_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_get_band_mode__field_descriptors NULL +#define rpc__req__wifi_get_band_mode__field_indices_by_name NULL +#define rpc__req__wifi_get_band_mode__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_get_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetBandMode", + "RpcReqWifiGetBandMode", + "RpcReqWifiGetBandMode", + "", + sizeof(RpcReqWifiGetBandMode), + 0, + rpc__req__wifi_get_band_mode__field_descriptors, + rpc__req__wifi_get_band_mode__field_indices_by_name, + 0, rpc__req__wifi_get_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_band_mode__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandMode, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandmode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetBandMode, bandmode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_band_mode__field_indices_by_name[] = { + 1, /* field[1] = bandmode */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_band_mode__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_band_mode__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetBandMode", + "RpcRespWifiGetBandMode", + "RpcRespWifiGetBandMode", + "", + sizeof(RpcRespWifiGetBandMode), + 2, + rpc__resp__wifi_get_band_mode__field_descriptors, + rpc__resp__wifi_get_band_mode__field_indices_by_name, + 1, rpc__resp__wifi_get_band_mode__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_band_mode__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_inactive_time__field_descriptors[2] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetInactiveTime, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sec", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetInactiveTime, sec), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_inactive_time__field_indices_by_name[] = { + 0, /* field[0] = ifx */ + 1, /* field[1] = sec */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_inactive_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_inactive_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetInactiveTime", + "RpcReqWifiSetInactiveTime", + "RpcReqWifiSetInactiveTime", + "", + sizeof(RpcReqWifiSetInactiveTime), + 2, + rpc__req__wifi_set_inactive_time__field_descriptors, + rpc__req__wifi_set_inactive_time__field_indices_by_name, + 1, rpc__req__wifi_set_inactive_time__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_inactive_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_inactive_time__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetInactiveTime, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_inactive_time__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_inactive_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_inactive_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetInactiveTime", + "RpcRespWifiSetInactiveTime", + "RpcRespWifiSetInactiveTime", + "", + sizeof(RpcRespWifiSetInactiveTime), + 1, + rpc__resp__wifi_set_inactive_time__field_descriptors, + rpc__resp__wifi_set_inactive_time__field_indices_by_name, + 1, rpc__resp__wifi_set_inactive_time__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_inactive_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_get_inactive_time__field_descriptors[1] = +{ + { + "ifx", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiGetInactiveTime, ifx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_get_inactive_time__field_indices_by_name[] = { + 0, /* field[0] = ifx */ +}; +static const ProtobufCIntRange rpc__req__wifi_get_inactive_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_get_inactive_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiGetInactiveTime", + "RpcReqWifiGetInactiveTime", + "RpcReqWifiGetInactiveTime", + "", + sizeof(RpcReqWifiGetInactiveTime), + 1, + rpc__req__wifi_get_inactive_time__field_descriptors, + rpc__req__wifi_get_inactive_time__field_indices_by_name, + 1, rpc__req__wifi_get_inactive_time__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_get_inactive_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_get_inactive_time__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetInactiveTime, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sec", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiGetInactiveTime, sec), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_get_inactive_time__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sec */ +}; +static const ProtobufCIntRange rpc__resp__wifi_get_inactive_time__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_get_inactive_time__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiGetInactiveTime", + "RpcRespWifiGetInactiveTime", + "RpcRespWifiGetInactiveTime", + "", + sizeof(RpcRespWifiGetInactiveTime), + 2, + rpc__resp__wifi_get_inactive_time__field_descriptors, + rpc__resp__wifi_get_inactive_time__field_indices_by_name, + 1, rpc__resp__wifi_get_inactive_time__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_get_inactive_time__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_sta_itwt_setup__field_descriptors[1] = +{ + { + "setup_config", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaItwtSetup, setup_config), + &wifi_itwt_setup_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_sta_itwt_setup__field_indices_by_name[] = { + 0, /* field[0] = setup_config */ +}; +static const ProtobufCIntRange rpc__req__wifi_sta_itwt_setup__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_setup__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaItwtSetup", + "RpcReqWifiStaItwtSetup", + "RpcReqWifiStaItwtSetup", + "", + sizeof(RpcReqWifiStaItwtSetup), + 1, + rpc__req__wifi_sta_itwt_setup__field_descriptors, + rpc__req__wifi_sta_itwt_setup__field_indices_by_name, + 1, rpc__req__wifi_sta_itwt_setup__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_itwt_setup__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_itwt_setup__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtSetup, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_itwt_setup__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_itwt_setup__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_setup__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaItwtSetup", + "RpcRespWifiStaItwtSetup", + "RpcRespWifiStaItwtSetup", + "", + sizeof(RpcRespWifiStaItwtSetup), + 1, + rpc__resp__wifi_sta_itwt_setup__field_descriptors, + rpc__resp__wifi_sta_itwt_setup__field_indices_by_name, + 1, rpc__resp__wifi_sta_itwt_setup__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_itwt_setup__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_sta_itwt_teardown__field_descriptors[1] = +{ + { + "flow_id", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaItwtTeardown, flow_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_sta_itwt_teardown__field_indices_by_name[] = { + 0, /* field[0] = flow_id */ +}; +static const ProtobufCIntRange rpc__req__wifi_sta_itwt_teardown__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_teardown__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaItwtTeardown", + "RpcReqWifiStaItwtTeardown", + "RpcReqWifiStaItwtTeardown", + "", + sizeof(RpcReqWifiStaItwtTeardown), + 1, + rpc__req__wifi_sta_itwt_teardown__field_descriptors, + rpc__req__wifi_sta_itwt_teardown__field_indices_by_name, + 1, rpc__req__wifi_sta_itwt_teardown__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_itwt_teardown__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_itwt_teardown__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtTeardown, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_itwt_teardown__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_itwt_teardown__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_teardown__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaItwtTeardown", + "RpcRespWifiStaItwtTeardown", + "RpcRespWifiStaItwtTeardown", + "", + sizeof(RpcRespWifiStaItwtTeardown), + 1, + rpc__resp__wifi_sta_itwt_teardown__field_descriptors, + rpc__resp__wifi_sta_itwt_teardown__field_indices_by_name, + 1, rpc__resp__wifi_sta_itwt_teardown__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_itwt_teardown__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_sta_itwt_suspend__field_descriptors[2] = +{ + { + "flow_id", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaItwtSuspend, flow_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "suspend_time_ms", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaItwtSuspend, suspend_time_ms), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_sta_itwt_suspend__field_indices_by_name[] = { + 0, /* field[0] = flow_id */ + 1, /* field[1] = suspend_time_ms */ +}; +static const ProtobufCIntRange rpc__req__wifi_sta_itwt_suspend__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_suspend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaItwtSuspend", + "RpcReqWifiStaItwtSuspend", + "RpcReqWifiStaItwtSuspend", + "", + sizeof(RpcReqWifiStaItwtSuspend), + 2, + rpc__req__wifi_sta_itwt_suspend__field_descriptors, + rpc__req__wifi_sta_itwt_suspend__field_indices_by_name, + 1, rpc__req__wifi_sta_itwt_suspend__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_itwt_suspend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_itwt_suspend__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtSuspend, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_itwt_suspend__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_itwt_suspend__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_suspend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaItwtSuspend", + "RpcRespWifiStaItwtSuspend", + "RpcRespWifiStaItwtSuspend", + "", + sizeof(RpcRespWifiStaItwtSuspend), + 1, + rpc__resp__wifi_sta_itwt_suspend__field_descriptors, + rpc__resp__wifi_sta_itwt_suspend__field_indices_by_name, + 1, rpc__resp__wifi_sta_itwt_suspend__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_itwt_suspend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_itwt_get_flow_id_status__field_descriptors NULL +#define rpc__req__wifi_sta_itwt_get_flow_id_status__field_indices_by_name NULL +#define rpc__req__wifi_sta_itwt_get_flow_id_status__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaItwtGetFlowIdStatus", + "RpcReqWifiStaItwtGetFlowIdStatus", + "RpcReqWifiStaItwtGetFlowIdStatus", + "", + sizeof(RpcReqWifiStaItwtGetFlowIdStatus), + 0, + rpc__req__wifi_sta_itwt_get_flow_id_status__field_descriptors, + rpc__req__wifi_sta_itwt_get_flow_id_status__field_indices_by_name, + 0, rpc__req__wifi_sta_itwt_get_flow_id_status__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_itwt_get_flow_id_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_itwt_get_flow_id_status__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtGetFlowIdStatus, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "flow_id_bitmap", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtGetFlowIdStatus, flow_id_bitmap), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_itwt_get_flow_id_status__field_indices_by_name[] = { + 1, /* field[1] = flow_id_bitmap */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_itwt_get_flow_id_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaItwtGetFlowIdStatus", + "RpcRespWifiStaItwtGetFlowIdStatus", + "RpcRespWifiStaItwtGetFlowIdStatus", + "", + sizeof(RpcRespWifiStaItwtGetFlowIdStatus), + 2, + rpc__resp__wifi_sta_itwt_get_flow_id_status__field_descriptors, + rpc__resp__wifi_sta_itwt_get_flow_id_status__field_indices_by_name, + 1, rpc__resp__wifi_sta_itwt_get_flow_id_status__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_itwt_get_flow_id_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_sta_itwt_send_probe_req__field_descriptors[1] = +{ + { + "timeout_ms", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaItwtSendProbeReq, timeout_ms), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_sta_itwt_send_probe_req__field_indices_by_name[] = { + 0, /* field[0] = timeout_ms */ +}; +static const ProtobufCIntRange rpc__req__wifi_sta_itwt_send_probe_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_send_probe_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaItwtSendProbeReq", + "RpcReqWifiStaItwtSendProbeReq", + "RpcReqWifiStaItwtSendProbeReq", + "", + sizeof(RpcReqWifiStaItwtSendProbeReq), + 1, + rpc__req__wifi_sta_itwt_send_probe_req__field_descriptors, + rpc__req__wifi_sta_itwt_send_probe_req__field_indices_by_name, + 1, rpc__req__wifi_sta_itwt_send_probe_req__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_itwt_send_probe_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_itwt_send_probe_req__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtSendProbeReq, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_itwt_send_probe_req__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_itwt_send_probe_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_send_probe_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaItwtSendProbeReq", + "RpcRespWifiStaItwtSendProbeReq", + "RpcRespWifiStaItwtSendProbeReq", + "", + sizeof(RpcRespWifiStaItwtSendProbeReq), + 1, + rpc__resp__wifi_sta_itwt_send_probe_req__field_descriptors, + rpc__resp__wifi_sta_itwt_send_probe_req__field_indices_by_name, + 1, rpc__resp__wifi_sta_itwt_send_probe_req__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_itwt_send_probe_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_sta_itwt_set_target_wake_time_offset__field_descriptors[1] = +{ + { + "offset_us", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaItwtSetTargetWakeTimeOffset, offset_us), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_sta_itwt_set_target_wake_time_offset__field_indices_by_name[] = { + 0, /* field[0] = offset_us */ +}; +static const ProtobufCIntRange rpc__req__wifi_sta_itwt_set_target_wake_time_offset__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaItwtSetTargetWakeTimeOffset", + "RpcReqWifiStaItwtSetTargetWakeTimeOffset", + "RpcReqWifiStaItwtSetTargetWakeTimeOffset", + "", + sizeof(RpcReqWifiStaItwtSetTargetWakeTimeOffset), + 1, + rpc__req__wifi_sta_itwt_set_target_wake_time_offset__field_descriptors, + rpc__req__wifi_sta_itwt_set_target_wake_time_offset__field_indices_by_name, + 1, rpc__req__wifi_sta_itwt_set_target_wake_time_offset__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_itwt_set_target_wake_time_offset__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaItwtSetTargetWakeTimeOffset, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaItwtSetTargetWakeTimeOffset", + "RpcRespWifiStaItwtSetTargetWakeTimeOffset", + "RpcRespWifiStaItwtSetTargetWakeTimeOffset", + "", + sizeof(RpcRespWifiStaItwtSetTargetWakeTimeOffset), + 1, + rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__field_descriptors, + rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__field_indices_by_name, + 1, rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_sta_twt_config__field_descriptors[1] = +{ + { + "config", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiStaTwtConfig, config), + &wifi_twt_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_sta_twt_config__field_indices_by_name[] = { + 0, /* field[0] = config */ +}; +static const ProtobufCIntRange rpc__req__wifi_sta_twt_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_sta_twt_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaTwtConfig", + "RpcReqWifiStaTwtConfig", + "RpcReqWifiStaTwtConfig", + "", + sizeof(RpcReqWifiStaTwtConfig), + 1, + rpc__req__wifi_sta_twt_config__field_descriptors, + rpc__req__wifi_sta_twt_config__field_indices_by_name, + 1, rpc__req__wifi_sta_twt_config__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_twt_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_twt_config__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaTwtConfig, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_twt_config__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_twt_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_twt_config__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaTwtConfig", + "RpcRespWifiStaTwtConfig", + "RpcRespWifiStaTwtConfig", + "", + sizeof(RpcRespWifiStaTwtConfig), + 1, + rpc__resp__wifi_sta_twt_config__field_descriptors, + rpc__resp__wifi_sta_twt_config__field_indices_by_name, + 1, rpc__resp__wifi_sta_twt_config__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_twt_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__get_coprocessor_fw_version__field_descriptors NULL +#define rpc__req__get_coprocessor_fw_version__field_indices_by_name NULL +#define rpc__req__get_coprocessor_fw_version__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__get_coprocessor_fw_version__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetCoprocessorFwVersion", + "RpcReqGetCoprocessorFwVersion", + "RpcReqGetCoprocessorFwVersion", + "", + sizeof(RpcReqGetCoprocessorFwVersion), + 0, + rpc__req__get_coprocessor_fw_version__field_descriptors, + rpc__req__get_coprocessor_fw_version__field_indices_by_name, + 0, rpc__req__get_coprocessor_fw_version__number_ranges, + (ProtobufCMessageInit) rpc__req__get_coprocessor_fw_version__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_coprocessor_fw_version__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "major1", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, major1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "minor1", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, minor1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "patch1", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetCoprocessorFwVersion, patch1), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_coprocessor_fw_version__field_indices_by_name[] = { + 1, /* field[1] = major1 */ + 2, /* field[2] = minor1 */ + 3, /* field[3] = patch1 */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_coprocessor_fw_version__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_coprocessor_fw_version__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetCoprocessorFwVersion", + "RpcRespGetCoprocessorFwVersion", + "RpcRespGetCoprocessorFwVersion", + "", + sizeof(RpcRespGetCoprocessorFwVersion), + 4, + rpc__resp__get_coprocessor_fw_version__field_descriptors, + rpc__resp__get_coprocessor_fw_version__field_indices_by_name, + 1, rpc__resp__get_coprocessor_fw_version__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_coprocessor_fw_version__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__set_dhcp_dns_status__field_descriptors[9] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "net_link_up", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, net_link_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_up", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dhcp_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_ip", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dhcp_ip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_nm", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dhcp_nm), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_gw", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dhcp_gw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_up", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dns_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_ip", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dns_ip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_type", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSetDhcpDnsStatus, dns_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__set_dhcp_dns_status__field_indices_by_name[] = { + 5, /* field[5] = dhcp_gw */ + 3, /* field[3] = dhcp_ip */ + 4, /* field[4] = dhcp_nm */ + 2, /* field[2] = dhcp_up */ + 7, /* field[7] = dns_ip */ + 8, /* field[8] = dns_type */ + 6, /* field[6] = dns_up */ + 0, /* field[0] = iface */ + 1, /* field[1] = net_link_up */ +}; +static const ProtobufCIntRange rpc__req__set_dhcp_dns_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 9 } +}; +const ProtobufCMessageDescriptor rpc__req__set_dhcp_dns_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SetDhcpDnsStatus", + "RpcReqSetDhcpDnsStatus", + "RpcReqSetDhcpDnsStatus", + "", + sizeof(RpcReqSetDhcpDnsStatus), + 9, + rpc__req__set_dhcp_dns_status__field_descriptors, + rpc__req__set_dhcp_dns_status__field_indices_by_name, + 1, rpc__req__set_dhcp_dns_status__number_ranges, + (ProtobufCMessageInit) rpc__req__set_dhcp_dns_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__set_dhcp_dns_status__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSetDhcpDnsStatus, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__set_dhcp_dns_status__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__set_dhcp_dns_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__set_dhcp_dns_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SetDhcpDnsStatus", + "RpcRespSetDhcpDnsStatus", + "RpcRespSetDhcpDnsStatus", + "", + sizeof(RpcRespSetDhcpDnsStatus), + 1, + rpc__resp__set_dhcp_dns_status__field_descriptors, + rpc__resp__set_dhcp_dns_status__field_indices_by_name, + 1, rpc__resp__set_dhcp_dns_status__number_ranges, + (ProtobufCMessageInit) rpc__resp__set_dhcp_dns_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__get_dhcp_dns_status__field_descriptors[1] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqGetDhcpDnsStatus, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__get_dhcp_dns_status__field_indices_by_name[] = { + 0, /* field[0] = iface */ +}; +static const ProtobufCIntRange rpc__req__get_dhcp_dns_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__get_dhcp_dns_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_GetDhcpDnsStatus", + "RpcReqGetDhcpDnsStatus", + "RpcReqGetDhcpDnsStatus", + "", + sizeof(RpcReqGetDhcpDnsStatus), + 1, + rpc__req__get_dhcp_dns_status__field_descriptors, + rpc__req__get_dhcp_dns_status__field_indices_by_name, + 1, rpc__req__get_dhcp_dns_status__number_ranges, + (ProtobufCMessageInit) rpc__req__get_dhcp_dns_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__get_dhcp_dns_status__field_descriptors[10] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "net_link_up", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, net_link_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_up", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dhcp_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_ip", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dhcp_ip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_nm", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dhcp_nm), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_gw", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dhcp_gw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_up", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dns_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_ip", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dns_ip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_type", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, dns_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespGetDhcpDnsStatus, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__get_dhcp_dns_status__field_indices_by_name[] = { + 5, /* field[5] = dhcp_gw */ + 3, /* field[3] = dhcp_ip */ + 4, /* field[4] = dhcp_nm */ + 2, /* field[2] = dhcp_up */ + 7, /* field[7] = dns_ip */ + 8, /* field[8] = dns_type */ + 6, /* field[6] = dns_up */ + 0, /* field[0] = iface */ + 1, /* field[1] = net_link_up */ + 9, /* field[9] = resp */ +}; +static const ProtobufCIntRange rpc__resp__get_dhcp_dns_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 10 } +}; +const ProtobufCMessageDescriptor rpc__resp__get_dhcp_dns_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_GetDhcpDnsStatus", + "RpcRespGetDhcpDnsStatus", + "RpcRespGetDhcpDnsStatus", + "", + sizeof(RpcRespGetDhcpDnsStatus), + 10, + rpc__resp__get_dhcp_dns_status__field_descriptors, + rpc__resp__get_dhcp_dns_status__field_indices_by_name, + 1, rpc__resp__get_dhcp_dns_status__number_ranges, + (ProtobufCMessageInit) rpc__resp__get_dhcp_dns_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__supp_dpp_init__field_descriptors[1] = +{ + { + "cb", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqSuppDppInit, cb), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__supp_dpp_init__field_indices_by_name[] = { + 0, /* field[0] = cb */ +}; +static const ProtobufCIntRange rpc__req__supp_dpp_init__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__supp_dpp_init__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SuppDppInit", + "RpcReqSuppDppInit", + "RpcReqSuppDppInit", + "", + sizeof(RpcReqSuppDppInit), + 1, + rpc__req__supp_dpp_init__field_descriptors, + rpc__req__supp_dpp_init__field_indices_by_name, + 1, rpc__req__supp_dpp_init__number_ranges, + (ProtobufCMessageInit) rpc__req__supp_dpp_init__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__supp_dpp_init__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSuppDppInit, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__supp_dpp_init__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__supp_dpp_init__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__supp_dpp_init__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SuppDppInit", + "RpcRespSuppDppInit", + "RpcRespSuppDppInit", + "", + sizeof(RpcRespSuppDppInit), + 1, + rpc__resp__supp_dpp_init__field_descriptors, + rpc__resp__supp_dpp_init__field_indices_by_name, + 1, rpc__resp__supp_dpp_init__number_ranges, + (ProtobufCMessageInit) rpc__resp__supp_dpp_init__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__supp_dpp_deinit__field_descriptors NULL +#define rpc__req__supp_dpp_deinit__field_indices_by_name NULL +#define rpc__req__supp_dpp_deinit__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__supp_dpp_deinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SuppDppDeinit", + "RpcReqSuppDppDeinit", + "RpcReqSuppDppDeinit", + "", + sizeof(RpcReqSuppDppDeinit), + 0, + rpc__req__supp_dpp_deinit__field_descriptors, + rpc__req__supp_dpp_deinit__field_indices_by_name, + 0, rpc__req__supp_dpp_deinit__number_ranges, + (ProtobufCMessageInit) rpc__req__supp_dpp_deinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__supp_dpp_deinit__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSuppDppDeinit, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__supp_dpp_deinit__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__supp_dpp_deinit__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__supp_dpp_deinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SuppDppDeinit", + "RpcRespSuppDppDeinit", + "RpcRespSuppDppDeinit", + "", + sizeof(RpcRespSuppDppDeinit), + 1, + rpc__resp__supp_dpp_deinit__field_descriptors, + rpc__resp__supp_dpp_deinit__field_indices_by_name, + 1, rpc__resp__supp_dpp_deinit__number_ranges, + (ProtobufCMessageInit) rpc__resp__supp_dpp_deinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__supp_dpp_bootstrap_gen__field_descriptors[4] = +{ + { + "chan_list", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSuppDppBootstrapGen, chan_list), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqSuppDppBootstrapGen, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "key", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSuppDppBootstrapGen, key), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "info", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqSuppDppBootstrapGen, info), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__supp_dpp_bootstrap_gen__field_indices_by_name[] = { + 0, /* field[0] = chan_list */ + 3, /* field[3] = info */ + 2, /* field[2] = key */ + 1, /* field[1] = type */ +}; +static const ProtobufCIntRange rpc__req__supp_dpp_bootstrap_gen__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__req__supp_dpp_bootstrap_gen__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SuppDppBootstrapGen", + "RpcReqSuppDppBootstrapGen", + "RpcReqSuppDppBootstrapGen", + "", + sizeof(RpcReqSuppDppBootstrapGen), + 4, + rpc__req__supp_dpp_bootstrap_gen__field_descriptors, + rpc__req__supp_dpp_bootstrap_gen__field_indices_by_name, + 1, rpc__req__supp_dpp_bootstrap_gen__number_ranges, + (ProtobufCMessageInit) rpc__req__supp_dpp_bootstrap_gen__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__supp_dpp_bootstrap_gen__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSuppDppBootstrapGen, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__supp_dpp_bootstrap_gen__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__supp_dpp_bootstrap_gen__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__supp_dpp_bootstrap_gen__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SuppDppBootstrapGen", + "RpcRespSuppDppBootstrapGen", + "RpcRespSuppDppBootstrapGen", + "", + sizeof(RpcRespSuppDppBootstrapGen), + 1, + rpc__resp__supp_dpp_bootstrap_gen__field_descriptors, + rpc__resp__supp_dpp_bootstrap_gen__field_indices_by_name, + 1, rpc__resp__supp_dpp_bootstrap_gen__number_ranges, + (ProtobufCMessageInit) rpc__resp__supp_dpp_bootstrap_gen__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__supp_dpp_start_listen__field_descriptors NULL +#define rpc__req__supp_dpp_start_listen__field_indices_by_name NULL +#define rpc__req__supp_dpp_start_listen__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__supp_dpp_start_listen__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SuppDppStartListen", + "RpcReqSuppDppStartListen", + "RpcReqSuppDppStartListen", + "", + sizeof(RpcReqSuppDppStartListen), + 0, + rpc__req__supp_dpp_start_listen__field_descriptors, + rpc__req__supp_dpp_start_listen__field_indices_by_name, + 0, rpc__req__supp_dpp_start_listen__number_ranges, + (ProtobufCMessageInit) rpc__req__supp_dpp_start_listen__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__supp_dpp_start_listen__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSuppDppStartListen, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__supp_dpp_start_listen__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__supp_dpp_start_listen__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__supp_dpp_start_listen__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SuppDppStartListen", + "RpcRespSuppDppStartListen", + "RpcRespSuppDppStartListen", + "", + sizeof(RpcRespSuppDppStartListen), + 1, + rpc__resp__supp_dpp_start_listen__field_descriptors, + rpc__resp__supp_dpp_start_listen__field_indices_by_name, + 1, rpc__resp__supp_dpp_start_listen__number_ranges, + (ProtobufCMessageInit) rpc__resp__supp_dpp_start_listen__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__supp_dpp_stop_listen__field_descriptors NULL +#define rpc__req__supp_dpp_stop_listen__field_indices_by_name NULL +#define rpc__req__supp_dpp_stop_listen__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__supp_dpp_stop_listen__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_SuppDppStopListen", + "RpcReqSuppDppStopListen", + "RpcReqSuppDppStopListen", + "", + sizeof(RpcReqSuppDppStopListen), + 0, + rpc__req__supp_dpp_stop_listen__field_descriptors, + rpc__req__supp_dpp_stop_listen__field_indices_by_name, + 0, rpc__req__supp_dpp_stop_listen__number_ranges, + (ProtobufCMessageInit) rpc__req__supp_dpp_stop_listen__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__supp_dpp_stop_listen__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespSuppDppStopListen, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__supp_dpp_stop_listen__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__supp_dpp_stop_listen__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__supp_dpp_stop_listen__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_SuppDppStopListen", + "RpcRespSuppDppStopListen", + "RpcRespSuppDppStopListen", + "", + sizeof(RpcRespSuppDppStopListen), + 1, + rpc__resp__supp_dpp_stop_listen__field_descriptors, + rpc__resp__supp_dpp_stop_listen__field_indices_by_name, + 1, rpc__resp__supp_dpp_stop_listen__number_ranges, + (ProtobufCMessageInit) rpc__resp__supp_dpp_stop_listen__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__iface_mac_addr_set_get__field_descriptors[3] = +{ + { + "set", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqIfaceMacAddrSetGet, set), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqIfaceMacAddrSetGet, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqIfaceMacAddrSetGet, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__iface_mac_addr_set_get__field_indices_by_name[] = { + 2, /* field[2] = mac */ + 0, /* field[0] = set */ + 1, /* field[1] = type */ +}; +static const ProtobufCIntRange rpc__req__iface_mac_addr_set_get__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__req__iface_mac_addr_set_get__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_IfaceMacAddrSetGet", + "RpcReqIfaceMacAddrSetGet", + "RpcReqIfaceMacAddrSetGet", + "", + sizeof(RpcReqIfaceMacAddrSetGet), + 3, + rpc__req__iface_mac_addr_set_get__field_descriptors, + rpc__req__iface_mac_addr_set_get__field_indices_by_name, + 1, rpc__req__iface_mac_addr_set_get__number_ranges, + (ProtobufCMessageInit) rpc__req__iface_mac_addr_set_get__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__iface_mac_addr_set_get__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrSetGet, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "set", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrSetGet, set), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrSetGet, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrSetGet, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__iface_mac_addr_set_get__field_indices_by_name[] = { + 3, /* field[3] = mac */ + 0, /* field[0] = resp */ + 1, /* field[1] = set */ + 2, /* field[2] = type */ +}; +static const ProtobufCIntRange rpc__resp__iface_mac_addr_set_get__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__resp__iface_mac_addr_set_get__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_IfaceMacAddrSetGet", + "RpcRespIfaceMacAddrSetGet", + "RpcRespIfaceMacAddrSetGet", + "", + sizeof(RpcRespIfaceMacAddrSetGet), + 4, + rpc__resp__iface_mac_addr_set_get__field_descriptors, + rpc__resp__iface_mac_addr_set_get__field_indices_by_name, + 1, rpc__resp__iface_mac_addr_set_get__number_ranges, + (ProtobufCMessageInit) rpc__resp__iface_mac_addr_set_get__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__iface_mac_addr_len_get__field_descriptors[1] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcReqIfaceMacAddrLenGet, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__iface_mac_addr_len_get__field_indices_by_name[] = { + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange rpc__req__iface_mac_addr_len_get__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__iface_mac_addr_len_get__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_IfaceMacAddrLenGet", + "RpcReqIfaceMacAddrLenGet", + "RpcReqIfaceMacAddrLenGet", + "", + sizeof(RpcReqIfaceMacAddrLenGet), + 1, + rpc__req__iface_mac_addr_len_get__field_descriptors, + rpc__req__iface_mac_addr_len_get__field_indices_by_name, + 1, rpc__req__iface_mac_addr_len_get__number_ranges, + (ProtobufCMessageInit) rpc__req__iface_mac_addr_len_get__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__iface_mac_addr_len_get__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrLenGet, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrLenGet, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcRespIfaceMacAddrLenGet, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__iface_mac_addr_len_get__field_indices_by_name[] = { + 2, /* field[2] = len */ + 0, /* field[0] = resp */ + 1, /* field[1] = type */ +}; +static const ProtobufCIntRange rpc__resp__iface_mac_addr_len_get__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__resp__iface_mac_addr_len_get__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_IfaceMacAddrLenGet", + "RpcRespIfaceMacAddrLenGet", + "RpcRespIfaceMacAddrLenGet", + "", + sizeof(RpcRespIfaceMacAddrLenGet), + 3, + rpc__resp__iface_mac_addr_len_get__field_descriptors, + rpc__resp__iface_mac_addr_len_get__field_indices_by_name, + 1, rpc__resp__iface_mac_addr_len_get__number_ranges, + (ProtobufCMessageInit) rpc__resp__iface_mac_addr_len_get__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__feature_control__field_descriptors[3] = +{ + { + "feature", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(RpcReqFeatureControl, feature), + &rpc_feature__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "command", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(RpcReqFeatureControl, command), + &rpc_feature_command__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "option", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(RpcReqFeatureControl, option), + &rpc_feature_option__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__feature_control__field_indices_by_name[] = { + 1, /* field[1] = command */ + 0, /* field[0] = feature */ + 2, /* field[2] = option */ +}; +static const ProtobufCIntRange rpc__req__feature_control__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__req__feature_control__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_FeatureControl", + "RpcReqFeatureControl", + "RpcReqFeatureControl", + "", + sizeof(RpcReqFeatureControl), + 3, + rpc__req__feature_control__field_descriptors, + rpc__req__feature_control__field_indices_by_name, + 1, rpc__req__feature_control__number_ranges, + (ProtobufCMessageInit) rpc__req__feature_control__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__feature_control__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespFeatureControl, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(RpcRespFeatureControl, feature), + &rpc_feature__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "command", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(RpcRespFeatureControl, command), + &rpc_feature_command__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "option", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(RpcRespFeatureControl, option), + &rpc_feature_option__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__feature_control__field_indices_by_name[] = { + 2, /* field[2] = command */ + 1, /* field[1] = feature */ + 3, /* field[3] = option */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__feature_control__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__resp__feature_control__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_FeatureControl", + "RpcRespFeatureControl", + "RpcRespFeatureControl", + "", + sizeof(RpcRespFeatureControl), + 4, + rpc__resp__feature_control__field_descriptors, + rpc__resp__feature_control__field_indices_by_name, + 1, rpc__resp__feature_control__number_ranges, + (ProtobufCMessageInit) rpc__resp__feature_control__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__wifi_event_no_args__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiEventNoArgs, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_id", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiEventNoArgs, event_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__wifi_event_no_args__field_indices_by_name[] = { + 1, /* field[1] = event_id */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__wifi_event_no_args__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__wifi_event_no_args__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_WifiEventNoArgs", + "RpcEventWifiEventNoArgs", + "RpcEventWifiEventNoArgs", + "", + sizeof(RpcEventWifiEventNoArgs), + 2, + rpc__event__wifi_event_no_args__field_descriptors, + rpc__event__wifi_event_no_args__field_indices_by_name, + 1, rpc__event__wifi_event_no_args__number_ranges, + (ProtobufCMessageInit) rpc__event__wifi_event_no_args__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__espinit__field_descriptors[1] = +{ + { + "init_data", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventESPInit, init_data), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__espinit__field_indices_by_name[] = { + 0, /* field[0] = init_data */ +}; +static const ProtobufCIntRange rpc__event__espinit__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__event__espinit__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_ESPInit", + "RpcEventESPInit", + "RpcEventESPInit", + "", + sizeof(RpcEventESPInit), + 1, + rpc__event__espinit__field_descriptors, + rpc__event__espinit__field_indices_by_name, + 1, rpc__event__espinit__number_ranges, + (ProtobufCMessageInit) rpc__event__espinit__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__heartbeat__field_descriptors[1] = +{ + { + "hb_num", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventHeartbeat, hb_num), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__heartbeat__field_indices_by_name[] = { + 0, /* field[0] = hb_num */ +}; +static const ProtobufCIntRange rpc__event__heartbeat__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__event__heartbeat__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_Heartbeat", + "RpcEventHeartbeat", + "RpcEventHeartbeat", + "", + sizeof(RpcEventHeartbeat), + 1, + rpc__event__heartbeat__field_descriptors, + rpc__event__heartbeat__field_indices_by_name, + 1, rpc__event__heartbeat__number_ranges, + (ProtobufCMessageInit) rpc__event__heartbeat__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__ap__sta_disconnected__field_descriptors[5] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "is_mesh_child", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, is_mesh_child), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaDisconnected, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__ap__sta_disconnected__field_indices_by_name[] = { + 2, /* field[2] = aid */ + 3, /* field[3] = is_mesh_child */ + 1, /* field[1] = mac */ + 4, /* field[4] = reason */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__ap__sta_disconnected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor rpc__event__ap__sta_disconnected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_AP_StaDisconnected", + "RpcEventAPStaDisconnected", + "RpcEventAPStaDisconnected", + "", + sizeof(RpcEventAPStaDisconnected), + 5, + rpc__event__ap__sta_disconnected__field_descriptors, + rpc__event__ap__sta_disconnected__field_indices_by_name, + 1, rpc__event__ap__sta_disconnected__number_ranges, + (ProtobufCMessageInit) rpc__event__ap__sta_disconnected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__ap__sta_connected__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "mac", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "aid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, aid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "is_mesh_child", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcEventAPStaConnected, is_mesh_child), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__ap__sta_connected__field_indices_by_name[] = { + 2, /* field[2] = aid */ + 3, /* field[3] = is_mesh_child */ + 1, /* field[1] = mac */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__ap__sta_connected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__event__ap__sta_connected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_AP_StaConnected", + "RpcEventAPStaConnected", + "RpcEventAPStaConnected", + "", + sizeof(RpcEventAPStaConnected), + 4, + rpc__event__ap__sta_connected__field_descriptors, + rpc__event__ap__sta_connected__field_indices_by_name, + 1, rpc__event__ap__sta_connected__number_ranges, + (ProtobufCMessageInit) rpc__event__ap__sta_connected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_scan_done__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaScanDone, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "scan_done", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaScanDone, scan_done), + &wifi_event_sta_scan_done__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_scan_done__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = scan_done */ +}; +static const ProtobufCIntRange rpc__event__sta_scan_done__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_scan_done__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaScanDone", + "RpcEventStaScanDone", + "RpcEventStaScanDone", + "", + sizeof(RpcEventStaScanDone), + 2, + rpc__event__sta_scan_done__field_descriptors, + rpc__event__sta_scan_done__field_indices_by_name, + 1, rpc__event__sta_scan_done__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_scan_done__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_connected__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaConnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_connected", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaConnected, sta_connected), + &wifi_event_sta_connected__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_connected__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sta_connected */ +}; +static const ProtobufCIntRange rpc__event__sta_connected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_connected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaConnected", + "RpcEventStaConnected", + "RpcEventStaConnected", + "", + sizeof(RpcEventStaConnected), + 2, + rpc__event__sta_connected__field_descriptors, + rpc__event__sta_connected__field_indices_by_name, + 1, rpc__event__sta_connected__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_connected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_disconnected__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaDisconnected, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_disconnected", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaDisconnected, sta_disconnected), + &wifi_event_sta_disconnected__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_disconnected__field_indices_by_name[] = { + 0, /* field[0] = resp */ + 1, /* field[1] = sta_disconnected */ +}; +static const ProtobufCIntRange rpc__event__sta_disconnected__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_disconnected__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaDisconnected", + "RpcEventStaDisconnected", + "RpcEventStaDisconnected", + "", + sizeof(RpcEventStaDisconnected), + 2, + rpc__event__sta_disconnected__field_descriptors, + rpc__event__sta_disconnected__field_indices_by_name, + 1, rpc__event__sta_disconnected__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_disconnected__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__dhcp_dns_status__field_descriptors[10] = +{ + { + "iface", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, iface), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "net_link_up", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, net_link_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_up", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dhcp_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_ip", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dhcp_ip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_nm", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dhcp_nm), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcp_gw", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dhcp_gw), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_up", + 7, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dns_up), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_ip", + 8, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dns_ip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dns_type", + 9, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, dns_type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp", + 10, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventDhcpDnsStatus, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__dhcp_dns_status__field_indices_by_name[] = { + 5, /* field[5] = dhcp_gw */ + 3, /* field[3] = dhcp_ip */ + 4, /* field[4] = dhcp_nm */ + 2, /* field[2] = dhcp_up */ + 7, /* field[7] = dns_ip */ + 8, /* field[8] = dns_type */ + 6, /* field[6] = dns_up */ + 0, /* field[0] = iface */ + 1, /* field[1] = net_link_up */ + 9, /* field[9] = resp */ +}; +static const ProtobufCIntRange rpc__event__dhcp_dns_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 10 } +}; +const ProtobufCMessageDescriptor rpc__event__dhcp_dns_status__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_DhcpDnsStatus", + "RpcEventDhcpDnsStatus", + "RpcEventDhcpDnsStatus", + "", + sizeof(RpcEventDhcpDnsStatus), + 10, + rpc__event__dhcp_dns_status__field_descriptors, + rpc__event__dhcp_dns_status__field_indices_by_name, + 1, rpc__event__dhcp_dns_status__number_ranges, + (ProtobufCMessageInit) rpc__event__dhcp_dns_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_itwt_setup__field_descriptors[5] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSetup, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "config", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSetup, config), + &wifi_itwt_setup_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSetup, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSetup, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "target_wake_time", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSetup, target_wake_time), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_itwt_setup__field_indices_by_name[] = { + 1, /* field[1] = config */ + 3, /* field[3] = reason */ + 0, /* field[0] = resp */ + 2, /* field[2] = status */ + 4, /* field[4] = target_wake_time */ +}; +static const ProtobufCIntRange rpc__event__sta_itwt_setup__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_itwt_setup__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaItwtSetup", + "RpcEventStaItwtSetup", + "RpcEventStaItwtSetup", + "", + sizeof(RpcEventStaItwtSetup), + 5, + rpc__event__sta_itwt_setup__field_descriptors, + rpc__event__sta_itwt_setup__field_indices_by_name, + 1, rpc__event__sta_itwt_setup__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_itwt_setup__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_itwt_teardown__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtTeardown, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "flow_id", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtTeardown, flow_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtTeardown, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_itwt_teardown__field_indices_by_name[] = { + 1, /* field[1] = flow_id */ + 0, /* field[0] = resp */ + 2, /* field[2] = status */ +}; +static const ProtobufCIntRange rpc__event__sta_itwt_teardown__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_itwt_teardown__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaItwtTeardown", + "RpcEventStaItwtTeardown", + "RpcEventStaItwtTeardown", + "", + sizeof(RpcEventStaItwtTeardown), + 3, + rpc__event__sta_itwt_teardown__field_descriptors, + rpc__event__sta_itwt_teardown__field_indices_by_name, + 1, rpc__event__sta_itwt_teardown__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_itwt_teardown__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_itwt_suspend__field_descriptors[4] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSuspend, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSuspend, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "flow_id_bitmap", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtSuspend, flow_id_bitmap), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "actual_suspend_time_ms", + 4, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + offsetof(RpcEventStaItwtSuspend, n_actual_suspend_time_ms), + offsetof(RpcEventStaItwtSuspend, actual_suspend_time_ms), + NULL, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_PACKED, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_itwt_suspend__field_indices_by_name[] = { + 3, /* field[3] = actual_suspend_time_ms */ + 2, /* field[2] = flow_id_bitmap */ + 0, /* field[0] = resp */ + 1, /* field[1] = status */ +}; +static const ProtobufCIntRange rpc__event__sta_itwt_suspend__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_itwt_suspend__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaItwtSuspend", + "RpcEventStaItwtSuspend", + "RpcEventStaItwtSuspend", + "", + sizeof(RpcEventStaItwtSuspend), + 4, + rpc__event__sta_itwt_suspend__field_descriptors, + rpc__event__sta_itwt_suspend__field_indices_by_name, + 1, rpc__event__sta_itwt_suspend__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_itwt_suspend__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__sta_itwt_probe__field_descriptors[3] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtProbe, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtProbe, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(RpcEventStaItwtProbe, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__sta_itwt_probe__field_indices_by_name[] = { + 2, /* field[2] = reason */ + 0, /* field[0] = resp */ + 1, /* field[1] = status */ +}; +static const ProtobufCIntRange rpc__event__sta_itwt_probe__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor rpc__event__sta_itwt_probe__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_StaItwtProbe", + "RpcEventStaItwtProbe", + "RpcEventStaItwtProbe", + "", + sizeof(RpcEventStaItwtProbe), + 3, + rpc__event__sta_itwt_probe__field_descriptors, + rpc__event__sta_itwt_probe__field_indices_by_name, + 1, rpc__event__sta_itwt_probe__number_ranges, + (ProtobufCMessageInit) rpc__event__sta_itwt_probe__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_enterprise_enable__field_descriptors NULL +#define rpc__req__wifi_sta_enterprise_enable__field_indices_by_name NULL +#define rpc__req__wifi_sta_enterprise_enable__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_enterprise_enable__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaEnterpriseEnable", + "RpcReqWifiStaEnterpriseEnable", + "RpcReqWifiStaEnterpriseEnable", + "", + sizeof(RpcReqWifiStaEnterpriseEnable), + 0, + rpc__req__wifi_sta_enterprise_enable__field_descriptors, + rpc__req__wifi_sta_enterprise_enable__field_indices_by_name, + 0, rpc__req__wifi_sta_enterprise_enable__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_enterprise_enable__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_enterprise_enable__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaEnterpriseEnable, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_enterprise_enable__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_enterprise_enable__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_enterprise_enable__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaEnterpriseEnable", + "RpcRespWifiStaEnterpriseEnable", + "RpcRespWifiStaEnterpriseEnable", + "", + sizeof(RpcRespWifiStaEnterpriseEnable), + 1, + rpc__resp__wifi_sta_enterprise_enable__field_descriptors, + rpc__resp__wifi_sta_enterprise_enable__field_indices_by_name, + 1, rpc__resp__wifi_sta_enterprise_enable__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_enterprise_enable__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__wifi_sta_enterprise_disable__field_descriptors NULL +#define rpc__req__wifi_sta_enterprise_disable__field_indices_by_name NULL +#define rpc__req__wifi_sta_enterprise_disable__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__wifi_sta_enterprise_disable__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiStaEnterpriseDisable", + "RpcReqWifiStaEnterpriseDisable", + "RpcReqWifiStaEnterpriseDisable", + "", + sizeof(RpcReqWifiStaEnterpriseDisable), + 0, + rpc__req__wifi_sta_enterprise_disable__field_descriptors, + rpc__req__wifi_sta_enterprise_disable__field_indices_by_name, + 0, rpc__req__wifi_sta_enterprise_disable__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_sta_enterprise_disable__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_sta_enterprise_disable__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiStaEnterpriseDisable, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_sta_enterprise_disable__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_sta_enterprise_disable__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_sta_enterprise_disable__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiStaEnterpriseDisable", + "RpcRespWifiStaEnterpriseDisable", + "RpcRespWifiStaEnterpriseDisable", + "", + sizeof(RpcRespWifiStaEnterpriseDisable), + 1, + rpc__resp__wifi_sta_enterprise_disable__field_descriptors, + rpc__resp__wifi_sta_enterprise_disable__field_indices_by_name, + 1, rpc__resp__wifi_sta_enterprise_disable__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_sta_enterprise_disable__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_identity__field_descriptors[2] = +{ + { + "identity", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetIdentity, identity), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetIdentity, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_identity__field_indices_by_name[] = { + 0, /* field[0] = identity */ + 1, /* field[1] = len */ +}; +static const ProtobufCIntRange rpc__req__eap_set_identity__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_identity__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetIdentity", + "RpcReqEapSetIdentity", + "RpcReqEapSetIdentity", + "", + sizeof(RpcReqEapSetIdentity), + 2, + rpc__req__eap_set_identity__field_descriptors, + rpc__req__eap_set_identity__field_indices_by_name, + 1, rpc__req__eap_set_identity__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_identity__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_identity__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetIdentity, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_identity__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_identity__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_identity__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetIdentity", + "RpcRespEapSetIdentity", + "RpcRespEapSetIdentity", + "", + sizeof(RpcRespEapSetIdentity), + 1, + rpc__resp__eap_set_identity__field_descriptors, + rpc__resp__eap_set_identity__field_indices_by_name, + 1, rpc__resp__eap_set_identity__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_identity__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_clear_identity__field_descriptors NULL +#define rpc__req__eap_clear_identity__field_indices_by_name NULL +#define rpc__req__eap_clear_identity__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_clear_identity__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapClearIdentity", + "RpcReqEapClearIdentity", + "RpcReqEapClearIdentity", + "", + sizeof(RpcReqEapClearIdentity), + 0, + rpc__req__eap_clear_identity__field_descriptors, + rpc__req__eap_clear_identity__field_indices_by_name, + 0, rpc__req__eap_clear_identity__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_clear_identity__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_clear_identity__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapClearIdentity, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_clear_identity__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_clear_identity__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_clear_identity__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapClearIdentity", + "RpcRespEapClearIdentity", + "RpcRespEapClearIdentity", + "", + sizeof(RpcRespEapClearIdentity), + 1, + rpc__resp__eap_clear_identity__field_descriptors, + rpc__resp__eap_clear_identity__field_indices_by_name, + 1, rpc__resp__eap_clear_identity__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_clear_identity__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_username__field_descriptors[2] = +{ + { + "username", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetUsername, username), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetUsername, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_username__field_indices_by_name[] = { + 1, /* field[1] = len */ + 0, /* field[0] = username */ +}; +static const ProtobufCIntRange rpc__req__eap_set_username__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_username__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetUsername", + "RpcReqEapSetUsername", + "RpcReqEapSetUsername", + "", + sizeof(RpcReqEapSetUsername), + 2, + rpc__req__eap_set_username__field_descriptors, + rpc__req__eap_set_username__field_indices_by_name, + 1, rpc__req__eap_set_username__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_username__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_username__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetUsername, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_username__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_username__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_username__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetUsername", + "RpcRespEapSetUsername", + "RpcRespEapSetUsername", + "", + sizeof(RpcRespEapSetUsername), + 1, + rpc__resp__eap_set_username__field_descriptors, + rpc__resp__eap_set_username__field_indices_by_name, + 1, rpc__resp__eap_set_username__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_username__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_clear_username__field_descriptors NULL +#define rpc__req__eap_clear_username__field_indices_by_name NULL +#define rpc__req__eap_clear_username__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_clear_username__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapClearUsername", + "RpcReqEapClearUsername", + "RpcReqEapClearUsername", + "", + sizeof(RpcReqEapClearUsername), + 0, + rpc__req__eap_clear_username__field_descriptors, + rpc__req__eap_clear_username__field_indices_by_name, + 0, rpc__req__eap_clear_username__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_clear_username__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_clear_username__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapClearUsername, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_clear_username__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_clear_username__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_clear_username__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapClearUsername", + "RpcRespEapClearUsername", + "RpcRespEapClearUsername", + "", + sizeof(RpcRespEapClearUsername), + 1, + rpc__resp__eap_clear_username__field_descriptors, + rpc__resp__eap_clear_username__field_indices_by_name, + 1, rpc__resp__eap_clear_username__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_clear_username__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_password__field_descriptors[2] = +{ + { + "password", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetPassword, password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetPassword, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_password__field_indices_by_name[] = { + 1, /* field[1] = len */ + 0, /* field[0] = password */ +}; +static const ProtobufCIntRange rpc__req__eap_set_password__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetPassword", + "RpcReqEapSetPassword", + "RpcReqEapSetPassword", + "", + sizeof(RpcReqEapSetPassword), + 2, + rpc__req__eap_set_password__field_descriptors, + rpc__req__eap_set_password__field_indices_by_name, + 1, rpc__req__eap_set_password__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_password__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetPassword, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_password__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_password__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetPassword", + "RpcRespEapSetPassword", + "RpcRespEapSetPassword", + "", + sizeof(RpcRespEapSetPassword), + 1, + rpc__resp__eap_set_password__field_descriptors, + rpc__resp__eap_set_password__field_indices_by_name, + 1, rpc__resp__eap_set_password__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_clear_password__field_descriptors NULL +#define rpc__req__eap_clear_password__field_indices_by_name NULL +#define rpc__req__eap_clear_password__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_clear_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapClearPassword", + "RpcReqEapClearPassword", + "RpcReqEapClearPassword", + "", + sizeof(RpcReqEapClearPassword), + 0, + rpc__req__eap_clear_password__field_descriptors, + rpc__req__eap_clear_password__field_indices_by_name, + 0, rpc__req__eap_clear_password__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_clear_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_clear_password__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapClearPassword, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_clear_password__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_clear_password__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_clear_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapClearPassword", + "RpcRespEapClearPassword", + "RpcRespEapClearPassword", + "", + sizeof(RpcRespEapClearPassword), + 1, + rpc__resp__eap_clear_password__field_descriptors, + rpc__resp__eap_clear_password__field_indices_by_name, + 1, rpc__resp__eap_clear_password__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_clear_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_new_password__field_descriptors[2] = +{ + { + "new_password", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetNewPassword, new_password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetNewPassword, len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_new_password__field_indices_by_name[] = { + 1, /* field[1] = len */ + 0, /* field[0] = new_password */ +}; +static const ProtobufCIntRange rpc__req__eap_set_new_password__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_new_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetNewPassword", + "RpcReqEapSetNewPassword", + "RpcReqEapSetNewPassword", + "", + sizeof(RpcReqEapSetNewPassword), + 2, + rpc__req__eap_set_new_password__field_descriptors, + rpc__req__eap_set_new_password__field_indices_by_name, + 1, rpc__req__eap_set_new_password__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_new_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_new_password__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetNewPassword, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_new_password__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_new_password__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_new_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetNewPassword", + "RpcRespEapSetNewPassword", + "RpcRespEapSetNewPassword", + "", + sizeof(RpcRespEapSetNewPassword), + 1, + rpc__resp__eap_set_new_password__field_descriptors, + rpc__resp__eap_set_new_password__field_indices_by_name, + 1, rpc__resp__eap_set_new_password__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_new_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_clear_new_password__field_descriptors NULL +#define rpc__req__eap_clear_new_password__field_indices_by_name NULL +#define rpc__req__eap_clear_new_password__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_clear_new_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapClearNewPassword", + "RpcReqEapClearNewPassword", + "RpcReqEapClearNewPassword", + "", + sizeof(RpcReqEapClearNewPassword), + 0, + rpc__req__eap_clear_new_password__field_descriptors, + rpc__req__eap_clear_new_password__field_indices_by_name, + 0, rpc__req__eap_clear_new_password__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_clear_new_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_clear_new_password__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapClearNewPassword, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_clear_new_password__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_clear_new_password__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_clear_new_password__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapClearNewPassword", + "RpcRespEapClearNewPassword", + "RpcRespEapClearNewPassword", + "", + sizeof(RpcRespEapClearNewPassword), + 1, + rpc__resp__eap_clear_new_password__field_descriptors, + rpc__resp__eap_clear_new_password__field_indices_by_name, + 1, rpc__resp__eap_clear_new_password__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_clear_new_password__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_ca_cert__field_descriptors[2] = +{ + { + "ca_cert", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCaCert, ca_cert), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ca_cert_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCaCert, ca_cert_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_ca_cert__field_indices_by_name[] = { + 0, /* field[0] = ca_cert */ + 1, /* field[1] = ca_cert_len */ +}; +static const ProtobufCIntRange rpc__req__eap_set_ca_cert__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_ca_cert__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetCaCert", + "RpcReqEapSetCaCert", + "RpcReqEapSetCaCert", + "", + sizeof(RpcReqEapSetCaCert), + 2, + rpc__req__eap_set_ca_cert__field_descriptors, + rpc__req__eap_set_ca_cert__field_indices_by_name, + 1, rpc__req__eap_set_ca_cert__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_ca_cert__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_ca_cert__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetCaCert, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_ca_cert__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_ca_cert__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_ca_cert__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetCaCert", + "RpcRespEapSetCaCert", + "RpcRespEapSetCaCert", + "", + sizeof(RpcRespEapSetCaCert), + 1, + rpc__resp__eap_set_ca_cert__field_descriptors, + rpc__resp__eap_set_ca_cert__field_indices_by_name, + 1, rpc__resp__eap_set_ca_cert__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_ca_cert__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_clear_ca_cert__field_descriptors NULL +#define rpc__req__eap_clear_ca_cert__field_indices_by_name NULL +#define rpc__req__eap_clear_ca_cert__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_clear_ca_cert__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapClearCaCert", + "RpcReqEapClearCaCert", + "RpcReqEapClearCaCert", + "", + sizeof(RpcReqEapClearCaCert), + 0, + rpc__req__eap_clear_ca_cert__field_descriptors, + rpc__req__eap_clear_ca_cert__field_indices_by_name, + 0, rpc__req__eap_clear_ca_cert__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_clear_ca_cert__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_clear_ca_cert__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapClearCaCert, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_clear_ca_cert__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_clear_ca_cert__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_clear_ca_cert__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapClearCaCert", + "RpcRespEapClearCaCert", + "RpcRespEapClearCaCert", + "", + sizeof(RpcRespEapClearCaCert), + 1, + rpc__resp__eap_clear_ca_cert__field_descriptors, + rpc__resp__eap_clear_ca_cert__field_indices_by_name, + 1, rpc__resp__eap_clear_ca_cert__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_clear_ca_cert__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_certificate_and_key__field_descriptors[6] = +{ + { + "client_cert", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCertificateAndKey, client_cert), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "client_cert_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCertificateAndKey, client_cert_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "private_key", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCertificateAndKey, private_key), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "private_key_len", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCertificateAndKey, private_key_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "private_key_password", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCertificateAndKey, private_key_password), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "private_key_passwd_len", + 6, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetCertificateAndKey, private_key_passwd_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_certificate_and_key__field_indices_by_name[] = { + 0, /* field[0] = client_cert */ + 1, /* field[1] = client_cert_len */ + 2, /* field[2] = private_key */ + 3, /* field[3] = private_key_len */ + 5, /* field[5] = private_key_passwd_len */ + 4, /* field[4] = private_key_password */ +}; +static const ProtobufCIntRange rpc__req__eap_set_certificate_and_key__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_certificate_and_key__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetCertificateAndKey", + "RpcReqEapSetCertificateAndKey", + "RpcReqEapSetCertificateAndKey", + "", + sizeof(RpcReqEapSetCertificateAndKey), + 6, + rpc__req__eap_set_certificate_and_key__field_descriptors, + rpc__req__eap_set_certificate_and_key__field_indices_by_name, + 1, rpc__req__eap_set_certificate_and_key__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_certificate_and_key__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_certificate_and_key__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetCertificateAndKey, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_certificate_and_key__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_certificate_and_key__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_certificate_and_key__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetCertificateAndKey", + "RpcRespEapSetCertificateAndKey", + "RpcRespEapSetCertificateAndKey", + "", + sizeof(RpcRespEapSetCertificateAndKey), + 1, + rpc__resp__eap_set_certificate_and_key__field_descriptors, + rpc__resp__eap_set_certificate_and_key__field_indices_by_name, + 1, rpc__resp__eap_set_certificate_and_key__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_certificate_and_key__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_clear_certificate_and_key__field_descriptors NULL +#define rpc__req__eap_clear_certificate_and_key__field_indices_by_name NULL +#define rpc__req__eap_clear_certificate_and_key__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_clear_certificate_and_key__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapClearCertificateAndKey", + "RpcReqEapClearCertificateAndKey", + "RpcReqEapClearCertificateAndKey", + "", + sizeof(RpcReqEapClearCertificateAndKey), + 0, + rpc__req__eap_clear_certificate_and_key__field_descriptors, + rpc__req__eap_clear_certificate_and_key__field_indices_by_name, + 0, rpc__req__eap_clear_certificate_and_key__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_clear_certificate_and_key__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_clear_certificate_and_key__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapClearCertificateAndKey, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_clear_certificate_and_key__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_clear_certificate_and_key__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_clear_certificate_and_key__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapClearCertificateAndKey", + "RpcRespEapClearCertificateAndKey", + "RpcRespEapClearCertificateAndKey", + "", + sizeof(RpcRespEapClearCertificateAndKey), + 1, + rpc__resp__eap_clear_certificate_and_key__field_descriptors, + rpc__resp__eap_clear_certificate_and_key__field_indices_by_name, + 1, rpc__resp__eap_clear_certificate_and_key__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_clear_certificate_and_key__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_disable_time_check__field_descriptors[1] = +{ + { + "disable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetDisableTimeCheck, disable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_disable_time_check__field_indices_by_name[] = { + 0, /* field[0] = disable */ +}; +static const ProtobufCIntRange rpc__req__eap_set_disable_time_check__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_disable_time_check__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetDisableTimeCheck", + "RpcReqEapSetDisableTimeCheck", + "RpcReqEapSetDisableTimeCheck", + "", + sizeof(RpcReqEapSetDisableTimeCheck), + 1, + rpc__req__eap_set_disable_time_check__field_descriptors, + rpc__req__eap_set_disable_time_check__field_indices_by_name, + 1, rpc__req__eap_set_disable_time_check__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_disable_time_check__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_disable_time_check__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetDisableTimeCheck, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_disable_time_check__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_disable_time_check__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_disable_time_check__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetDisableTimeCheck", + "RpcRespEapSetDisableTimeCheck", + "RpcRespEapSetDisableTimeCheck", + "", + sizeof(RpcRespEapSetDisableTimeCheck), + 1, + rpc__resp__eap_set_disable_time_check__field_descriptors, + rpc__resp__eap_set_disable_time_check__field_indices_by_name, + 1, rpc__resp__eap_set_disable_time_check__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_disable_time_check__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define rpc__req__eap_get_disable_time_check__field_descriptors NULL +#define rpc__req__eap_get_disable_time_check__field_indices_by_name NULL +#define rpc__req__eap_get_disable_time_check__number_ranges NULL +const ProtobufCMessageDescriptor rpc__req__eap_get_disable_time_check__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapGetDisableTimeCheck", + "RpcReqEapGetDisableTimeCheck", + "RpcReqEapGetDisableTimeCheck", + "", + sizeof(RpcReqEapGetDisableTimeCheck), + 0, + rpc__req__eap_get_disable_time_check__field_descriptors, + rpc__req__eap_get_disable_time_check__field_indices_by_name, + 0, rpc__req__eap_get_disable_time_check__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_get_disable_time_check__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_get_disable_time_check__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapGetDisableTimeCheck, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "disable", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcRespEapGetDisableTimeCheck, disable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_get_disable_time_check__field_indices_by_name[] = { + 1, /* field[1] = disable */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_get_disable_time_check__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_get_disable_time_check__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapGetDisableTimeCheck", + "RpcRespEapGetDisableTimeCheck", + "RpcRespEapGetDisableTimeCheck", + "", + sizeof(RpcRespEapGetDisableTimeCheck), + 2, + rpc__resp__eap_get_disable_time_check__field_descriptors, + rpc__resp__eap_get_disable_time_check__field_indices_by_name, + 1, rpc__resp__eap_get_disable_time_check__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_get_disable_time_check__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_ttls_phase2_method__field_descriptors[1] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetTtlsPhase2Method, type), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_ttls_phase2_method__field_indices_by_name[] = { + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange rpc__req__eap_set_ttls_phase2_method__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_ttls_phase2_method__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetTtlsPhase2Method", + "RpcReqEapSetTtlsPhase2Method", + "RpcReqEapSetTtlsPhase2Method", + "", + sizeof(RpcReqEapSetTtlsPhase2Method), + 1, + rpc__req__eap_set_ttls_phase2_method__field_descriptors, + rpc__req__eap_set_ttls_phase2_method__field_indices_by_name, + 1, rpc__req__eap_set_ttls_phase2_method__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_ttls_phase2_method__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_ttls_phase2_method__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetTtlsPhase2Method, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_ttls_phase2_method__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_ttls_phase2_method__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_ttls_phase2_method__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetTtlsPhase2Method", + "RpcRespEapSetTtlsPhase2Method", + "RpcRespEapSetTtlsPhase2Method", + "", + sizeof(RpcRespEapSetTtlsPhase2Method), + 1, + rpc__resp__eap_set_ttls_phase2_method__field_descriptors, + rpc__resp__eap_set_ttls_phase2_method__field_indices_by_name, + 1, rpc__resp__eap_set_ttls_phase2_method__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_ttls_phase2_method__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_suiteb192bit_certification__field_descriptors[1] = +{ + { + "enable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetSuiteb192bitCertification, enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_suiteb192bit_certification__field_indices_by_name[] = { + 0, /* field[0] = enable */ +}; +static const ProtobufCIntRange rpc__req__eap_set_suiteb192bit_certification__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_suiteb192bit_certification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetSuiteb192bitCertification", + "RpcReqEapSetSuiteb192bitCertification", + "RpcReqEapSetSuiteb192bitCertification", + "", + sizeof(RpcReqEapSetSuiteb192bitCertification), + 1, + rpc__req__eap_set_suiteb192bit_certification__field_descriptors, + rpc__req__eap_set_suiteb192bit_certification__field_indices_by_name, + 1, rpc__req__eap_set_suiteb192bit_certification__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_suiteb192bit_certification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_suiteb192bit_certification__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetSuiteb192bitCertification, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_suiteb192bit_certification__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_suiteb192bit_certification__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_suiteb192bit_certification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetSuiteb192bitCertification", + "RpcRespEapSetSuiteb192bitCertification", + "RpcRespEapSetSuiteb192bitCertification", + "", + sizeof(RpcRespEapSetSuiteb192bitCertification), + 1, + rpc__resp__eap_set_suiteb192bit_certification__field_descriptors, + rpc__resp__eap_set_suiteb192bit_certification__field_indices_by_name, + 1, rpc__resp__eap_set_suiteb192bit_certification__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_suiteb192bit_certification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_pac_file__field_descriptors[2] = +{ + { + "pac_file", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetPacFile, pac_file), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "pac_file_len", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetPacFile, pac_file_len), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_pac_file__field_indices_by_name[] = { + 0, /* field[0] = pac_file */ + 1, /* field[1] = pac_file_len */ +}; +static const ProtobufCIntRange rpc__req__eap_set_pac_file__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_pac_file__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetPacFile", + "RpcReqEapSetPacFile", + "RpcReqEapSetPacFile", + "", + sizeof(RpcReqEapSetPacFile), + 2, + rpc__req__eap_set_pac_file__field_descriptors, + rpc__req__eap_set_pac_file__field_indices_by_name, + 1, rpc__req__eap_set_pac_file__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_pac_file__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_pac_file__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetPacFile, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_pac_file__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_pac_file__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_pac_file__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetPacFile", + "RpcRespEapSetPacFile", + "RpcRespEapSetPacFile", + "", + sizeof(RpcRespEapSetPacFile), + 1, + rpc__resp__eap_set_pac_file__field_descriptors, + rpc__resp__eap_set_pac_file__field_indices_by_name, + 1, rpc__resp__eap_set_pac_file__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_pac_file__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_fast_params__field_descriptors[1] = +{ + { + "eap_fast_config", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetFastParams, eap_fast_config), + &eap_fast_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_fast_params__field_indices_by_name[] = { + 0, /* field[0] = eap_fast_config */ +}; +static const ProtobufCIntRange rpc__req__eap_set_fast_params__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_fast_params__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetFastParams", + "RpcReqEapSetFastParams", + "RpcReqEapSetFastParams", + "", + sizeof(RpcReqEapSetFastParams), + 1, + rpc__req__eap_set_fast_params__field_descriptors, + rpc__req__eap_set_fast_params__field_indices_by_name, + 1, rpc__req__eap_set_fast_params__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_fast_params__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_fast_params__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetFastParams, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_fast_params__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_fast_params__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_fast_params__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetFastParams", + "RpcRespEapSetFastParams", + "RpcRespEapSetFastParams", + "", + sizeof(RpcRespEapSetFastParams), + 1, + rpc__resp__eap_set_fast_params__field_descriptors, + rpc__resp__eap_set_fast_params__field_indices_by_name, + 1, rpc__resp__eap_set_fast_params__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_fast_params__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_use_default_cert_bundle__field_descriptors[1] = +{ + { + "use_default_bundle", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqEapUseDefaultCertBundle, use_default_bundle), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_use_default_cert_bundle__field_indices_by_name[] = { + 0, /* field[0] = use_default_bundle */ +}; +static const ProtobufCIntRange rpc__req__eap_use_default_cert_bundle__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_use_default_cert_bundle__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapUseDefaultCertBundle", + "RpcReqEapUseDefaultCertBundle", + "RpcReqEapUseDefaultCertBundle", + "", + sizeof(RpcReqEapUseDefaultCertBundle), + 1, + rpc__req__eap_use_default_cert_bundle__field_descriptors, + rpc__req__eap_use_default_cert_bundle__field_indices_by_name, + 1, rpc__req__eap_use_default_cert_bundle__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_use_default_cert_bundle__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_use_default_cert_bundle__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapUseDefaultCertBundle, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_use_default_cert_bundle__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_use_default_cert_bundle__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_use_default_cert_bundle__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapUseDefaultCertBundle", + "RpcRespEapUseDefaultCertBundle", + "RpcRespEapUseDefaultCertBundle", + "", + sizeof(RpcRespEapUseDefaultCertBundle), + 1, + rpc__resp__eap_use_default_cert_bundle__field_descriptors, + rpc__resp__eap_use_default_cert_bundle__field_indices_by_name, + 1, rpc__resp__eap_use_default_cert_bundle__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_use_default_cert_bundle__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__wifi_set_okc_support__field_descriptors[1] = +{ + { + "enable", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(RpcReqWifiSetOkcSupport, enable), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__wifi_set_okc_support__field_indices_by_name[] = { + 0, /* field[0] = enable */ +}; +static const ProtobufCIntRange rpc__req__wifi_set_okc_support__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__wifi_set_okc_support__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_WifiSetOkcSupport", + "RpcReqWifiSetOkcSupport", + "RpcReqWifiSetOkcSupport", + "", + sizeof(RpcReqWifiSetOkcSupport), + 1, + rpc__req__wifi_set_okc_support__field_descriptors, + rpc__req__wifi_set_okc_support__field_indices_by_name, + 1, rpc__req__wifi_set_okc_support__number_ranges, + (ProtobufCMessageInit) rpc__req__wifi_set_okc_support__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__wifi_set_okc_support__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespWifiSetOkcSupport, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__wifi_set_okc_support__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__wifi_set_okc_support__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__wifi_set_okc_support__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_WifiSetOkcSupport", + "RpcRespWifiSetOkcSupport", + "RpcRespWifiSetOkcSupport", + "", + sizeof(RpcRespWifiSetOkcSupport), + 1, + rpc__resp__wifi_set_okc_support__field_descriptors, + rpc__resp__wifi_set_okc_support__field_indices_by_name, + 1, rpc__resp__wifi_set_okc_support__number_ranges, + (ProtobufCMessageInit) rpc__resp__wifi_set_okc_support__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_domain_name__field_descriptors[1] = +{ + { + "domain_name", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetDomainName, domain_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_domain_name__field_indices_by_name[] = { + 0, /* field[0] = domain_name */ +}; +static const ProtobufCIntRange rpc__req__eap_set_domain_name__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_domain_name__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetDomainName", + "RpcReqEapSetDomainName", + "RpcReqEapSetDomainName", + "", + sizeof(RpcReqEapSetDomainName), + 1, + rpc__req__eap_set_domain_name__field_descriptors, + rpc__req__eap_set_domain_name__field_indices_by_name, + 1, rpc__req__eap_set_domain_name__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_domain_name__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_domain_name__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetDomainName, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_domain_name__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_domain_name__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_domain_name__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetDomainName", + "RpcRespEapSetDomainName", + "RpcRespEapSetDomainName", + "", + sizeof(RpcRespEapSetDomainName), + 1, + rpc__resp__eap_set_domain_name__field_descriptors, + rpc__resp__eap_set_domain_name__field_indices_by_name, + 1, rpc__resp__eap_set_domain_name__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_domain_name__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__req__eap_set_eap_methods__field_descriptors[1] = +{ + { + "methods", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcReqEapSetEapMethods, methods), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__req__eap_set_eap_methods__field_indices_by_name[] = { + 0, /* field[0] = methods */ +}; +static const ProtobufCIntRange rpc__req__eap_set_eap_methods__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__req__eap_set_eap_methods__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Req_EapSetEapMethods", + "RpcReqEapSetEapMethods", + "RpcReqEapSetEapMethods", + "", + sizeof(RpcReqEapSetEapMethods), + 1, + rpc__req__eap_set_eap_methods__field_descriptors, + rpc__req__eap_set_eap_methods__field_indices_by_name, + 1, rpc__req__eap_set_eap_methods__number_ranges, + (ProtobufCMessageInit) rpc__req__eap_set_eap_methods__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__resp__eap_set_eap_methods__field_descriptors[1] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcRespEapSetEapMethods, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__resp__eap_set_eap_methods__field_indices_by_name[] = { + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__resp__eap_set_eap_methods__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor rpc__resp__eap_set_eap_methods__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Resp_EapSetEapMethods", + "RpcRespEapSetEapMethods", + "RpcRespEapSetEapMethods", + "", + sizeof(RpcRespEapSetEapMethods), + 1, + rpc__resp__eap_set_eap_methods__field_descriptors, + rpc__resp__eap_set_eap_methods__field_indices_by_name, + 1, rpc__resp__eap_set_eap_methods__number_ranges, + (ProtobufCMessageInit) rpc__resp__eap_set_eap_methods__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__supp_dpp_uri_ready__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventSuppDppUriReady, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "qrcode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventSuppDppUriReady, qrcode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__supp_dpp_uri_ready__field_indices_by_name[] = { + 1, /* field[1] = qrcode */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__supp_dpp_uri_ready__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__supp_dpp_uri_ready__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_SuppDppUriReady", + "RpcEventSuppDppUriReady", + "RpcEventSuppDppUriReady", + "", + sizeof(RpcEventSuppDppUriReady), + 2, + rpc__event__supp_dpp_uri_ready__field_descriptors, + rpc__event__supp_dpp_uri_ready__field_indices_by_name, + 1, rpc__event__supp_dpp_uri_ready__number_ranges, + (ProtobufCMessageInit) rpc__event__supp_dpp_uri_ready__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__supp_dpp_cfg_recvd__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventSuppDppCfgRecvd, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cfg", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventSuppDppCfgRecvd, cfg), + &wifi_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__supp_dpp_cfg_recvd__field_indices_by_name[] = { + 1, /* field[1] = cfg */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__supp_dpp_cfg_recvd__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__supp_dpp_cfg_recvd__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_SuppDppCfgRecvd", + "RpcEventSuppDppCfgRecvd", + "RpcEventSuppDppCfgRecvd", + "", + sizeof(RpcEventSuppDppCfgRecvd), + 2, + rpc__event__supp_dpp_cfg_recvd__field_descriptors, + rpc__event__supp_dpp_cfg_recvd__field_indices_by_name, + 1, rpc__event__supp_dpp_cfg_recvd__number_ranges, + (ProtobufCMessageInit) rpc__event__supp_dpp_cfg_recvd__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__supp_dpp_fail__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventSuppDppFail, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventSuppDppFail, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__supp_dpp_fail__field_indices_by_name[] = { + 1, /* field[1] = reason */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__supp_dpp_fail__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__supp_dpp_fail__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_SuppDppFail", + "RpcEventSuppDppFail", + "RpcEventSuppDppFail", + "", + sizeof(RpcEventSuppDppFail), + 2, + rpc__event__supp_dpp_fail__field_descriptors, + rpc__event__supp_dpp_fail__field_indices_by_name, + 1, rpc__event__supp_dpp_fail__number_ranges, + (ProtobufCMessageInit) rpc__event__supp_dpp_fail__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__wifi_dpp_uri_ready__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiDppUriReady, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "qrcode", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiDppUriReady, qrcode), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__wifi_dpp_uri_ready__field_indices_by_name[] = { + 1, /* field[1] = qrcode */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__wifi_dpp_uri_ready__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__wifi_dpp_uri_ready__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_WifiDppUriReady", + "RpcEventWifiDppUriReady", + "RpcEventWifiDppUriReady", + "", + sizeof(RpcEventWifiDppUriReady), + 2, + rpc__event__wifi_dpp_uri_ready__field_descriptors, + rpc__event__wifi_dpp_uri_ready__field_indices_by_name, + 1, rpc__event__wifi_dpp_uri_ready__number_ranges, + (ProtobufCMessageInit) rpc__event__wifi_dpp_uri_ready__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__wifi_dpp_cfg_recvd__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiDppCfgRecvd, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cfg", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiDppCfgRecvd, cfg), + &wifi_config__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__wifi_dpp_cfg_recvd__field_indices_by_name[] = { + 1, /* field[1] = cfg */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__wifi_dpp_cfg_recvd__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__wifi_dpp_cfg_recvd__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_WifiDppCfgRecvd", + "RpcEventWifiDppCfgRecvd", + "RpcEventWifiDppCfgRecvd", + "", + sizeof(RpcEventWifiDppCfgRecvd), + 2, + rpc__event__wifi_dpp_cfg_recvd__field_descriptors, + rpc__event__wifi_dpp_cfg_recvd__field_indices_by_name, + 1, rpc__event__wifi_dpp_cfg_recvd__number_ranges, + (ProtobufCMessageInit) rpc__event__wifi_dpp_cfg_recvd__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__event__wifi_dpp_fail__field_descriptors[2] = +{ + { + "resp", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiDppFail, resp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "reason", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(RpcEventWifiDppFail, reason), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__event__wifi_dpp_fail__field_indices_by_name[] = { + 1, /* field[1] = reason */ + 0, /* field[0] = resp */ +}; +static const ProtobufCIntRange rpc__event__wifi_dpp_fail__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor rpc__event__wifi_dpp_fail__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc_Event_WifiDppFail", + "RpcEventWifiDppFail", + "RpcEventWifiDppFail", + "", + sizeof(RpcEventWifiDppFail), + 2, + rpc__event__wifi_dpp_fail__field_descriptors, + rpc__event__wifi_dpp_fail__field_indices_by_name, + 1, rpc__event__wifi_dpp_fail__number_ranges, + (ProtobufCMessageInit) rpc__event__wifi_dpp_fail__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor rpc__field_descriptors[218] = +{ + { + "msg_type", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Rpc, msg_type), + &rpc_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "msg_id", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Rpc, msg_id), + &rpc_id__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "uid", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Rpc, uid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_mac_address", + 257, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_mac_address), + &rpc__req__get_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_mac_address", + 258, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_mac_address), + &rpc__req__set_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_wifi_mode", + 259, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_wifi_mode), + &rpc__req__get_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_wifi_mode", + 260, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_wifi_mode), + &rpc__req__set_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_supp_dpp_init", + 261, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_supp_dpp_init), + &rpc__req__supp_dpp_init__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_supp_dpp_deinit", + 262, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_supp_dpp_deinit), + &rpc__req__supp_dpp_deinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_supp_dpp_bootstrap_gen", + 263, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_supp_dpp_bootstrap_gen), + &rpc__req__supp_dpp_bootstrap_gen__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_supp_dpp_start_listen", + 264, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_supp_dpp_start_listen), + &rpc__req__supp_dpp_start_listen__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_supp_dpp_stop_listen", + 265, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_supp_dpp_stop_listen), + &rpc__req__supp_dpp_stop_listen__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_ps", + 270, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_ps), + &rpc__req__set_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_ps", + 271, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_ps), + &rpc__req__get_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_ota_begin", + 272, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_ota_begin), + &rpc__req__otabegin__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_ota_write", + 273, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_ota_write), + &rpc__req__otawrite__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_ota_end", + 274, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_ota_end), + &rpc__req__otaend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_wifi_max_tx_power", + 275, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_wifi_max_tx_power), + &rpc__req__wifi_set_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_wifi_max_tx_power", + 276, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_wifi_max_tx_power), + &rpc__req__wifi_get_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_config_heartbeat", + 277, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_config_heartbeat), + &rpc__req__config_heartbeat__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_init", + 278, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_init), + &rpc__req__wifi_init__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_deinit", + 279, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_deinit), + &rpc__req__wifi_deinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_start", + 280, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_start), + &rpc__req__wifi_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_stop", + 281, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_stop), + &rpc__req__wifi_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_connect", + 282, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_connect), + &rpc__req__wifi_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_disconnect", + 283, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_disconnect), + &rpc__req__wifi_disconnect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_config", + 284, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_config), + &rpc__req__wifi_set_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_config", + 285, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_config), + &rpc__req__wifi_get_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_start", + 286, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_start), + &rpc__req__wifi_scan_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_stop", + 287, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_stop), + &rpc__req__wifi_scan_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_get_ap_num", + 288, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_get_ap_num), + &rpc__req__wifi_scan_get_ap_num__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_get_ap_records", + 289, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_get_ap_records), + &rpc__req__wifi_scan_get_ap_records__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_clear_ap_list", + 290, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_clear_ap_list), + &rpc__req__wifi_clear_ap_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_restore", + 291, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_restore), + &rpc__req__wifi_restore__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_clear_fast_connect", + 292, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_clear_fast_connect), + &rpc__req__wifi_clear_fast_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_deauth_sta", + 293, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_deauth_sta), + &rpc__req__wifi_deauth_sta__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_ap_info", + 294, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_ap_info), + &rpc__req__wifi_sta_get_ap_info__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_protocol", + 297, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_protocol), + &rpc__req__wifi_set_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_protocol", + 298, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_protocol), + &rpc__req__wifi_get_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_bandwidth", + 299, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_bandwidth), + &rpc__req__wifi_set_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_bandwidth", + 300, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_bandwidth), + &rpc__req__wifi_get_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_channel", + 301, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_channel), + &rpc__req__wifi_set_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_channel", + 302, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_channel), + &rpc__req__wifi_get_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_country", + 303, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_country), + &rpc__req__wifi_set_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_country", + 304, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_country), + &rpc__req__wifi_get_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_ap_get_sta_list", + 311, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_ap_get_sta_list), + &rpc__req__wifi_ap_get_sta_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_ap_get_sta_aid", + 312, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_ap_get_sta_aid), + &rpc__req__wifi_ap_get_sta_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_storage", + 313, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_storage), + &rpc__req__wifi_set_storage__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_inactive_time", + 325, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_inactive_time), + &rpc__req__wifi_set_inactive_time__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_inactive_time", + 326, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_inactive_time), + &rpc__req__wifi_get_inactive_time__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_country_code", + 334, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_country_code), + &rpc__req__wifi_set_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_country_code", + 335, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_country_code), + &rpc__req__wifi_get_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_aid", + 338, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_aid), + &rpc__req__wifi_sta_get_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_negotiated_phymode", + 339, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_negotiated_phymode), + &rpc__req__wifi_sta_get_negotiated_phymode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_get_rssi", + 341, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_get_rssi), + &rpc__req__wifi_sta_get_rssi__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_protocols", + 342, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_protocols), + &rpc__req__wifi_set_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_protocols", + 343, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_protocols), + &rpc__req__wifi_get_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_bandwidths", + 344, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_bandwidths), + &rpc__req__wifi_set_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_bandwidths", + 345, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_bandwidths), + &rpc__req__wifi_get_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_band", + 346, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_band), + &rpc__req__wifi_set_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_band", + 347, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_band), + &rpc__req__wifi_get_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_bandmode", + 348, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_bandmode), + &rpc__req__wifi_set_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_get_bandmode", + 349, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_get_bandmode), + &rpc__req__wifi_get_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_coprocessor_fwversion", + 350, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_coprocessor_fwversion), + &rpc__req__get_coprocessor_fw_version__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_scan_get_ap_record", + 351, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_scan_get_ap_record), + &rpc__req__wifi_scan_get_ap_record__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_set_dhcp_dns", + 352, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_set_dhcp_dns), + &rpc__req__set_dhcp_dns_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_get_dhcp_dns", + 353, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_get_dhcp_dns), + &rpc__req__get_dhcp_dns_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_twt_config", + 354, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_twt_config), + &rpc__req__wifi_sta_twt_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_itwt_setup", + 355, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_itwt_setup), + &rpc__req__wifi_sta_itwt_setup__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_itwt_teardown", + 356, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_itwt_teardown), + &rpc__req__wifi_sta_itwt_teardown__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_itwt_suspend", + 357, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_itwt_suspend), + &rpc__req__wifi_sta_itwt_suspend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_itwt_get_flow_id_status", + 358, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_itwt_get_flow_id_status), + &rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_itwt_send_probe_req", + 359, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_itwt_send_probe_req), + &rpc__req__wifi_sta_itwt_send_probe_req__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_itwt_set_target_wake_time_offset", + 360, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_itwt_set_target_wake_time_offset), + &rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_enterprise_enable", + 361, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_enterprise_enable), + &rpc__req__wifi_sta_enterprise_enable__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_sta_enterprise_disable", + 362, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_sta_enterprise_disable), + &rpc__req__wifi_sta_enterprise_disable__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_identity", + 363, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_identity), + &rpc__req__eap_set_identity__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_clear_identity", + 364, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_clear_identity), + &rpc__req__eap_clear_identity__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_username", + 365, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_username), + &rpc__req__eap_set_username__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_clear_username", + 366, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_clear_username), + &rpc__req__eap_clear_username__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_password", + 367, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_password), + &rpc__req__eap_set_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_clear_password", + 368, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_clear_password), + &rpc__req__eap_clear_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_new_password", + 369, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_new_password), + &rpc__req__eap_set_new_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_clear_new_password", + 370, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_clear_new_password), + &rpc__req__eap_clear_new_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_ca_cert", + 371, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_ca_cert), + &rpc__req__eap_set_ca_cert__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_clear_ca_cert", + 372, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_clear_ca_cert), + &rpc__req__eap_clear_ca_cert__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_certificate_and_key", + 373, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_certificate_and_key), + &rpc__req__eap_set_certificate_and_key__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_clear_certificate_and_key", + 374, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_clear_certificate_and_key), + &rpc__req__eap_clear_certificate_and_key__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_get_disable_time_check", + 375, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_get_disable_time_check), + &rpc__req__eap_get_disable_time_check__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_ttls_phase2_method", + 376, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_ttls_phase2_method), + &rpc__req__eap_set_ttls_phase2_method__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_suiteb_certification", + 377, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_suiteb_certification), + &rpc__req__eap_set_suiteb192bit_certification__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_pac_file", + 378, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_pac_file), + &rpc__req__eap_set_pac_file__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_fast_params", + 379, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_fast_params), + &rpc__req__eap_set_fast_params__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_use_default_cert_bundle", + 380, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_use_default_cert_bundle), + &rpc__req__eap_use_default_cert_bundle__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_wifi_set_okc_support", + 381, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_wifi_set_okc_support), + &rpc__req__wifi_set_okc_support__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_domain_name", + 382, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_domain_name), + &rpc__req__eap_set_domain_name__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_disable_time_check", + 383, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_disable_time_check), + &rpc__req__eap_set_disable_time_check__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_eap_set_eap_methods", + 384, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_eap_set_eap_methods), + &rpc__req__eap_set_eap_methods__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_iface_mac_addr_set_get", + 385, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_iface_mac_addr_set_get), + &rpc__req__iface_mac_addr_set_get__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_iface_mac_addr_len_get", + 386, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_iface_mac_addr_len_get), + &rpc__req__iface_mac_addr_len_get__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "req_feature_control", + 387, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, req_feature_control), + &rpc__req__feature_control__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_mac_address", + 513, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_mac_address), + &rpc__resp__get_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_mac_address", + 514, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_mac_address), + &rpc__resp__set_mac_address__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_wifi_mode", + 515, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_wifi_mode), + &rpc__resp__get_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_wifi_mode", + 516, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_wifi_mode), + &rpc__resp__set_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_supp_dpp_init", + 517, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_supp_dpp_init), + &rpc__resp__supp_dpp_init__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_supp_dpp_deinit", + 518, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_supp_dpp_deinit), + &rpc__resp__supp_dpp_deinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_supp_dpp_bootstrap_gen", + 519, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_supp_dpp_bootstrap_gen), + &rpc__resp__supp_dpp_bootstrap_gen__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_supp_dpp_start_listen", + 520, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_supp_dpp_start_listen), + &rpc__resp__supp_dpp_start_listen__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_supp_dpp_stop_listen", + 521, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_supp_dpp_stop_listen), + &rpc__resp__supp_dpp_stop_listen__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_ps", + 526, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_ps), + &rpc__resp__set_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_ps", + 527, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_ps), + &rpc__resp__get_ps__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_ota_begin", + 528, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_ota_begin), + &rpc__resp__otabegin__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_ota_write", + 529, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_ota_write), + &rpc__resp__otawrite__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_ota_end", + 530, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_ota_end), + &rpc__resp__otaend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_wifi_max_tx_power", + 531, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_wifi_max_tx_power), + &rpc__resp__wifi_set_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_wifi_max_tx_power", + 532, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_wifi_max_tx_power), + &rpc__resp__wifi_get_max_tx_power__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_config_heartbeat", + 533, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_config_heartbeat), + &rpc__resp__config_heartbeat__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_init", + 534, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_init), + &rpc__resp__wifi_init__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_deinit", + 535, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_deinit), + &rpc__resp__wifi_deinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_start", + 536, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_start), + &rpc__resp__wifi_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_stop", + 537, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_stop), + &rpc__resp__wifi_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_connect", + 538, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_connect), + &rpc__resp__wifi_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_disconnect", + 539, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_disconnect), + &rpc__resp__wifi_disconnect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_config", + 540, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_config), + &rpc__resp__wifi_set_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_config", + 541, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_config), + &rpc__resp__wifi_get_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_start", + 542, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_start), + &rpc__resp__wifi_scan_start__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_stop", + 543, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_stop), + &rpc__resp__wifi_scan_stop__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_get_ap_num", + 544, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_get_ap_num), + &rpc__resp__wifi_scan_get_ap_num__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_get_ap_records", + 545, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_get_ap_records), + &rpc__resp__wifi_scan_get_ap_records__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_clear_ap_list", + 546, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_clear_ap_list), + &rpc__resp__wifi_clear_ap_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_restore", + 547, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_restore), + &rpc__resp__wifi_restore__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_clear_fast_connect", + 548, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_clear_fast_connect), + &rpc__resp__wifi_clear_fast_connect__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_deauth_sta", + 549, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_deauth_sta), + &rpc__resp__wifi_deauth_sta__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_ap_info", + 550, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_ap_info), + &rpc__resp__wifi_sta_get_ap_info__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_protocol", + 553, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_protocol), + &rpc__resp__wifi_set_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_protocol", + 554, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_protocol), + &rpc__resp__wifi_get_protocol__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_bandwidth", + 555, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_bandwidth), + &rpc__resp__wifi_set_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_bandwidth", + 556, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_bandwidth), + &rpc__resp__wifi_get_bandwidth__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_channel", + 557, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_channel), + &rpc__resp__wifi_set_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_channel", + 558, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_channel), + &rpc__resp__wifi_get_channel__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_country", + 559, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_country), + &rpc__resp__wifi_set_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_country", + 560, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_country), + &rpc__resp__wifi_get_country__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_ap_get_sta_list", + 567, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_ap_get_sta_list), + &rpc__resp__wifi_ap_get_sta_list__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_ap_get_sta_aid", + 568, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_ap_get_sta_aid), + &rpc__resp__wifi_ap_get_sta_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_storage", + 569, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_storage), + &rpc__resp__wifi_set_storage__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_inactive_time", + 581, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_inactive_time), + &rpc__resp__wifi_set_inactive_time__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_inactive_time", + 582, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_inactive_time), + &rpc__resp__wifi_get_inactive_time__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_country_code", + 590, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_country_code), + &rpc__resp__wifi_set_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_country_code", + 591, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_country_code), + &rpc__resp__wifi_get_country_code__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_aid", + 594, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_aid), + &rpc__resp__wifi_sta_get_aid__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_negotiated_phymode", + 595, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_negotiated_phymode), + &rpc__resp__wifi_sta_get_negotiated_phymode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_get_rssi", + 597, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_get_rssi), + &rpc__resp__wifi_sta_get_rssi__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_protocols", + 598, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_protocols), + &rpc__resp__wifi_set_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_protocols", + 599, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_protocols), + &rpc__resp__wifi_get_protocols__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_bandwidths", + 600, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_bandwidths), + &rpc__resp__wifi_set_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_bandwidths", + 601, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_bandwidths), + &rpc__resp__wifi_get_bandwidths__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_band", + 602, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_band), + &rpc__resp__wifi_set_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_band", + 603, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_band), + &rpc__resp__wifi_get_band__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_bandmode", + 604, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_bandmode), + &rpc__resp__wifi_set_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_get_bandmode", + 605, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_get_bandmode), + &rpc__resp__wifi_get_band_mode__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_coprocessor_fwversion", + 606, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_coprocessor_fwversion), + &rpc__resp__get_coprocessor_fw_version__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_scan_get_ap_record", + 607, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_scan_get_ap_record), + &rpc__resp__wifi_scan_get_ap_record__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_set_dhcp_dns", + 608, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_set_dhcp_dns), + &rpc__resp__set_dhcp_dns_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_get_dhcp_dns", + 609, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_get_dhcp_dns), + &rpc__resp__get_dhcp_dns_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_twt_config", + 610, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_twt_config), + &rpc__resp__wifi_sta_twt_config__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_itwt_setup", + 611, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_itwt_setup), + &rpc__resp__wifi_sta_itwt_setup__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_itwt_teardown", + 612, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_itwt_teardown), + &rpc__resp__wifi_sta_itwt_teardown__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_itwt_suspend", + 613, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_itwt_suspend), + &rpc__resp__wifi_sta_itwt_suspend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_itwt_get_flow_id_status", + 614, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_itwt_get_flow_id_status), + &rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_itwt_send_probe_req", + 615, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_itwt_send_probe_req), + &rpc__resp__wifi_sta_itwt_send_probe_req__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_itwt_set_target_wake_time_offset", + 616, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_itwt_set_target_wake_time_offset), + &rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_enterprise_enable", + 617, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_enterprise_enable), + &rpc__resp__wifi_sta_enterprise_enable__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_sta_enterprise_disable", + 618, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_sta_enterprise_disable), + &rpc__resp__wifi_sta_enterprise_disable__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_identity", + 619, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_identity), + &rpc__resp__eap_set_identity__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_clear_identity", + 620, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_clear_identity), + &rpc__resp__eap_clear_identity__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_username", + 621, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_username), + &rpc__resp__eap_set_username__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_clear_username", + 622, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_clear_username), + &rpc__resp__eap_clear_username__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_password", + 623, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_password), + &rpc__resp__eap_set_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_clear_password", + 624, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_clear_password), + &rpc__resp__eap_clear_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_new_password", + 625, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_new_password), + &rpc__resp__eap_set_new_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_clear_new_password", + 626, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_clear_new_password), + &rpc__resp__eap_clear_new_password__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_ca_cert", + 627, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_ca_cert), + &rpc__resp__eap_set_ca_cert__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_clear_ca_cert", + 628, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_clear_ca_cert), + &rpc__resp__eap_clear_ca_cert__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_certificate_and_key", + 629, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_certificate_and_key), + &rpc__resp__eap_set_certificate_and_key__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_clear_certificate_and_key", + 630, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_clear_certificate_and_key), + &rpc__resp__eap_clear_certificate_and_key__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_get_disable_time_check", + 631, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_get_disable_time_check), + &rpc__resp__eap_get_disable_time_check__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_ttls_phase2_method", + 632, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_ttls_phase2_method), + &rpc__resp__eap_set_ttls_phase2_method__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_suiteb_certification", + 633, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_suiteb_certification), + &rpc__resp__eap_set_suiteb192bit_certification__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_pac_file", + 634, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_pac_file), + &rpc__resp__eap_set_pac_file__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_fast_params", + 635, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_fast_params), + &rpc__resp__eap_set_fast_params__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_use_default_cert_bundle", + 636, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_use_default_cert_bundle), + &rpc__resp__eap_use_default_cert_bundle__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_wifi_set_okc_support", + 637, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_wifi_set_okc_support), + &rpc__resp__wifi_set_okc_support__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_domain_name", + 638, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_domain_name), + &rpc__resp__eap_set_domain_name__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_disable_time_check", + 639, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_disable_time_check), + &rpc__resp__eap_set_disable_time_check__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_eap_set_eap_methods", + 640, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_eap_set_eap_methods), + &rpc__resp__eap_set_eap_methods__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_iface_mac_addr_set_get", + 641, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_iface_mac_addr_set_get), + &rpc__resp__iface_mac_addr_set_get__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_iface_mac_addr_len_get", + 642, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_iface_mac_addr_len_get), + &rpc__resp__iface_mac_addr_len_get__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resp_feature_control", + 643, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, resp_feature_control), + &rpc__resp__feature_control__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_esp_init", + 769, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_esp_init), + &rpc__event__espinit__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_heartbeat", + 770, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_heartbeat), + &rpc__event__heartbeat__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_ap_sta_connected", + 771, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_ap_sta_connected), + &rpc__event__ap__sta_connected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_ap_sta_disconnected", + 772, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_ap_sta_disconnected), + &rpc__event__ap__sta_disconnected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_wifi_event_no_args", + 773, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_wifi_event_no_args), + &rpc__event__wifi_event_no_args__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_scan_done", + 774, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_scan_done), + &rpc__event__sta_scan_done__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_connected", + 775, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_connected), + &rpc__event__sta_connected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_disconnected", + 776, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_disconnected), + &rpc__event__sta_disconnected__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_dhcp_dns", + 777, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_dhcp_dns), + &rpc__event__dhcp_dns_status__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_itwt_setup", + 778, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_itwt_setup), + &rpc__event__sta_itwt_setup__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_itwt_teardown", + 779, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_itwt_teardown), + &rpc__event__sta_itwt_teardown__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_itwt_suspend", + 780, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_itwt_suspend), + &rpc__event__sta_itwt_suspend__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_sta_itwt_probe", + 781, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_sta_itwt_probe), + &rpc__event__sta_itwt_probe__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_supp_dpp_uri_ready", + 782, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_supp_dpp_uri_ready), + &rpc__event__supp_dpp_uri_ready__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_supp_dpp_cfg_recvd", + 783, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_supp_dpp_cfg_recvd), + &rpc__event__supp_dpp_cfg_recvd__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_supp_dpp_fail", + 784, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_supp_dpp_fail), + &rpc__event__supp_dpp_fail__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_wifi_dpp_uri_ready", + 785, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_wifi_dpp_uri_ready), + &rpc__event__wifi_dpp_uri_ready__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_wifi_dpp_cfg_recvd", + 786, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_wifi_dpp_cfg_recvd), + &rpc__event__wifi_dpp_cfg_recvd__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_wifi_dpp_fail", + 787, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Rpc, payload_case), + offsetof(Rpc, event_wifi_dpp_fail), + &rpc__event__wifi_dpp_fail__descriptor, + NULL, + 0 | PROTOBUF_C_FIELD_FLAG_ONEOF, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned rpc__field_indices_by_name[] = { + 201, /* field[201] = event_ap_sta_connected */ + 202, /* field[202] = event_ap_sta_disconnected */ + 207, /* field[207] = event_dhcp_dns */ + 199, /* field[199] = event_esp_init */ + 200, /* field[200] = event_heartbeat */ + 205, /* field[205] = event_sta_connected */ + 206, /* field[206] = event_sta_disconnected */ + 211, /* field[211] = event_sta_itwt_probe */ + 208, /* field[208] = event_sta_itwt_setup */ + 210, /* field[210] = event_sta_itwt_suspend */ + 209, /* field[209] = event_sta_itwt_teardown */ + 204, /* field[204] = event_sta_scan_done */ + 213, /* field[213] = event_supp_dpp_cfg_recvd */ + 214, /* field[214] = event_supp_dpp_fail */ + 212, /* field[212] = event_supp_dpp_uri_ready */ + 216, /* field[216] = event_wifi_dpp_cfg_recvd */ + 217, /* field[217] = event_wifi_dpp_fail */ + 215, /* field[215] = event_wifi_dpp_uri_ready */ + 203, /* field[203] = event_wifi_event_no_args */ + 1, /* field[1] = msg_id */ + 0, /* field[0] = msg_type */ + 19, /* field[19] = req_config_heartbeat */ + 85, /* field[85] = req_eap_clear_ca_cert */ + 87, /* field[87] = req_eap_clear_certificate_and_key */ + 77, /* field[77] = req_eap_clear_identity */ + 83, /* field[83] = req_eap_clear_new_password */ + 81, /* field[81] = req_eap_clear_password */ + 79, /* field[79] = req_eap_clear_username */ + 88, /* field[88] = req_eap_get_disable_time_check */ + 84, /* field[84] = req_eap_set_ca_cert */ + 86, /* field[86] = req_eap_set_certificate_and_key */ + 96, /* field[96] = req_eap_set_disable_time_check */ + 95, /* field[95] = req_eap_set_domain_name */ + 97, /* field[97] = req_eap_set_eap_methods */ + 92, /* field[92] = req_eap_set_fast_params */ + 76, /* field[76] = req_eap_set_identity */ + 82, /* field[82] = req_eap_set_new_password */ + 91, /* field[91] = req_eap_set_pac_file */ + 80, /* field[80] = req_eap_set_password */ + 90, /* field[90] = req_eap_set_suiteb_certification */ + 89, /* field[89] = req_eap_set_ttls_phase2_method */ + 78, /* field[78] = req_eap_set_username */ + 93, /* field[93] = req_eap_use_default_cert_bundle */ + 100, /* field[100] = req_feature_control */ + 63, /* field[63] = req_get_coprocessor_fwversion */ + 66, /* field[66] = req_get_dhcp_dns */ + 3, /* field[3] = req_get_mac_address */ + 18, /* field[18] = req_get_wifi_max_tx_power */ + 5, /* field[5] = req_get_wifi_mode */ + 99, /* field[99] = req_iface_mac_addr_len_get */ + 98, /* field[98] = req_iface_mac_addr_set_get */ + 14, /* field[14] = req_ota_begin */ + 16, /* field[16] = req_ota_end */ + 15, /* field[15] = req_ota_write */ + 65, /* field[65] = req_set_dhcp_dns */ + 4, /* field[4] = req_set_mac_address */ + 17, /* field[17] = req_set_wifi_max_tx_power */ + 6, /* field[6] = req_set_wifi_mode */ + 9, /* field[9] = req_supp_dpp_bootstrap_gen */ + 8, /* field[8] = req_supp_dpp_deinit */ + 7, /* field[7] = req_supp_dpp_init */ + 10, /* field[10] = req_supp_dpp_start_listen */ + 11, /* field[11] = req_supp_dpp_stop_listen */ + 46, /* field[46] = req_wifi_ap_get_sta_aid */ + 45, /* field[45] = req_wifi_ap_get_sta_list */ + 32, /* field[32] = req_wifi_clear_ap_list */ + 34, /* field[34] = req_wifi_clear_fast_connect */ + 24, /* field[24] = req_wifi_connect */ + 35, /* field[35] = req_wifi_deauth_sta */ + 21, /* field[21] = req_wifi_deinit */ + 25, /* field[25] = req_wifi_disconnect */ + 60, /* field[60] = req_wifi_get_band */ + 62, /* field[62] = req_wifi_get_bandmode */ + 40, /* field[40] = req_wifi_get_bandwidth */ + 58, /* field[58] = req_wifi_get_bandwidths */ + 42, /* field[42] = req_wifi_get_channel */ + 27, /* field[27] = req_wifi_get_config */ + 44, /* field[44] = req_wifi_get_country */ + 51, /* field[51] = req_wifi_get_country_code */ + 49, /* field[49] = req_wifi_get_inactive_time */ + 38, /* field[38] = req_wifi_get_protocol */ + 56, /* field[56] = req_wifi_get_protocols */ + 13, /* field[13] = req_wifi_get_ps */ + 20, /* field[20] = req_wifi_init */ + 33, /* field[33] = req_wifi_restore */ + 30, /* field[30] = req_wifi_scan_get_ap_num */ + 64, /* field[64] = req_wifi_scan_get_ap_record */ + 31, /* field[31] = req_wifi_scan_get_ap_records */ + 28, /* field[28] = req_wifi_scan_start */ + 29, /* field[29] = req_wifi_scan_stop */ + 59, /* field[59] = req_wifi_set_band */ + 61, /* field[61] = req_wifi_set_bandmode */ + 39, /* field[39] = req_wifi_set_bandwidth */ + 57, /* field[57] = req_wifi_set_bandwidths */ + 41, /* field[41] = req_wifi_set_channel */ + 26, /* field[26] = req_wifi_set_config */ + 43, /* field[43] = req_wifi_set_country */ + 50, /* field[50] = req_wifi_set_country_code */ + 48, /* field[48] = req_wifi_set_inactive_time */ + 94, /* field[94] = req_wifi_set_okc_support */ + 37, /* field[37] = req_wifi_set_protocol */ + 55, /* field[55] = req_wifi_set_protocols */ + 12, /* field[12] = req_wifi_set_ps */ + 47, /* field[47] = req_wifi_set_storage */ + 75, /* field[75] = req_wifi_sta_enterprise_disable */ + 74, /* field[74] = req_wifi_sta_enterprise_enable */ + 52, /* field[52] = req_wifi_sta_get_aid */ + 36, /* field[36] = req_wifi_sta_get_ap_info */ + 53, /* field[53] = req_wifi_sta_get_negotiated_phymode */ + 54, /* field[54] = req_wifi_sta_get_rssi */ + 71, /* field[71] = req_wifi_sta_itwt_get_flow_id_status */ + 72, /* field[72] = req_wifi_sta_itwt_send_probe_req */ + 73, /* field[73] = req_wifi_sta_itwt_set_target_wake_time_offset */ + 68, /* field[68] = req_wifi_sta_itwt_setup */ + 70, /* field[70] = req_wifi_sta_itwt_suspend */ + 69, /* field[69] = req_wifi_sta_itwt_teardown */ + 67, /* field[67] = req_wifi_sta_twt_config */ + 22, /* field[22] = req_wifi_start */ + 23, /* field[23] = req_wifi_stop */ + 117, /* field[117] = resp_config_heartbeat */ + 183, /* field[183] = resp_eap_clear_ca_cert */ + 185, /* field[185] = resp_eap_clear_certificate_and_key */ + 175, /* field[175] = resp_eap_clear_identity */ + 181, /* field[181] = resp_eap_clear_new_password */ + 179, /* field[179] = resp_eap_clear_password */ + 177, /* field[177] = resp_eap_clear_username */ + 186, /* field[186] = resp_eap_get_disable_time_check */ + 182, /* field[182] = resp_eap_set_ca_cert */ + 184, /* field[184] = resp_eap_set_certificate_and_key */ + 194, /* field[194] = resp_eap_set_disable_time_check */ + 193, /* field[193] = resp_eap_set_domain_name */ + 195, /* field[195] = resp_eap_set_eap_methods */ + 190, /* field[190] = resp_eap_set_fast_params */ + 174, /* field[174] = resp_eap_set_identity */ + 180, /* field[180] = resp_eap_set_new_password */ + 189, /* field[189] = resp_eap_set_pac_file */ + 178, /* field[178] = resp_eap_set_password */ + 188, /* field[188] = resp_eap_set_suiteb_certification */ + 187, /* field[187] = resp_eap_set_ttls_phase2_method */ + 176, /* field[176] = resp_eap_set_username */ + 191, /* field[191] = resp_eap_use_default_cert_bundle */ + 198, /* field[198] = resp_feature_control */ + 161, /* field[161] = resp_get_coprocessor_fwversion */ + 164, /* field[164] = resp_get_dhcp_dns */ + 101, /* field[101] = resp_get_mac_address */ + 116, /* field[116] = resp_get_wifi_max_tx_power */ + 103, /* field[103] = resp_get_wifi_mode */ + 197, /* field[197] = resp_iface_mac_addr_len_get */ + 196, /* field[196] = resp_iface_mac_addr_set_get */ + 112, /* field[112] = resp_ota_begin */ + 114, /* field[114] = resp_ota_end */ + 113, /* field[113] = resp_ota_write */ + 163, /* field[163] = resp_set_dhcp_dns */ + 102, /* field[102] = resp_set_mac_address */ + 115, /* field[115] = resp_set_wifi_max_tx_power */ + 104, /* field[104] = resp_set_wifi_mode */ + 107, /* field[107] = resp_supp_dpp_bootstrap_gen */ + 106, /* field[106] = resp_supp_dpp_deinit */ + 105, /* field[105] = resp_supp_dpp_init */ + 108, /* field[108] = resp_supp_dpp_start_listen */ + 109, /* field[109] = resp_supp_dpp_stop_listen */ + 144, /* field[144] = resp_wifi_ap_get_sta_aid */ + 143, /* field[143] = resp_wifi_ap_get_sta_list */ + 130, /* field[130] = resp_wifi_clear_ap_list */ + 132, /* field[132] = resp_wifi_clear_fast_connect */ + 122, /* field[122] = resp_wifi_connect */ + 133, /* field[133] = resp_wifi_deauth_sta */ + 119, /* field[119] = resp_wifi_deinit */ + 123, /* field[123] = resp_wifi_disconnect */ + 158, /* field[158] = resp_wifi_get_band */ + 160, /* field[160] = resp_wifi_get_bandmode */ + 138, /* field[138] = resp_wifi_get_bandwidth */ + 156, /* field[156] = resp_wifi_get_bandwidths */ + 140, /* field[140] = resp_wifi_get_channel */ + 125, /* field[125] = resp_wifi_get_config */ + 142, /* field[142] = resp_wifi_get_country */ + 149, /* field[149] = resp_wifi_get_country_code */ + 147, /* field[147] = resp_wifi_get_inactive_time */ + 136, /* field[136] = resp_wifi_get_protocol */ + 154, /* field[154] = resp_wifi_get_protocols */ + 111, /* field[111] = resp_wifi_get_ps */ + 118, /* field[118] = resp_wifi_init */ + 131, /* field[131] = resp_wifi_restore */ + 128, /* field[128] = resp_wifi_scan_get_ap_num */ + 162, /* field[162] = resp_wifi_scan_get_ap_record */ + 129, /* field[129] = resp_wifi_scan_get_ap_records */ + 126, /* field[126] = resp_wifi_scan_start */ + 127, /* field[127] = resp_wifi_scan_stop */ + 157, /* field[157] = resp_wifi_set_band */ + 159, /* field[159] = resp_wifi_set_bandmode */ + 137, /* field[137] = resp_wifi_set_bandwidth */ + 155, /* field[155] = resp_wifi_set_bandwidths */ + 139, /* field[139] = resp_wifi_set_channel */ + 124, /* field[124] = resp_wifi_set_config */ + 141, /* field[141] = resp_wifi_set_country */ + 148, /* field[148] = resp_wifi_set_country_code */ + 146, /* field[146] = resp_wifi_set_inactive_time */ + 192, /* field[192] = resp_wifi_set_okc_support */ + 135, /* field[135] = resp_wifi_set_protocol */ + 153, /* field[153] = resp_wifi_set_protocols */ + 110, /* field[110] = resp_wifi_set_ps */ + 145, /* field[145] = resp_wifi_set_storage */ + 173, /* field[173] = resp_wifi_sta_enterprise_disable */ + 172, /* field[172] = resp_wifi_sta_enterprise_enable */ + 150, /* field[150] = resp_wifi_sta_get_aid */ + 134, /* field[134] = resp_wifi_sta_get_ap_info */ + 151, /* field[151] = resp_wifi_sta_get_negotiated_phymode */ + 152, /* field[152] = resp_wifi_sta_get_rssi */ + 169, /* field[169] = resp_wifi_sta_itwt_get_flow_id_status */ + 170, /* field[170] = resp_wifi_sta_itwt_send_probe_req */ + 171, /* field[171] = resp_wifi_sta_itwt_set_target_wake_time_offset */ + 166, /* field[166] = resp_wifi_sta_itwt_setup */ + 168, /* field[168] = resp_wifi_sta_itwt_suspend */ + 167, /* field[167] = resp_wifi_sta_itwt_teardown */ + 165, /* field[165] = resp_wifi_sta_twt_config */ + 120, /* field[120] = resp_wifi_start */ + 121, /* field[121] = resp_wifi_stop */ + 2, /* field[2] = uid */ +}; +static const ProtobufCIntRange rpc__number_ranges[18 + 1] = +{ + { 1, 0 }, + { 257, 3 }, + { 270, 12 }, + { 297, 37 }, + { 311, 45 }, + { 325, 48 }, + { 334, 50 }, + { 338, 52 }, + { 341, 54 }, + { 513, 101 }, + { 526, 110 }, + { 553, 135 }, + { 567, 143 }, + { 581, 146 }, + { 590, 148 }, + { 594, 150 }, + { 597, 152 }, + { 769, 199 }, + { 0, 218 } +}; +const ProtobufCMessageDescriptor rpc__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "Rpc", + "Rpc", + "Rpc", + "", + sizeof(Rpc), + 218, + rpc__field_descriptors, + rpc__field_indices_by_name, + 18, rpc__number_ranges, + (ProtobufCMessageInit) rpc__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue rpc__wifi_bw__enum_values_by_number[3] = +{ + { "BW_Invalid", "RPC__WIFI_BW__BW_Invalid", 0 }, + { "HT20", "RPC__WIFI_BW__HT20", 1 }, + { "HT40", "RPC__WIFI_BW__HT40", 2 }, +}; +static const ProtobufCIntRange rpc__wifi_bw__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex rpc__wifi_bw__enum_values_by_name[3] = +{ + { "BW_Invalid", 0 }, + { "HT20", 1 }, + { "HT40", 2 }, +}; +const ProtobufCEnumDescriptor rpc__wifi_bw__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_WifiBw", + "Rpc_WifiBw", + "RpcWifiBw", + "", + 3, + rpc__wifi_bw__enum_values_by_number, + 3, + rpc__wifi_bw__enum_values_by_name, + 1, + rpc__wifi_bw__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc__wifi_power_save__enum_values_by_number[3] = +{ + { "PS_Invalid", "RPC__WIFI_POWER_SAVE__PS_Invalid", 0 }, + { "MIN_MODEM", "RPC__WIFI_POWER_SAVE__MIN_MODEM", 1 }, + { "MAX_MODEM", "RPC__WIFI_POWER_SAVE__MAX_MODEM", 2 }, +}; +static const ProtobufCIntRange rpc__wifi_power_save__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex rpc__wifi_power_save__enum_values_by_name[3] = +{ + { "MAX_MODEM", 2 }, + { "MIN_MODEM", 1 }, + { "PS_Invalid", 0 }, +}; +const ProtobufCEnumDescriptor rpc__wifi_power_save__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_WifiPowerSave", + "Rpc_WifiPowerSave", + "RpcWifiPowerSave", + "", + 3, + rpc__wifi_power_save__enum_values_by_number, + 3, + rpc__wifi_power_save__enum_values_by_name, + 1, + rpc__wifi_power_save__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc__wifi_sec_prot__enum_values_by_number[8] = +{ + { "Open", "RPC__WIFI_SEC_PROT__Open", 0 }, + { "WEP", "RPC__WIFI_SEC_PROT__WEP", 1 }, + { "WPA_PSK", "RPC__WIFI_SEC_PROT__WPA_PSK", 2 }, + { "WPA2_PSK", "RPC__WIFI_SEC_PROT__WPA2_PSK", 3 }, + { "WPA_WPA2_PSK", "RPC__WIFI_SEC_PROT__WPA_WPA2_PSK", 4 }, + { "WPA2_ENTERPRISE", "RPC__WIFI_SEC_PROT__WPA2_ENTERPRISE", 5 }, + { "WPA3_PSK", "RPC__WIFI_SEC_PROT__WPA3_PSK", 6 }, + { "WPA2_WPA3_PSK", "RPC__WIFI_SEC_PROT__WPA2_WPA3_PSK", 7 }, +}; +static const ProtobufCIntRange rpc__wifi_sec_prot__value_ranges[] = { +{0, 0},{0, 8} +}; +static const ProtobufCEnumValueIndex rpc__wifi_sec_prot__enum_values_by_name[8] = +{ + { "Open", 0 }, + { "WEP", 1 }, + { "WPA2_ENTERPRISE", 5 }, + { "WPA2_PSK", 3 }, + { "WPA2_WPA3_PSK", 7 }, + { "WPA3_PSK", 6 }, + { "WPA_PSK", 2 }, + { "WPA_WPA2_PSK", 4 }, +}; +const ProtobufCEnumDescriptor rpc__wifi_sec_prot__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_WifiSecProt", + "Rpc_WifiSecProt", + "RpcWifiSecProt", + "", + 8, + rpc__wifi_sec_prot__enum_values_by_number, + 8, + rpc__wifi_sec_prot__enum_values_by_name, + 1, + rpc__wifi_sec_prot__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc__status__enum_values_by_number[6] = +{ + { "Connected", "RPC__STATUS__Connected", 0 }, + { "Not_Connected", "RPC__STATUS__Not_Connected", 1 }, + { "No_AP_Found", "RPC__STATUS__No_AP_Found", 2 }, + { "Connection_Fail", "RPC__STATUS__Connection_Fail", 3 }, + { "Invalid_Argument", "RPC__STATUS__Invalid_Argument", 4 }, + { "Out_Of_Range", "RPC__STATUS__Out_Of_Range", 5 }, +}; +static const ProtobufCIntRange rpc__status__value_ranges[] = { +{0, 0},{0, 6} +}; +static const ProtobufCEnumValueIndex rpc__status__enum_values_by_name[6] = +{ + { "Connected", 0 }, + { "Connection_Fail", 3 }, + { "Invalid_Argument", 4 }, + { "No_AP_Found", 2 }, + { "Not_Connected", 1 }, + { "Out_Of_Range", 5 }, +}; +const ProtobufCEnumDescriptor rpc__status__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "Rpc_Status", + "Rpc_Status", + "RpcStatus", + "", + 6, + rpc__status__enum_values_by_number, + 6, + rpc__status__enum_values_by_name, + 1, + rpc__status__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_type__enum_values_by_number[5] = +{ + { "MsgType_Invalid", "RPC_TYPE__MsgType_Invalid", 0 }, + { "Req", "RPC_TYPE__Req", 1 }, + { "Resp", "RPC_TYPE__Resp", 2 }, + { "Event", "RPC_TYPE__Event", 3 }, + { "MsgType_Max", "RPC_TYPE__MsgType_Max", 4 }, +}; +static const ProtobufCIntRange rpc_type__value_ranges[] = { +{0, 0},{0, 5} +}; +static const ProtobufCEnumValueIndex rpc_type__enum_values_by_name[5] = +{ + { "Event", 3 }, + { "MsgType_Invalid", 0 }, + { "MsgType_Max", 4 }, + { "Req", 1 }, + { "Resp", 2 }, +}; +const ProtobufCEnumDescriptor rpc_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcType", + "RpcType", + "RpcType", + "", + 5, + rpc_type__enum_values_by_number, + 5, + rpc_type__enum_values_by_name, + 1, + rpc_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_feature__enum_values_by_number[2] = +{ + { "Feature_None", "RPC_FEATURE__Feature_None", 0 }, + { "Feature_Bluetooth", "RPC_FEATURE__Feature_Bluetooth", 1 }, +}; +static const ProtobufCIntRange rpc_feature__value_ranges[] = { +{0, 0},{0, 2} +}; +static const ProtobufCEnumValueIndex rpc_feature__enum_values_by_name[2] = +{ + { "Feature_Bluetooth", 1 }, + { "Feature_None", 0 }, +}; +const ProtobufCEnumDescriptor rpc_feature__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcFeature", + "RpcFeature", + "RpcFeature", + "", + 2, + rpc_feature__enum_values_by_number, + 2, + rpc_feature__enum_values_by_name, + 1, + rpc_feature__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_feature_command__enum_values_by_number[5] = +{ + { "Feature_Command_None", "RPC_FEATURE_COMMAND__Feature_Command_None", 0 }, + { "Feature_Command_BT_Init", "RPC_FEATURE_COMMAND__Feature_Command_BT_Init", 1 }, + { "Feature_Command_BT_Deinit", "RPC_FEATURE_COMMAND__Feature_Command_BT_Deinit", 2 }, + { "Feature_Command_BT_Enable", "RPC_FEATURE_COMMAND__Feature_Command_BT_Enable", 3 }, + { "Feature_Command_BT_Disable", "RPC_FEATURE_COMMAND__Feature_Command_BT_Disable", 4 }, +}; +static const ProtobufCIntRange rpc_feature_command__value_ranges[] = { +{0, 0},{0, 5} +}; +static const ProtobufCEnumValueIndex rpc_feature_command__enum_values_by_name[5] = +{ + { "Feature_Command_BT_Deinit", 2 }, + { "Feature_Command_BT_Disable", 4 }, + { "Feature_Command_BT_Enable", 3 }, + { "Feature_Command_BT_Init", 1 }, + { "Feature_Command_None", 0 }, +}; +const ProtobufCEnumDescriptor rpc_feature_command__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcFeatureCommand", + "RpcFeatureCommand", + "RpcFeatureCommand", + "", + 5, + rpc_feature_command__enum_values_by_number, + 5, + rpc_feature_command__enum_values_by_name, + 1, + rpc_feature_command__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_feature_option__enum_values_by_number[2] = +{ + { "Feature_Option_None", "RPC_FEATURE_OPTION__Feature_Option_None", 0 }, + { "Feature_Option_BT_Deinit_Release_Memory", "RPC_FEATURE_OPTION__Feature_Option_BT_Deinit_Release_Memory", 1 }, +}; +static const ProtobufCIntRange rpc_feature_option__value_ranges[] = { +{0, 0},{0, 2} +}; +static const ProtobufCEnumValueIndex rpc_feature_option__enum_values_by_name[2] = +{ + { "Feature_Option_BT_Deinit_Release_Memory", 1 }, + { "Feature_Option_None", 0 }, +}; +const ProtobufCEnumDescriptor rpc_feature_option__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcFeatureOption", + "RpcFeatureOption", + "RpcFeatureOption", + "", + 2, + rpc_feature_option__enum_values_by_number, + 2, + rpc_feature_option__enum_values_by_name, + 1, + rpc_feature_option__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue rpc_id__enum_values_by_number[276] = +{ + { "MsgId_Invalid", "RPC_ID__MsgId_Invalid", 0 }, + { "Req_Base", "RPC_ID__Req_Base", 256 }, + { "Req_GetMACAddress", "RPC_ID__Req_GetMACAddress", 257 }, + { "Req_SetMacAddress", "RPC_ID__Req_SetMacAddress", 258 }, + { "Req_GetWifiMode", "RPC_ID__Req_GetWifiMode", 259 }, + { "Req_SetWifiMode", "RPC_ID__Req_SetWifiMode", 260 }, + { "Req_SuppDppInit", "RPC_ID__Req_SuppDppInit", 261 }, + { "Req_SuppDppDeinit", "RPC_ID__Req_SuppDppDeinit", 262 }, + { "Req_SuppDppBootstrapGen", "RPC_ID__Req_SuppDppBootstrapGen", 263 }, + { "Req_SuppDppStartListen", "RPC_ID__Req_SuppDppStartListen", 264 }, + { "Req_SuppDppStopListen", "RPC_ID__Req_SuppDppStopListen", 265 }, + { "Req_WifiSetPs", "RPC_ID__Req_WifiSetPs", 270 }, + { "Req_WifiGetPs", "RPC_ID__Req_WifiGetPs", 271 }, + { "Req_OTABegin", "RPC_ID__Req_OTABegin", 272 }, + { "Req_OTAWrite", "RPC_ID__Req_OTAWrite", 273 }, + { "Req_OTAEnd", "RPC_ID__Req_OTAEnd", 274 }, + { "Req_WifiSetMaxTxPower", "RPC_ID__Req_WifiSetMaxTxPower", 275 }, + { "Req_WifiGetMaxTxPower", "RPC_ID__Req_WifiGetMaxTxPower", 276 }, + { "Req_ConfigHeartbeat", "RPC_ID__Req_ConfigHeartbeat", 277 }, + { "Req_WifiInit", "RPC_ID__Req_WifiInit", 278 }, + { "Req_WifiDeinit", "RPC_ID__Req_WifiDeinit", 279 }, + { "Req_WifiStart", "RPC_ID__Req_WifiStart", 280 }, + { "Req_WifiStop", "RPC_ID__Req_WifiStop", 281 }, + { "Req_WifiConnect", "RPC_ID__Req_WifiConnect", 282 }, + { "Req_WifiDisconnect", "RPC_ID__Req_WifiDisconnect", 283 }, + { "Req_WifiSetConfig", "RPC_ID__Req_WifiSetConfig", 284 }, + { "Req_WifiGetConfig", "RPC_ID__Req_WifiGetConfig", 285 }, + { "Req_WifiScanStart", "RPC_ID__Req_WifiScanStart", 286 }, + { "Req_WifiScanStop", "RPC_ID__Req_WifiScanStop", 287 }, + { "Req_WifiScanGetApNum", "RPC_ID__Req_WifiScanGetApNum", 288 }, + { "Req_WifiScanGetApRecords", "RPC_ID__Req_WifiScanGetApRecords", 289 }, + { "Req_WifiClearApList", "RPC_ID__Req_WifiClearApList", 290 }, + { "Req_WifiRestore", "RPC_ID__Req_WifiRestore", 291 }, + { "Req_WifiClearFastConnect", "RPC_ID__Req_WifiClearFastConnect", 292 }, + { "Req_WifiDeauthSta", "RPC_ID__Req_WifiDeauthSta", 293 }, + { "Req_WifiStaGetApInfo", "RPC_ID__Req_WifiStaGetApInfo", 294 }, + { "Req_WifiSetProtocol", "RPC_ID__Req_WifiSetProtocol", 297 }, + { "Req_WifiGetProtocol", "RPC_ID__Req_WifiGetProtocol", 298 }, + { "Req_WifiSetBandwidth", "RPC_ID__Req_WifiSetBandwidth", 299 }, + { "Req_WifiGetBandwidth", "RPC_ID__Req_WifiGetBandwidth", 300 }, + { "Req_WifiSetChannel", "RPC_ID__Req_WifiSetChannel", 301 }, + { "Req_WifiGetChannel", "RPC_ID__Req_WifiGetChannel", 302 }, + { "Req_WifiSetCountry", "RPC_ID__Req_WifiSetCountry", 303 }, + { "Req_WifiGetCountry", "RPC_ID__Req_WifiGetCountry", 304 }, + { "Req_WifiSetPromiscuous", "RPC_ID__Req_WifiSetPromiscuous", 305 }, + { "Req_WifiGetPromiscuous", "RPC_ID__Req_WifiGetPromiscuous", 306 }, + { "Req_WifiSetPromiscuousFilter", "RPC_ID__Req_WifiSetPromiscuousFilter", 307 }, + { "Req_WifiGetPromiscuousFilter", "RPC_ID__Req_WifiGetPromiscuousFilter", 308 }, + { "Req_WifiSetPromiscuousCtrlFilter", "RPC_ID__Req_WifiSetPromiscuousCtrlFilter", 309 }, + { "Req_WifiGetPromiscuousCtrlFilter", "RPC_ID__Req_WifiGetPromiscuousCtrlFilter", 310 }, + { "Req_WifiApGetStaList", "RPC_ID__Req_WifiApGetStaList", 311 }, + { "Req_WifiApGetStaAid", "RPC_ID__Req_WifiApGetStaAid", 312 }, + { "Req_WifiSetStorage", "RPC_ID__Req_WifiSetStorage", 313 }, + { "Req_WifiSetVendorIe", "RPC_ID__Req_WifiSetVendorIe", 314 }, + { "Req_WifiSetEventMask", "RPC_ID__Req_WifiSetEventMask", 315 }, + { "Req_WifiGetEventMask", "RPC_ID__Req_WifiGetEventMask", 316 }, + { "Req_Wifi80211Tx", "RPC_ID__Req_Wifi80211Tx", 317 }, + { "Req_WifiSetCsiConfig", "RPC_ID__Req_WifiSetCsiConfig", 318 }, + { "Req_WifiSetCsi", "RPC_ID__Req_WifiSetCsi", 319 }, + { "Req_WifiSetAntGpio", "RPC_ID__Req_WifiSetAntGpio", 320 }, + { "Req_WifiGetAntGpio", "RPC_ID__Req_WifiGetAntGpio", 321 }, + { "Req_WifiSetAnt", "RPC_ID__Req_WifiSetAnt", 322 }, + { "Req_WifiGetAnt", "RPC_ID__Req_WifiGetAnt", 323 }, + { "Req_WifiGetTsfTime", "RPC_ID__Req_WifiGetTsfTime", 324 }, + { "Req_WifiSetInactiveTime", "RPC_ID__Req_WifiSetInactiveTime", 325 }, + { "Req_WifiGetInactiveTime", "RPC_ID__Req_WifiGetInactiveTime", 326 }, + { "Req_WifiStatisDump", "RPC_ID__Req_WifiStatisDump", 327 }, + { "Req_WifiSetRssiThreshold", "RPC_ID__Req_WifiSetRssiThreshold", 328 }, + { "Req_WifiFtmInitiateSession", "RPC_ID__Req_WifiFtmInitiateSession", 329 }, + { "Req_WifiFtmEndSession", "RPC_ID__Req_WifiFtmEndSession", 330 }, + { "Req_WifiFtmRespSetOffset", "RPC_ID__Req_WifiFtmRespSetOffset", 331 }, + { "Req_WifiConfig11bRate", "RPC_ID__Req_WifiConfig11bRate", 332 }, + { "Req_WifiConnectionlessModuleSetWakeInterval", "RPC_ID__Req_WifiConnectionlessModuleSetWakeInterval", 333 }, + { "Req_WifiSetCountryCode", "RPC_ID__Req_WifiSetCountryCode", 334 }, + { "Req_WifiGetCountryCode", "RPC_ID__Req_WifiGetCountryCode", 335 }, + { "Req_WifiConfig80211TxRate", "RPC_ID__Req_WifiConfig80211TxRate", 336 }, + { "Req_WifiDisablePmfConfig", "RPC_ID__Req_WifiDisablePmfConfig", 337 }, + { "Req_WifiStaGetAid", "RPC_ID__Req_WifiStaGetAid", 338 }, + { "Req_WifiStaGetNegotiatedPhymode", "RPC_ID__Req_WifiStaGetNegotiatedPhymode", 339 }, + { "Req_WifiSetDynamicCs", "RPC_ID__Req_WifiSetDynamicCs", 340 }, + { "Req_WifiStaGetRssi", "RPC_ID__Req_WifiStaGetRssi", 341 }, + { "Req_WifiSetProtocols", "RPC_ID__Req_WifiSetProtocols", 342 }, + { "Req_WifiGetProtocols", "RPC_ID__Req_WifiGetProtocols", 343 }, + { "Req_WifiSetBandwidths", "RPC_ID__Req_WifiSetBandwidths", 344 }, + { "Req_WifiGetBandwidths", "RPC_ID__Req_WifiGetBandwidths", 345 }, + { "Req_WifiSetBand", "RPC_ID__Req_WifiSetBand", 346 }, + { "Req_WifiGetBand", "RPC_ID__Req_WifiGetBand", 347 }, + { "Req_WifiSetBandMode", "RPC_ID__Req_WifiSetBandMode", 348 }, + { "Req_WifiGetBandMode", "RPC_ID__Req_WifiGetBandMode", 349 }, + { "Req_GetCoprocessorFwVersion", "RPC_ID__Req_GetCoprocessorFwVersion", 350 }, + { "Req_WifiScanGetApRecord", "RPC_ID__Req_WifiScanGetApRecord", 351 }, + { "Req_SetDhcpDnsStatus", "RPC_ID__Req_SetDhcpDnsStatus", 352 }, + { "Req_GetDhcpDnsStatus", "RPC_ID__Req_GetDhcpDnsStatus", 353 }, + { "Req_WifiStaTwtConfig", "RPC_ID__Req_WifiStaTwtConfig", 354 }, + { "Req_WifiStaItwtSetup", "RPC_ID__Req_WifiStaItwtSetup", 355 }, + { "Req_WifiStaItwtTeardown", "RPC_ID__Req_WifiStaItwtTeardown", 356 }, + { "Req_WifiStaItwtSuspend", "RPC_ID__Req_WifiStaItwtSuspend", 357 }, + { "Req_WifiStaItwtGetFlowIdStatus", "RPC_ID__Req_WifiStaItwtGetFlowIdStatus", 358 }, + { "Req_WifiStaItwtSendProbeReq", "RPC_ID__Req_WifiStaItwtSendProbeReq", 359 }, + { "Req_WifiStaItwtSetTargetWakeTimeOffset", "RPC_ID__Req_WifiStaItwtSetTargetWakeTimeOffset", 360 }, + { "Req_WifiStaEnterpriseEnable", "RPC_ID__Req_WifiStaEnterpriseEnable", 361 }, + { "Req_WifiStaEnterpriseDisable", "RPC_ID__Req_WifiStaEnterpriseDisable", 362 }, + { "Req_EapSetIdentity", "RPC_ID__Req_EapSetIdentity", 363 }, + { "Req_EapClearIdentity", "RPC_ID__Req_EapClearIdentity", 364 }, + { "Req_EapSetUsername", "RPC_ID__Req_EapSetUsername", 365 }, + { "Req_EapClearUsername", "RPC_ID__Req_EapClearUsername", 366 }, + { "Req_EapSetPassword", "RPC_ID__Req_EapSetPassword", 367 }, + { "Req_EapClearPassword", "RPC_ID__Req_EapClearPassword", 368 }, + { "Req_EapSetNewPassword", "RPC_ID__Req_EapSetNewPassword", 369 }, + { "Req_EapClearNewPassword", "RPC_ID__Req_EapClearNewPassword", 370 }, + { "Req_EapSetCaCert", "RPC_ID__Req_EapSetCaCert", 371 }, + { "Req_EapClearCaCert", "RPC_ID__Req_EapClearCaCert", 372 }, + { "Req_EapSetCertificateAndKey", "RPC_ID__Req_EapSetCertificateAndKey", 373 }, + { "Req_EapClearCertificateAndKey", "RPC_ID__Req_EapClearCertificateAndKey", 374 }, + { "Req_EapGetDisableTimeCheck", "RPC_ID__Req_EapGetDisableTimeCheck", 375 }, + { "Req_EapSetTtlsPhase2Method", "RPC_ID__Req_EapSetTtlsPhase2Method", 376 }, + { "Req_EapSetSuitebCertification", "RPC_ID__Req_EapSetSuitebCertification", 377 }, + { "Req_EapSetPacFile", "RPC_ID__Req_EapSetPacFile", 378 }, + { "Req_EapSetFastParams", "RPC_ID__Req_EapSetFastParams", 379 }, + { "Req_EapUseDefaultCertBundle", "RPC_ID__Req_EapUseDefaultCertBundle", 380 }, + { "Req_WifiSetOkcSupport", "RPC_ID__Req_WifiSetOkcSupport", 381 }, + { "Req_EapSetDomainName", "RPC_ID__Req_EapSetDomainName", 382 }, + { "Req_EapSetDisableTimeCheck", "RPC_ID__Req_EapSetDisableTimeCheck", 383 }, + { "Req_EapSetEapMethods", "RPC_ID__Req_EapSetEapMethods", 384 }, + { "Req_IfaceMacAddrSetGet", "RPC_ID__Req_IfaceMacAddrSetGet", 385 }, + { "Req_IfaceMacAddrLenGet", "RPC_ID__Req_IfaceMacAddrLenGet", 386 }, + { "Req_FeatureControl", "RPC_ID__Req_FeatureControl", 387 }, + { "Req_Max", "RPC_ID__Req_Max", 388 }, + { "Resp_Base", "RPC_ID__Resp_Base", 512 }, + { "Resp_GetMACAddress", "RPC_ID__Resp_GetMACAddress", 513 }, + { "Resp_SetMacAddress", "RPC_ID__Resp_SetMacAddress", 514 }, + { "Resp_GetWifiMode", "RPC_ID__Resp_GetWifiMode", 515 }, + { "Resp_SetWifiMode", "RPC_ID__Resp_SetWifiMode", 516 }, + { "Resp_SuppDppInit", "RPC_ID__Resp_SuppDppInit", 517 }, + { "Resp_SuppDppDeinit", "RPC_ID__Resp_SuppDppDeinit", 518 }, + { "Resp_SuppDppBootstrapGen", "RPC_ID__Resp_SuppDppBootstrapGen", 519 }, + { "Resp_SuppDppStartListen", "RPC_ID__Resp_SuppDppStartListen", 520 }, + { "Resp_SuppDppStopListen", "RPC_ID__Resp_SuppDppStopListen", 521 }, + { "Resp_WifiSetPs", "RPC_ID__Resp_WifiSetPs", 526 }, + { "Resp_WifiGetPs", "RPC_ID__Resp_WifiGetPs", 527 }, + { "Resp_OTABegin", "RPC_ID__Resp_OTABegin", 528 }, + { "Resp_OTAWrite", "RPC_ID__Resp_OTAWrite", 529 }, + { "Resp_OTAEnd", "RPC_ID__Resp_OTAEnd", 530 }, + { "Resp_WifiSetMaxTxPower", "RPC_ID__Resp_WifiSetMaxTxPower", 531 }, + { "Resp_WifiGetMaxTxPower", "RPC_ID__Resp_WifiGetMaxTxPower", 532 }, + { "Resp_ConfigHeartbeat", "RPC_ID__Resp_ConfigHeartbeat", 533 }, + { "Resp_WifiInit", "RPC_ID__Resp_WifiInit", 534 }, + { "Resp_WifiDeinit", "RPC_ID__Resp_WifiDeinit", 535 }, + { "Resp_WifiStart", "RPC_ID__Resp_WifiStart", 536 }, + { "Resp_WifiStop", "RPC_ID__Resp_WifiStop", 537 }, + { "Resp_WifiConnect", "RPC_ID__Resp_WifiConnect", 538 }, + { "Resp_WifiDisconnect", "RPC_ID__Resp_WifiDisconnect", 539 }, + { "Resp_WifiSetConfig", "RPC_ID__Resp_WifiSetConfig", 540 }, + { "Resp_WifiGetConfig", "RPC_ID__Resp_WifiGetConfig", 541 }, + { "Resp_WifiScanStart", "RPC_ID__Resp_WifiScanStart", 542 }, + { "Resp_WifiScanStop", "RPC_ID__Resp_WifiScanStop", 543 }, + { "Resp_WifiScanGetApNum", "RPC_ID__Resp_WifiScanGetApNum", 544 }, + { "Resp_WifiScanGetApRecords", "RPC_ID__Resp_WifiScanGetApRecords", 545 }, + { "Resp_WifiClearApList", "RPC_ID__Resp_WifiClearApList", 546 }, + { "Resp_WifiRestore", "RPC_ID__Resp_WifiRestore", 547 }, + { "Resp_WifiClearFastConnect", "RPC_ID__Resp_WifiClearFastConnect", 548 }, + { "Resp_WifiDeauthSta", "RPC_ID__Resp_WifiDeauthSta", 549 }, + { "Resp_WifiStaGetApInfo", "RPC_ID__Resp_WifiStaGetApInfo", 550 }, + { "Resp_WifiSetProtocol", "RPC_ID__Resp_WifiSetProtocol", 553 }, + { "Resp_WifiGetProtocol", "RPC_ID__Resp_WifiGetProtocol", 554 }, + { "Resp_WifiSetBandwidth", "RPC_ID__Resp_WifiSetBandwidth", 555 }, + { "Resp_WifiGetBandwidth", "RPC_ID__Resp_WifiGetBandwidth", 556 }, + { "Resp_WifiSetChannel", "RPC_ID__Resp_WifiSetChannel", 557 }, + { "Resp_WifiGetChannel", "RPC_ID__Resp_WifiGetChannel", 558 }, + { "Resp_WifiSetCountry", "RPC_ID__Resp_WifiSetCountry", 559 }, + { "Resp_WifiGetCountry", "RPC_ID__Resp_WifiGetCountry", 560 }, + { "Resp_WifiSetPromiscuous", "RPC_ID__Resp_WifiSetPromiscuous", 561 }, + { "Resp_WifiGetPromiscuous", "RPC_ID__Resp_WifiGetPromiscuous", 562 }, + { "Resp_WifiSetPromiscuousFilter", "RPC_ID__Resp_WifiSetPromiscuousFilter", 563 }, + { "Resp_WifiGetPromiscuousFilter", "RPC_ID__Resp_WifiGetPromiscuousFilter", 564 }, + { "Resp_WifiSetPromiscuousCtrlFilter", "RPC_ID__Resp_WifiSetPromiscuousCtrlFilter", 565 }, + { "Resp_WifiGetPromiscuousCtrlFilter", "RPC_ID__Resp_WifiGetPromiscuousCtrlFilter", 566 }, + { "Resp_WifiApGetStaList", "RPC_ID__Resp_WifiApGetStaList", 567 }, + { "Resp_WifiApGetStaAid", "RPC_ID__Resp_WifiApGetStaAid", 568 }, + { "Resp_WifiSetStorage", "RPC_ID__Resp_WifiSetStorage", 569 }, + { "Resp_WifiSetVendorIe", "RPC_ID__Resp_WifiSetVendorIe", 570 }, + { "Resp_WifiSetEventMask", "RPC_ID__Resp_WifiSetEventMask", 571 }, + { "Resp_WifiGetEventMask", "RPC_ID__Resp_WifiGetEventMask", 572 }, + { "Resp_Wifi80211Tx", "RPC_ID__Resp_Wifi80211Tx", 573 }, + { "Resp_WifiSetCsiConfig", "RPC_ID__Resp_WifiSetCsiConfig", 574 }, + { "Resp_WifiSetCsi", "RPC_ID__Resp_WifiSetCsi", 575 }, + { "Resp_WifiSetAntGpio", "RPC_ID__Resp_WifiSetAntGpio", 576 }, + { "Resp_WifiGetAntGpio", "RPC_ID__Resp_WifiGetAntGpio", 577 }, + { "Resp_WifiSetAnt", "RPC_ID__Resp_WifiSetAnt", 578 }, + { "Resp_WifiGetAnt", "RPC_ID__Resp_WifiGetAnt", 579 }, + { "Resp_WifiGetTsfTime", "RPC_ID__Resp_WifiGetTsfTime", 580 }, + { "Resp_WifiSetInactiveTime", "RPC_ID__Resp_WifiSetInactiveTime", 581 }, + { "Resp_WifiGetInactiveTime", "RPC_ID__Resp_WifiGetInactiveTime", 582 }, + { "Resp_WifiStatisDump", "RPC_ID__Resp_WifiStatisDump", 583 }, + { "Resp_WifiSetRssiThreshold", "RPC_ID__Resp_WifiSetRssiThreshold", 584 }, + { "Resp_WifiFtmInitiateSession", "RPC_ID__Resp_WifiFtmInitiateSession", 585 }, + { "Resp_WifiFtmEndSession", "RPC_ID__Resp_WifiFtmEndSession", 586 }, + { "Resp_WifiFtmRespSetOffset", "RPC_ID__Resp_WifiFtmRespSetOffset", 587 }, + { "Resp_WifiConfig11bRate", "RPC_ID__Resp_WifiConfig11bRate", 588 }, + { "Resp_WifiConnectionlessModuleSetWakeInterval", "RPC_ID__Resp_WifiConnectionlessModuleSetWakeInterval", 589 }, + { "Resp_WifiSetCountryCode", "RPC_ID__Resp_WifiSetCountryCode", 590 }, + { "Resp_WifiGetCountryCode", "RPC_ID__Resp_WifiGetCountryCode", 591 }, + { "Resp_WifiConfig80211TxRate", "RPC_ID__Resp_WifiConfig80211TxRate", 592 }, + { "Resp_WifiDisablePmfConfig", "RPC_ID__Resp_WifiDisablePmfConfig", 593 }, + { "Resp_WifiStaGetAid", "RPC_ID__Resp_WifiStaGetAid", 594 }, + { "Resp_WifiStaGetNegotiatedPhymode", "RPC_ID__Resp_WifiStaGetNegotiatedPhymode", 595 }, + { "Resp_WifiSetDynamicCs", "RPC_ID__Resp_WifiSetDynamicCs", 596 }, + { "Resp_WifiStaGetRssi", "RPC_ID__Resp_WifiStaGetRssi", 597 }, + { "Resp_WifiSetProtocols", "RPC_ID__Resp_WifiSetProtocols", 598 }, + { "Resp_WifiGetProtocols", "RPC_ID__Resp_WifiGetProtocols", 599 }, + { "Resp_WifiSetBandwidths", "RPC_ID__Resp_WifiSetBandwidths", 600 }, + { "Resp_WifiGetBandwidths", "RPC_ID__Resp_WifiGetBandwidths", 601 }, + { "Resp_WifiSetBand", "RPC_ID__Resp_WifiSetBand", 602 }, + { "Resp_WifiGetBand", "RPC_ID__Resp_WifiGetBand", 603 }, + { "Resp_WifiSetBandMode", "RPC_ID__Resp_WifiSetBandMode", 604 }, + { "Resp_WifiGetBandMode", "RPC_ID__Resp_WifiGetBandMode", 605 }, + { "Resp_GetCoprocessorFwVersion", "RPC_ID__Resp_GetCoprocessorFwVersion", 606 }, + { "Resp_WifiScanGetApRecord", "RPC_ID__Resp_WifiScanGetApRecord", 607 }, + { "Resp_SetDhcpDnsStatus", "RPC_ID__Resp_SetDhcpDnsStatus", 608 }, + { "Resp_GetDhcpDnsStatus", "RPC_ID__Resp_GetDhcpDnsStatus", 609 }, + { "Resp_WifiStaTwtConfig", "RPC_ID__Resp_WifiStaTwtConfig", 610 }, + { "Resp_WifiStaItwtSetup", "RPC_ID__Resp_WifiStaItwtSetup", 611 }, + { "Resp_WifiStaItwtTeardown", "RPC_ID__Resp_WifiStaItwtTeardown", 612 }, + { "Resp_WifiStaItwtSuspend", "RPC_ID__Resp_WifiStaItwtSuspend", 613 }, + { "Resp_WifiStaItwtGetFlowIdStatus", "RPC_ID__Resp_WifiStaItwtGetFlowIdStatus", 614 }, + { "Resp_WifiStaItwtSendProbeReq", "RPC_ID__Resp_WifiStaItwtSendProbeReq", 615 }, + { "Resp_WifiStaItwtSetTargetWakeTimeOffset", "RPC_ID__Resp_WifiStaItwtSetTargetWakeTimeOffset", 616 }, + { "Resp_WifiStaEnterpriseEnable", "RPC_ID__Resp_WifiStaEnterpriseEnable", 617 }, + { "Resp_WifiStaEnterpriseDisable", "RPC_ID__Resp_WifiStaEnterpriseDisable", 618 }, + { "Resp_EapSetIdentity", "RPC_ID__Resp_EapSetIdentity", 619 }, + { "Resp_EapClearIdentity", "RPC_ID__Resp_EapClearIdentity", 620 }, + { "Resp_EapSetUsername", "RPC_ID__Resp_EapSetUsername", 621 }, + { "Resp_EapClearUsername", "RPC_ID__Resp_EapClearUsername", 622 }, + { "Resp_EapSetPassword", "RPC_ID__Resp_EapSetPassword", 623 }, + { "Resp_EapClearPassword", "RPC_ID__Resp_EapClearPassword", 624 }, + { "Resp_EapSetNewPassword", "RPC_ID__Resp_EapSetNewPassword", 625 }, + { "Resp_EapClearNewPassword", "RPC_ID__Resp_EapClearNewPassword", 626 }, + { "Resp_EapSetCaCert", "RPC_ID__Resp_EapSetCaCert", 627 }, + { "Resp_EapClearCaCert", "RPC_ID__Resp_EapClearCaCert", 628 }, + { "Resp_EapSetCertificateAndKey", "RPC_ID__Resp_EapSetCertificateAndKey", 629 }, + { "Resp_EapClearCertificateAndKey", "RPC_ID__Resp_EapClearCertificateAndKey", 630 }, + { "Resp_EapGetDisableTimeCheck", "RPC_ID__Resp_EapGetDisableTimeCheck", 631 }, + { "Resp_EapSetTtlsPhase2Method", "RPC_ID__Resp_EapSetTtlsPhase2Method", 632 }, + { "Resp_EapSetSuitebCertification", "RPC_ID__Resp_EapSetSuitebCertification", 633 }, + { "Resp_EapSetPacFile", "RPC_ID__Resp_EapSetPacFile", 634 }, + { "Resp_EapSetFastParams", "RPC_ID__Resp_EapSetFastParams", 635 }, + { "Resp_EapUseDefaultCertBundle", "RPC_ID__Resp_EapUseDefaultCertBundle", 636 }, + { "Resp_WifiSetOkcSupport", "RPC_ID__Resp_WifiSetOkcSupport", 637 }, + { "Resp_EapSetDomainName", "RPC_ID__Resp_EapSetDomainName", 638 }, + { "Resp_EapSetDisableTimeCheck", "RPC_ID__Resp_EapSetDisableTimeCheck", 639 }, + { "Resp_EapSetEapMethods", "RPC_ID__Resp_EapSetEapMethods", 640 }, + { "Resp_IfaceMacAddrSetGet", "RPC_ID__Resp_IfaceMacAddrSetGet", 641 }, + { "Resp_IfaceMacAddrLenGet", "RPC_ID__Resp_IfaceMacAddrLenGet", 642 }, + { "Resp_FeatureControl", "RPC_ID__Resp_FeatureControl", 643 }, + { "Resp_Max", "RPC_ID__Resp_Max", 644 }, + { "Event_Base", "RPC_ID__Event_Base", 768 }, + { "Event_ESPInit", "RPC_ID__Event_ESPInit", 769 }, + { "Event_Heartbeat", "RPC_ID__Event_Heartbeat", 770 }, + { "Event_AP_StaConnected", "RPC_ID__Event_AP_StaConnected", 771 }, + { "Event_AP_StaDisconnected", "RPC_ID__Event_AP_StaDisconnected", 772 }, + { "Event_WifiEventNoArgs", "RPC_ID__Event_WifiEventNoArgs", 773 }, + { "Event_StaScanDone", "RPC_ID__Event_StaScanDone", 774 }, + { "Event_StaConnected", "RPC_ID__Event_StaConnected", 775 }, + { "Event_StaDisconnected", "RPC_ID__Event_StaDisconnected", 776 }, + { "Event_DhcpDnsStatus", "RPC_ID__Event_DhcpDnsStatus", 777 }, + { "Event_StaItwtSetup", "RPC_ID__Event_StaItwtSetup", 778 }, + { "Event_StaItwtTeardown", "RPC_ID__Event_StaItwtTeardown", 779 }, + { "Event_StaItwtSuspend", "RPC_ID__Event_StaItwtSuspend", 780 }, + { "Event_StaItwtProbe", "RPC_ID__Event_StaItwtProbe", 781 }, + { "Event_SuppDppUriReady", "RPC_ID__Event_SuppDppUriReady", 782 }, + { "Event_SuppDppCfgRecvd", "RPC_ID__Event_SuppDppCfgRecvd", 783 }, + { "Event_SuppDppFail", "RPC_ID__Event_SuppDppFail", 784 }, + { "Event_WifiDppUriReady", "RPC_ID__Event_WifiDppUriReady", 785 }, + { "Event_WifiDppCfgRecvd", "RPC_ID__Event_WifiDppCfgRecvd", 786 }, + { "Event_WifiDppFail", "RPC_ID__Event_WifiDppFail", 787 }, + { "Event_Max", "RPC_ID__Event_Max", 788 }, +}; +static const ProtobufCIntRange rpc_id__value_ranges[] = { +{0, 0},{256, 1},{270, 11},{297, 36},{512, 128},{526, 138},{553, 163},{768, 255},{0, 276} +}; +static const ProtobufCEnumValueIndex rpc_id__enum_values_by_name[276] = +{ + { "Event_AP_StaConnected", 258 }, + { "Event_AP_StaDisconnected", 259 }, + { "Event_Base", 255 }, + { "Event_DhcpDnsStatus", 264 }, + { "Event_ESPInit", 256 }, + { "Event_Heartbeat", 257 }, + { "Event_Max", 275 }, + { "Event_StaConnected", 262 }, + { "Event_StaDisconnected", 263 }, + { "Event_StaItwtProbe", 268 }, + { "Event_StaItwtSetup", 265 }, + { "Event_StaItwtSuspend", 267 }, + { "Event_StaItwtTeardown", 266 }, + { "Event_StaScanDone", 261 }, + { "Event_SuppDppCfgRecvd", 270 }, + { "Event_SuppDppFail", 271 }, + { "Event_SuppDppUriReady", 269 }, + { "Event_WifiDppCfgRecvd", 273 }, + { "Event_WifiDppFail", 274 }, + { "Event_WifiDppUriReady", 272 }, + { "Event_WifiEventNoArgs", 260 }, + { "MsgId_Invalid", 0 }, + { "Req_Base", 1 }, + { "Req_ConfigHeartbeat", 18 }, + { "Req_EapClearCaCert", 111 }, + { "Req_EapClearCertificateAndKey", 113 }, + { "Req_EapClearIdentity", 103 }, + { "Req_EapClearNewPassword", 109 }, + { "Req_EapClearPassword", 107 }, + { "Req_EapClearUsername", 105 }, + { "Req_EapGetDisableTimeCheck", 114 }, + { "Req_EapSetCaCert", 110 }, + { "Req_EapSetCertificateAndKey", 112 }, + { "Req_EapSetDisableTimeCheck", 122 }, + { "Req_EapSetDomainName", 121 }, + { "Req_EapSetEapMethods", 123 }, + { "Req_EapSetFastParams", 118 }, + { "Req_EapSetIdentity", 102 }, + { "Req_EapSetNewPassword", 108 }, + { "Req_EapSetPacFile", 117 }, + { "Req_EapSetPassword", 106 }, + { "Req_EapSetSuitebCertification", 116 }, + { "Req_EapSetTtlsPhase2Method", 115 }, + { "Req_EapSetUsername", 104 }, + { "Req_EapUseDefaultCertBundle", 119 }, + { "Req_FeatureControl", 126 }, + { "Req_GetCoprocessorFwVersion", 89 }, + { "Req_GetDhcpDnsStatus", 92 }, + { "Req_GetMACAddress", 2 }, + { "Req_GetWifiMode", 4 }, + { "Req_IfaceMacAddrLenGet", 125 }, + { "Req_IfaceMacAddrSetGet", 124 }, + { "Req_Max", 127 }, + { "Req_OTABegin", 13 }, + { "Req_OTAEnd", 15 }, + { "Req_OTAWrite", 14 }, + { "Req_SetDhcpDnsStatus", 91 }, + { "Req_SetMacAddress", 3 }, + { "Req_SetWifiMode", 5 }, + { "Req_SuppDppBootstrapGen", 8 }, + { "Req_SuppDppDeinit", 7 }, + { "Req_SuppDppInit", 6 }, + { "Req_SuppDppStartListen", 9 }, + { "Req_SuppDppStopListen", 10 }, + { "Req_Wifi80211Tx", 56 }, + { "Req_WifiApGetStaAid", 51 }, + { "Req_WifiApGetStaList", 50 }, + { "Req_WifiClearApList", 31 }, + { "Req_WifiClearFastConnect", 33 }, + { "Req_WifiConfig11bRate", 71 }, + { "Req_WifiConfig80211TxRate", 75 }, + { "Req_WifiConnect", 23 }, + { "Req_WifiConnectionlessModuleSetWakeInterval", 72 }, + { "Req_WifiDeauthSta", 34 }, + { "Req_WifiDeinit", 20 }, + { "Req_WifiDisablePmfConfig", 76 }, + { "Req_WifiDisconnect", 24 }, + { "Req_WifiFtmEndSession", 69 }, + { "Req_WifiFtmInitiateSession", 68 }, + { "Req_WifiFtmRespSetOffset", 70 }, + { "Req_WifiGetAnt", 62 }, + { "Req_WifiGetAntGpio", 60 }, + { "Req_WifiGetBand", 86 }, + { "Req_WifiGetBandMode", 88 }, + { "Req_WifiGetBandwidth", 39 }, + { "Req_WifiGetBandwidths", 84 }, + { "Req_WifiGetChannel", 41 }, + { "Req_WifiGetConfig", 26 }, + { "Req_WifiGetCountry", 43 }, + { "Req_WifiGetCountryCode", 74 }, + { "Req_WifiGetEventMask", 55 }, + { "Req_WifiGetInactiveTime", 65 }, + { "Req_WifiGetMaxTxPower", 17 }, + { "Req_WifiGetPromiscuous", 45 }, + { "Req_WifiGetPromiscuousCtrlFilter", 49 }, + { "Req_WifiGetPromiscuousFilter", 47 }, + { "Req_WifiGetProtocol", 37 }, + { "Req_WifiGetProtocols", 82 }, + { "Req_WifiGetPs", 12 }, + { "Req_WifiGetTsfTime", 63 }, + { "Req_WifiInit", 19 }, + { "Req_WifiRestore", 32 }, + { "Req_WifiScanGetApNum", 29 }, + { "Req_WifiScanGetApRecord", 90 }, + { "Req_WifiScanGetApRecords", 30 }, + { "Req_WifiScanStart", 27 }, + { "Req_WifiScanStop", 28 }, + { "Req_WifiSetAnt", 61 }, + { "Req_WifiSetAntGpio", 59 }, + { "Req_WifiSetBand", 85 }, + { "Req_WifiSetBandMode", 87 }, + { "Req_WifiSetBandwidth", 38 }, + { "Req_WifiSetBandwidths", 83 }, + { "Req_WifiSetChannel", 40 }, + { "Req_WifiSetConfig", 25 }, + { "Req_WifiSetCountry", 42 }, + { "Req_WifiSetCountryCode", 73 }, + { "Req_WifiSetCsi", 58 }, + { "Req_WifiSetCsiConfig", 57 }, + { "Req_WifiSetDynamicCs", 79 }, + { "Req_WifiSetEventMask", 54 }, + { "Req_WifiSetInactiveTime", 64 }, + { "Req_WifiSetMaxTxPower", 16 }, + { "Req_WifiSetOkcSupport", 120 }, + { "Req_WifiSetPromiscuous", 44 }, + { "Req_WifiSetPromiscuousCtrlFilter", 48 }, + { "Req_WifiSetPromiscuousFilter", 46 }, + { "Req_WifiSetProtocol", 36 }, + { "Req_WifiSetProtocols", 81 }, + { "Req_WifiSetPs", 11 }, + { "Req_WifiSetRssiThreshold", 67 }, + { "Req_WifiSetStorage", 52 }, + { "Req_WifiSetVendorIe", 53 }, + { "Req_WifiStaEnterpriseDisable", 101 }, + { "Req_WifiStaEnterpriseEnable", 100 }, + { "Req_WifiStaGetAid", 77 }, + { "Req_WifiStaGetApInfo", 35 }, + { "Req_WifiStaGetNegotiatedPhymode", 78 }, + { "Req_WifiStaGetRssi", 80 }, + { "Req_WifiStaItwtGetFlowIdStatus", 97 }, + { "Req_WifiStaItwtSendProbeReq", 98 }, + { "Req_WifiStaItwtSetTargetWakeTimeOffset", 99 }, + { "Req_WifiStaItwtSetup", 94 }, + { "Req_WifiStaItwtSuspend", 96 }, + { "Req_WifiStaItwtTeardown", 95 }, + { "Req_WifiStaTwtConfig", 93 }, + { "Req_WifiStart", 21 }, + { "Req_WifiStatisDump", 66 }, + { "Req_WifiStop", 22 }, + { "Resp_Base", 128 }, + { "Resp_ConfigHeartbeat", 145 }, + { "Resp_EapClearCaCert", 238 }, + { "Resp_EapClearCertificateAndKey", 240 }, + { "Resp_EapClearIdentity", 230 }, + { "Resp_EapClearNewPassword", 236 }, + { "Resp_EapClearPassword", 234 }, + { "Resp_EapClearUsername", 232 }, + { "Resp_EapGetDisableTimeCheck", 241 }, + { "Resp_EapSetCaCert", 237 }, + { "Resp_EapSetCertificateAndKey", 239 }, + { "Resp_EapSetDisableTimeCheck", 249 }, + { "Resp_EapSetDomainName", 248 }, + { "Resp_EapSetEapMethods", 250 }, + { "Resp_EapSetFastParams", 245 }, + { "Resp_EapSetIdentity", 229 }, + { "Resp_EapSetNewPassword", 235 }, + { "Resp_EapSetPacFile", 244 }, + { "Resp_EapSetPassword", 233 }, + { "Resp_EapSetSuitebCertification", 243 }, + { "Resp_EapSetTtlsPhase2Method", 242 }, + { "Resp_EapSetUsername", 231 }, + { "Resp_EapUseDefaultCertBundle", 246 }, + { "Resp_FeatureControl", 253 }, + { "Resp_GetCoprocessorFwVersion", 216 }, + { "Resp_GetDhcpDnsStatus", 219 }, + { "Resp_GetMACAddress", 129 }, + { "Resp_GetWifiMode", 131 }, + { "Resp_IfaceMacAddrLenGet", 252 }, + { "Resp_IfaceMacAddrSetGet", 251 }, + { "Resp_Max", 254 }, + { "Resp_OTABegin", 140 }, + { "Resp_OTAEnd", 142 }, + { "Resp_OTAWrite", 141 }, + { "Resp_SetDhcpDnsStatus", 218 }, + { "Resp_SetMacAddress", 130 }, + { "Resp_SetWifiMode", 132 }, + { "Resp_SuppDppBootstrapGen", 135 }, + { "Resp_SuppDppDeinit", 134 }, + { "Resp_SuppDppInit", 133 }, + { "Resp_SuppDppStartListen", 136 }, + { "Resp_SuppDppStopListen", 137 }, + { "Resp_Wifi80211Tx", 183 }, + { "Resp_WifiApGetStaAid", 178 }, + { "Resp_WifiApGetStaList", 177 }, + { "Resp_WifiClearApList", 158 }, + { "Resp_WifiClearFastConnect", 160 }, + { "Resp_WifiConfig11bRate", 198 }, + { "Resp_WifiConfig80211TxRate", 202 }, + { "Resp_WifiConnect", 150 }, + { "Resp_WifiConnectionlessModuleSetWakeInterval", 199 }, + { "Resp_WifiDeauthSta", 161 }, + { "Resp_WifiDeinit", 147 }, + { "Resp_WifiDisablePmfConfig", 203 }, + { "Resp_WifiDisconnect", 151 }, + { "Resp_WifiFtmEndSession", 196 }, + { "Resp_WifiFtmInitiateSession", 195 }, + { "Resp_WifiFtmRespSetOffset", 197 }, + { "Resp_WifiGetAnt", 189 }, + { "Resp_WifiGetAntGpio", 187 }, + { "Resp_WifiGetBand", 213 }, + { "Resp_WifiGetBandMode", 215 }, + { "Resp_WifiGetBandwidth", 166 }, + { "Resp_WifiGetBandwidths", 211 }, + { "Resp_WifiGetChannel", 168 }, + { "Resp_WifiGetConfig", 153 }, + { "Resp_WifiGetCountry", 170 }, + { "Resp_WifiGetCountryCode", 201 }, + { "Resp_WifiGetEventMask", 182 }, + { "Resp_WifiGetInactiveTime", 192 }, + { "Resp_WifiGetMaxTxPower", 144 }, + { "Resp_WifiGetPromiscuous", 172 }, + { "Resp_WifiGetPromiscuousCtrlFilter", 176 }, + { "Resp_WifiGetPromiscuousFilter", 174 }, + { "Resp_WifiGetProtocol", 164 }, + { "Resp_WifiGetProtocols", 209 }, + { "Resp_WifiGetPs", 139 }, + { "Resp_WifiGetTsfTime", 190 }, + { "Resp_WifiInit", 146 }, + { "Resp_WifiRestore", 159 }, + { "Resp_WifiScanGetApNum", 156 }, + { "Resp_WifiScanGetApRecord", 217 }, + { "Resp_WifiScanGetApRecords", 157 }, + { "Resp_WifiScanStart", 154 }, + { "Resp_WifiScanStop", 155 }, + { "Resp_WifiSetAnt", 188 }, + { "Resp_WifiSetAntGpio", 186 }, + { "Resp_WifiSetBand", 212 }, + { "Resp_WifiSetBandMode", 214 }, + { "Resp_WifiSetBandwidth", 165 }, + { "Resp_WifiSetBandwidths", 210 }, + { "Resp_WifiSetChannel", 167 }, + { "Resp_WifiSetConfig", 152 }, + { "Resp_WifiSetCountry", 169 }, + { "Resp_WifiSetCountryCode", 200 }, + { "Resp_WifiSetCsi", 185 }, + { "Resp_WifiSetCsiConfig", 184 }, + { "Resp_WifiSetDynamicCs", 206 }, + { "Resp_WifiSetEventMask", 181 }, + { "Resp_WifiSetInactiveTime", 191 }, + { "Resp_WifiSetMaxTxPower", 143 }, + { "Resp_WifiSetOkcSupport", 247 }, + { "Resp_WifiSetPromiscuous", 171 }, + { "Resp_WifiSetPromiscuousCtrlFilter", 175 }, + { "Resp_WifiSetPromiscuousFilter", 173 }, + { "Resp_WifiSetProtocol", 163 }, + { "Resp_WifiSetProtocols", 208 }, + { "Resp_WifiSetPs", 138 }, + { "Resp_WifiSetRssiThreshold", 194 }, + { "Resp_WifiSetStorage", 179 }, + { "Resp_WifiSetVendorIe", 180 }, + { "Resp_WifiStaEnterpriseDisable", 228 }, + { "Resp_WifiStaEnterpriseEnable", 227 }, + { "Resp_WifiStaGetAid", 204 }, + { "Resp_WifiStaGetApInfo", 162 }, + { "Resp_WifiStaGetNegotiatedPhymode", 205 }, + { "Resp_WifiStaGetRssi", 207 }, + { "Resp_WifiStaItwtGetFlowIdStatus", 224 }, + { "Resp_WifiStaItwtSendProbeReq", 225 }, + { "Resp_WifiStaItwtSetTargetWakeTimeOffset", 226 }, + { "Resp_WifiStaItwtSetup", 221 }, + { "Resp_WifiStaItwtSuspend", 223 }, + { "Resp_WifiStaItwtTeardown", 222 }, + { "Resp_WifiStaTwtConfig", 220 }, + { "Resp_WifiStart", 148 }, + { "Resp_WifiStatisDump", 193 }, + { "Resp_WifiStop", 149 }, +}; +const ProtobufCEnumDescriptor rpc_id__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "RpcId", + "RpcId", + "RpcId", + "", + 276, + rpc_id__enum_values_by_number, + 276, + rpc_id__enum_values_by_name, + 8, + rpc_id__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.pb-c.h b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.pb-c.h new file mode 100644 index 0000000..210d314 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.pb-c.h @@ -0,0 +1,11346 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: esp_hosted_rpc.proto */ + +#ifndef PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED +#define PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct WifiInitConfig WifiInitConfig; +typedef struct WifiCountry WifiCountry; +typedef struct WifiActiveScanTime WifiActiveScanTime; +typedef struct WifiScanTime WifiScanTime; +typedef struct WifiScanChannelBitmap WifiScanChannelBitmap; +typedef struct WifiScanConfig WifiScanConfig; +typedef struct WifiHeApInfo WifiHeApInfo; +typedef struct WifiApRecord WifiApRecord; +typedef struct WifiScanThreshold WifiScanThreshold; +typedef struct WifiPmfConfig WifiPmfConfig; +typedef struct WifiBssMaxIdleConfig WifiBssMaxIdleConfig; +typedef struct WifiApConfig WifiApConfig; +typedef struct WifiStaConfig WifiStaConfig; +typedef struct WifiConfig WifiConfig; +typedef struct WifiStaInfo WifiStaInfo; +typedef struct WifiStaList WifiStaList; +typedef struct WifiPktRxCtrl WifiPktRxCtrl; +typedef struct WifiPromiscuousPkt WifiPromiscuousPkt; +typedef struct WifiPromiscuousFilter WifiPromiscuousFilter; +typedef struct WifiCsiConfig WifiCsiConfig; +typedef struct WifiCsiInfo WifiCsiInfo; +typedef struct WifiAntGpio WifiAntGpio; +typedef struct WifiAntGpioConfig WifiAntGpioConfig; +typedef struct WifiAntConfig WifiAntConfig; +typedef struct WifiActionTxReq WifiActionTxReq; +typedef struct WifiFtmInitiatorCfg WifiFtmInitiatorCfg; +typedef struct WifiEventStaScanDone WifiEventStaScanDone; +typedef struct WifiEventStaConnected WifiEventStaConnected; +typedef struct WifiEventStaDisconnected WifiEventStaDisconnected; +typedef struct WifiEventStaAuthmodeChange WifiEventStaAuthmodeChange; +typedef struct WifiEventStaWpsErPin WifiEventStaWpsErPin; +typedef struct ApCred ApCred; +typedef struct WifiEventStaWpsErSuccess WifiEventStaWpsErSuccess; +typedef struct WifiEventApProbeReqRx WifiEventApProbeReqRx; +typedef struct WifiEventBssRssiLow WifiEventBssRssiLow; +typedef struct WifiFtmReportEntry WifiFtmReportEntry; +typedef struct WifiEventFtmReport WifiEventFtmReport; +typedef struct WifiEventActionTxStatus WifiEventActionTxStatus; +typedef struct WifiEventRocDone WifiEventRocDone; +typedef struct WifiEventApWpsRgPin WifiEventApWpsRgPin; +typedef struct WifiEventApWpsRgFailReason WifiEventApWpsRgFailReason; +typedef struct WifiEventApWpsRgSuccess WifiEventApWpsRgSuccess; +typedef struct WifiProtocols WifiProtocols; +typedef struct WifiBandwidths WifiBandwidths; +typedef struct WifiItwtSetupConfig WifiItwtSetupConfig; +typedef struct WifiTwtConfig WifiTwtConfig; +typedef struct ConnectedSTAList ConnectedSTAList; +typedef struct EapFastConfig EapFastConfig; +typedef struct RpcReqGetMacAddress RpcReqGetMacAddress; +typedef struct RpcRespGetMacAddress RpcRespGetMacAddress; +typedef struct RpcReqGetMode RpcReqGetMode; +typedef struct RpcRespGetMode RpcRespGetMode; +typedef struct RpcReqSetMode RpcReqSetMode; +typedef struct RpcRespSetMode RpcRespSetMode; +typedef struct RpcReqGetPs RpcReqGetPs; +typedef struct RpcRespGetPs RpcRespGetPs; +typedef struct RpcReqSetPs RpcReqSetPs; +typedef struct RpcRespSetPs RpcRespSetPs; +typedef struct RpcReqSetMacAddress RpcReqSetMacAddress; +typedef struct RpcRespSetMacAddress RpcRespSetMacAddress; +typedef struct RpcReqOTABegin RpcReqOTABegin; +typedef struct RpcRespOTABegin RpcRespOTABegin; +typedef struct RpcReqOTAWrite RpcReqOTAWrite; +typedef struct RpcRespOTAWrite RpcRespOTAWrite; +typedef struct RpcReqOTAEnd RpcReqOTAEnd; +typedef struct RpcRespOTAEnd RpcRespOTAEnd; +typedef struct RpcReqWifiSetMaxTxPower RpcReqWifiSetMaxTxPower; +typedef struct RpcRespWifiSetMaxTxPower RpcRespWifiSetMaxTxPower; +typedef struct RpcReqWifiGetMaxTxPower RpcReqWifiGetMaxTxPower; +typedef struct RpcRespWifiGetMaxTxPower RpcRespWifiGetMaxTxPower; +typedef struct RpcReqConfigHeartbeat RpcReqConfigHeartbeat; +typedef struct RpcRespConfigHeartbeat RpcRespConfigHeartbeat; +typedef struct RpcReqWifiInit RpcReqWifiInit; +typedef struct RpcRespWifiInit RpcRespWifiInit; +typedef struct RpcReqWifiDeinit RpcReqWifiDeinit; +typedef struct RpcRespWifiDeinit RpcRespWifiDeinit; +typedef struct RpcReqWifiSetConfig RpcReqWifiSetConfig; +typedef struct RpcRespWifiSetConfig RpcRespWifiSetConfig; +typedef struct RpcReqWifiGetConfig RpcReqWifiGetConfig; +typedef struct RpcRespWifiGetConfig RpcRespWifiGetConfig; +typedef struct RpcReqWifiConnect RpcReqWifiConnect; +typedef struct RpcRespWifiConnect RpcRespWifiConnect; +typedef struct RpcReqWifiDisconnect RpcReqWifiDisconnect; +typedef struct RpcRespWifiDisconnect RpcRespWifiDisconnect; +typedef struct RpcReqWifiStart RpcReqWifiStart; +typedef struct RpcRespWifiStart RpcRespWifiStart; +typedef struct RpcReqWifiStop RpcReqWifiStop; +typedef struct RpcRespWifiStop RpcRespWifiStop; +typedef struct RpcReqWifiScanStart RpcReqWifiScanStart; +typedef struct RpcRespWifiScanStart RpcRespWifiScanStart; +typedef struct RpcReqWifiScanStop RpcReqWifiScanStop; +typedef struct RpcRespWifiScanStop RpcRespWifiScanStop; +typedef struct RpcReqWifiScanGetApNum RpcReqWifiScanGetApNum; +typedef struct RpcRespWifiScanGetApNum RpcRespWifiScanGetApNum; +typedef struct RpcReqWifiScanGetApRecords RpcReqWifiScanGetApRecords; +typedef struct RpcRespWifiScanGetApRecords RpcRespWifiScanGetApRecords; +typedef struct RpcReqWifiScanGetApRecord RpcReqWifiScanGetApRecord; +typedef struct RpcRespWifiScanGetApRecord RpcRespWifiScanGetApRecord; +typedef struct RpcReqWifiClearApList RpcReqWifiClearApList; +typedef struct RpcRespWifiClearApList RpcRespWifiClearApList; +typedef struct RpcReqWifiRestore RpcReqWifiRestore; +typedef struct RpcRespWifiRestore RpcRespWifiRestore; +typedef struct RpcReqWifiClearFastConnect RpcReqWifiClearFastConnect; +typedef struct RpcRespWifiClearFastConnect RpcRespWifiClearFastConnect; +typedef struct RpcReqWifiDeauthSta RpcReqWifiDeauthSta; +typedef struct RpcRespWifiDeauthSta RpcRespWifiDeauthSta; +typedef struct RpcReqWifiStaGetApInfo RpcReqWifiStaGetApInfo; +typedef struct RpcRespWifiStaGetApInfo RpcRespWifiStaGetApInfo; +typedef struct RpcReqWifiSetProtocol RpcReqWifiSetProtocol; +typedef struct RpcRespWifiSetProtocol RpcRespWifiSetProtocol; +typedef struct RpcReqWifiGetProtocol RpcReqWifiGetProtocol; +typedef struct RpcRespWifiGetProtocol RpcRespWifiGetProtocol; +typedef struct RpcReqWifiSetBandwidth RpcReqWifiSetBandwidth; +typedef struct RpcRespWifiSetBandwidth RpcRespWifiSetBandwidth; +typedef struct RpcReqWifiGetBandwidth RpcReqWifiGetBandwidth; +typedef struct RpcRespWifiGetBandwidth RpcRespWifiGetBandwidth; +typedef struct RpcReqWifiSetChannel RpcReqWifiSetChannel; +typedef struct RpcRespWifiSetChannel RpcRespWifiSetChannel; +typedef struct RpcReqWifiGetChannel RpcReqWifiGetChannel; +typedef struct RpcRespWifiGetChannel RpcRespWifiGetChannel; +typedef struct RpcReqWifiSetStorage RpcReqWifiSetStorage; +typedef struct RpcRespWifiSetStorage RpcRespWifiSetStorage; +typedef struct RpcReqWifiSetCountryCode RpcReqWifiSetCountryCode; +typedef struct RpcRespWifiSetCountryCode RpcRespWifiSetCountryCode; +typedef struct RpcReqWifiGetCountryCode RpcReqWifiGetCountryCode; +typedef struct RpcRespWifiGetCountryCode RpcRespWifiGetCountryCode; +typedef struct RpcReqWifiSetCountry RpcReqWifiSetCountry; +typedef struct RpcRespWifiSetCountry RpcRespWifiSetCountry; +typedef struct RpcReqWifiGetCountry RpcReqWifiGetCountry; +typedef struct RpcRespWifiGetCountry RpcRespWifiGetCountry; +typedef struct RpcReqWifiApGetStaList RpcReqWifiApGetStaList; +typedef struct RpcRespWifiApGetStaList RpcRespWifiApGetStaList; +typedef struct RpcReqWifiApGetStaAid RpcReqWifiApGetStaAid; +typedef struct RpcReqWifiStaGetNegotiatedPhymode RpcReqWifiStaGetNegotiatedPhymode; +typedef struct RpcRespWifiStaGetNegotiatedPhymode RpcRespWifiStaGetNegotiatedPhymode; +typedef struct RpcRespWifiApGetStaAid RpcRespWifiApGetStaAid; +typedef struct RpcReqWifiStaGetRssi RpcReqWifiStaGetRssi; +typedef struct RpcRespWifiStaGetRssi RpcRespWifiStaGetRssi; +typedef struct RpcReqWifiStaGetAid RpcReqWifiStaGetAid; +typedef struct RpcRespWifiStaGetAid RpcRespWifiStaGetAid; +typedef struct RpcReqWifiSetProtocols RpcReqWifiSetProtocols; +typedef struct RpcRespWifiSetProtocols RpcRespWifiSetProtocols; +typedef struct RpcReqWifiGetProtocols RpcReqWifiGetProtocols; +typedef struct RpcRespWifiGetProtocols RpcRespWifiGetProtocols; +typedef struct RpcReqWifiSetBandwidths RpcReqWifiSetBandwidths; +typedef struct RpcRespWifiSetBandwidths RpcRespWifiSetBandwidths; +typedef struct RpcReqWifiGetBandwidths RpcReqWifiGetBandwidths; +typedef struct RpcRespWifiGetBandwidths RpcRespWifiGetBandwidths; +typedef struct RpcReqWifiSetBand RpcReqWifiSetBand; +typedef struct RpcRespWifiSetBand RpcRespWifiSetBand; +typedef struct RpcReqWifiGetBand RpcReqWifiGetBand; +typedef struct RpcRespWifiGetBand RpcRespWifiGetBand; +typedef struct RpcReqWifiSetBandMode RpcReqWifiSetBandMode; +typedef struct RpcRespWifiSetBandMode RpcRespWifiSetBandMode; +typedef struct RpcReqWifiGetBandMode RpcReqWifiGetBandMode; +typedef struct RpcRespWifiGetBandMode RpcRespWifiGetBandMode; +typedef struct RpcReqWifiSetInactiveTime RpcReqWifiSetInactiveTime; +typedef struct RpcRespWifiSetInactiveTime RpcRespWifiSetInactiveTime; +typedef struct RpcReqWifiGetInactiveTime RpcReqWifiGetInactiveTime; +typedef struct RpcRespWifiGetInactiveTime RpcRespWifiGetInactiveTime; +typedef struct RpcReqWifiStaItwtSetup RpcReqWifiStaItwtSetup; +typedef struct RpcRespWifiStaItwtSetup RpcRespWifiStaItwtSetup; +typedef struct RpcReqWifiStaItwtTeardown RpcReqWifiStaItwtTeardown; +typedef struct RpcRespWifiStaItwtTeardown RpcRespWifiStaItwtTeardown; +typedef struct RpcReqWifiStaItwtSuspend RpcReqWifiStaItwtSuspend; +typedef struct RpcRespWifiStaItwtSuspend RpcRespWifiStaItwtSuspend; +typedef struct RpcReqWifiStaItwtGetFlowIdStatus RpcReqWifiStaItwtGetFlowIdStatus; +typedef struct RpcRespWifiStaItwtGetFlowIdStatus RpcRespWifiStaItwtGetFlowIdStatus; +typedef struct RpcReqWifiStaItwtSendProbeReq RpcReqWifiStaItwtSendProbeReq; +typedef struct RpcRespWifiStaItwtSendProbeReq RpcRespWifiStaItwtSendProbeReq; +typedef struct RpcReqWifiStaItwtSetTargetWakeTimeOffset RpcReqWifiStaItwtSetTargetWakeTimeOffset; +typedef struct RpcRespWifiStaItwtSetTargetWakeTimeOffset RpcRespWifiStaItwtSetTargetWakeTimeOffset; +typedef struct RpcReqWifiStaTwtConfig RpcReqWifiStaTwtConfig; +typedef struct RpcRespWifiStaTwtConfig RpcRespWifiStaTwtConfig; +typedef struct RpcReqGetCoprocessorFwVersion RpcReqGetCoprocessorFwVersion; +typedef struct RpcRespGetCoprocessorFwVersion RpcRespGetCoprocessorFwVersion; +typedef struct RpcReqSetDhcpDnsStatus RpcReqSetDhcpDnsStatus; +typedef struct RpcRespSetDhcpDnsStatus RpcRespSetDhcpDnsStatus; +typedef struct RpcReqGetDhcpDnsStatus RpcReqGetDhcpDnsStatus; +typedef struct RpcRespGetDhcpDnsStatus RpcRespGetDhcpDnsStatus; +typedef struct RpcReqSuppDppInit RpcReqSuppDppInit; +typedef struct RpcRespSuppDppInit RpcRespSuppDppInit; +typedef struct RpcReqSuppDppDeinit RpcReqSuppDppDeinit; +typedef struct RpcRespSuppDppDeinit RpcRespSuppDppDeinit; +typedef struct RpcReqSuppDppBootstrapGen RpcReqSuppDppBootstrapGen; +typedef struct RpcRespSuppDppBootstrapGen RpcRespSuppDppBootstrapGen; +typedef struct RpcReqSuppDppStartListen RpcReqSuppDppStartListen; +typedef struct RpcRespSuppDppStartListen RpcRespSuppDppStartListen; +typedef struct RpcReqSuppDppStopListen RpcReqSuppDppStopListen; +typedef struct RpcRespSuppDppStopListen RpcRespSuppDppStopListen; +typedef struct RpcReqIfaceMacAddrSetGet RpcReqIfaceMacAddrSetGet; +typedef struct RpcRespIfaceMacAddrSetGet RpcRespIfaceMacAddrSetGet; +typedef struct RpcReqIfaceMacAddrLenGet RpcReqIfaceMacAddrLenGet; +typedef struct RpcRespIfaceMacAddrLenGet RpcRespIfaceMacAddrLenGet; +typedef struct RpcReqFeatureControl RpcReqFeatureControl; +typedef struct RpcRespFeatureControl RpcRespFeatureControl; +typedef struct RpcEventWifiEventNoArgs RpcEventWifiEventNoArgs; +typedef struct RpcEventESPInit RpcEventESPInit; +typedef struct RpcEventHeartbeat RpcEventHeartbeat; +typedef struct RpcEventAPStaDisconnected RpcEventAPStaDisconnected; +typedef struct RpcEventAPStaConnected RpcEventAPStaConnected; +typedef struct RpcEventStaScanDone RpcEventStaScanDone; +typedef struct RpcEventStaConnected RpcEventStaConnected; +typedef struct RpcEventStaDisconnected RpcEventStaDisconnected; +typedef struct RpcEventDhcpDnsStatus RpcEventDhcpDnsStatus; +typedef struct RpcEventStaItwtSetup RpcEventStaItwtSetup; +typedef struct RpcEventStaItwtTeardown RpcEventStaItwtTeardown; +typedef struct RpcEventStaItwtSuspend RpcEventStaItwtSuspend; +typedef struct RpcEventStaItwtProbe RpcEventStaItwtProbe; +typedef struct RpcReqWifiStaEnterpriseEnable RpcReqWifiStaEnterpriseEnable; +typedef struct RpcRespWifiStaEnterpriseEnable RpcRespWifiStaEnterpriseEnable; +typedef struct RpcReqWifiStaEnterpriseDisable RpcReqWifiStaEnterpriseDisable; +typedef struct RpcRespWifiStaEnterpriseDisable RpcRespWifiStaEnterpriseDisable; +typedef struct RpcReqEapSetIdentity RpcReqEapSetIdentity; +typedef struct RpcRespEapSetIdentity RpcRespEapSetIdentity; +typedef struct RpcReqEapClearIdentity RpcReqEapClearIdentity; +typedef struct RpcRespEapClearIdentity RpcRespEapClearIdentity; +typedef struct RpcReqEapSetUsername RpcReqEapSetUsername; +typedef struct RpcRespEapSetUsername RpcRespEapSetUsername; +typedef struct RpcReqEapClearUsername RpcReqEapClearUsername; +typedef struct RpcRespEapClearUsername RpcRespEapClearUsername; +typedef struct RpcReqEapSetPassword RpcReqEapSetPassword; +typedef struct RpcRespEapSetPassword RpcRespEapSetPassword; +typedef struct RpcReqEapClearPassword RpcReqEapClearPassword; +typedef struct RpcRespEapClearPassword RpcRespEapClearPassword; +typedef struct RpcReqEapSetNewPassword RpcReqEapSetNewPassword; +typedef struct RpcRespEapSetNewPassword RpcRespEapSetNewPassword; +typedef struct RpcReqEapClearNewPassword RpcReqEapClearNewPassword; +typedef struct RpcRespEapClearNewPassword RpcRespEapClearNewPassword; +typedef struct RpcReqEapSetCaCert RpcReqEapSetCaCert; +typedef struct RpcRespEapSetCaCert RpcRespEapSetCaCert; +typedef struct RpcReqEapClearCaCert RpcReqEapClearCaCert; +typedef struct RpcRespEapClearCaCert RpcRespEapClearCaCert; +typedef struct RpcReqEapSetCertificateAndKey RpcReqEapSetCertificateAndKey; +typedef struct RpcRespEapSetCertificateAndKey RpcRespEapSetCertificateAndKey; +typedef struct RpcReqEapClearCertificateAndKey RpcReqEapClearCertificateAndKey; +typedef struct RpcRespEapClearCertificateAndKey RpcRespEapClearCertificateAndKey; +typedef struct RpcReqEapSetDisableTimeCheck RpcReqEapSetDisableTimeCheck; +typedef struct RpcRespEapSetDisableTimeCheck RpcRespEapSetDisableTimeCheck; +typedef struct RpcReqEapGetDisableTimeCheck RpcReqEapGetDisableTimeCheck; +typedef struct RpcRespEapGetDisableTimeCheck RpcRespEapGetDisableTimeCheck; +typedef struct RpcReqEapSetTtlsPhase2Method RpcReqEapSetTtlsPhase2Method; +typedef struct RpcRespEapSetTtlsPhase2Method RpcRespEapSetTtlsPhase2Method; +typedef struct RpcReqEapSetSuiteb192bitCertification RpcReqEapSetSuiteb192bitCertification; +typedef struct RpcRespEapSetSuiteb192bitCertification RpcRespEapSetSuiteb192bitCertification; +typedef struct RpcReqEapSetPacFile RpcReqEapSetPacFile; +typedef struct RpcRespEapSetPacFile RpcRespEapSetPacFile; +typedef struct RpcReqEapSetFastParams RpcReqEapSetFastParams; +typedef struct RpcRespEapSetFastParams RpcRespEapSetFastParams; +typedef struct RpcReqEapUseDefaultCertBundle RpcReqEapUseDefaultCertBundle; +typedef struct RpcRespEapUseDefaultCertBundle RpcRespEapUseDefaultCertBundle; +typedef struct RpcReqWifiSetOkcSupport RpcReqWifiSetOkcSupport; +typedef struct RpcRespWifiSetOkcSupport RpcRespWifiSetOkcSupport; +typedef struct RpcReqEapSetDomainName RpcReqEapSetDomainName; +typedef struct RpcRespEapSetDomainName RpcRespEapSetDomainName; +typedef struct RpcReqEapSetEapMethods RpcReqEapSetEapMethods; +typedef struct RpcRespEapSetEapMethods RpcRespEapSetEapMethods; +typedef struct RpcEventSuppDppUriReady RpcEventSuppDppUriReady; +typedef struct RpcEventSuppDppCfgRecvd RpcEventSuppDppCfgRecvd; +typedef struct RpcEventSuppDppFail RpcEventSuppDppFail; +typedef struct RpcEventWifiDppUriReady RpcEventWifiDppUriReady; +typedef struct RpcEventWifiDppCfgRecvd RpcEventWifiDppCfgRecvd; +typedef struct RpcEventWifiDppFail RpcEventWifiDppFail; +typedef struct Rpc Rpc; + + +/* --- enums --- */ + +typedef enum _RpcWifiBw { + RPC__WIFI_BW__BW_Invalid = 0, + RPC__WIFI_BW__HT20 = 1, + RPC__WIFI_BW__HT40 = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_BW) +} RpcWifiBw; +typedef enum _RpcWifiPowerSave { + RPC__WIFI_POWER_SAVE__PS_Invalid = 0, + RPC__WIFI_POWER_SAVE__MIN_MODEM = 1, + RPC__WIFI_POWER_SAVE__MAX_MODEM = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_POWER_SAVE) +} RpcWifiPowerSave; +typedef enum _RpcWifiSecProt { + RPC__WIFI_SEC_PROT__Open = 0, + RPC__WIFI_SEC_PROT__WEP = 1, + RPC__WIFI_SEC_PROT__WPA_PSK = 2, + RPC__WIFI_SEC_PROT__WPA2_PSK = 3, + RPC__WIFI_SEC_PROT__WPA_WPA2_PSK = 4, + RPC__WIFI_SEC_PROT__WPA2_ENTERPRISE = 5, + RPC__WIFI_SEC_PROT__WPA3_PSK = 6, + RPC__WIFI_SEC_PROT__WPA2_WPA3_PSK = 7 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_SEC_PROT) +} RpcWifiSecProt; +/* + * enums for Control path + */ +typedef enum _RpcStatus { + RPC__STATUS__Connected = 0, + RPC__STATUS__Not_Connected = 1, + RPC__STATUS__No_AP_Found = 2, + RPC__STATUS__Connection_Fail = 3, + RPC__STATUS__Invalid_Argument = 4, + RPC__STATUS__Out_Of_Range = 5 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__STATUS) +} RpcStatus; +typedef enum _RpcType { + RPC_TYPE__MsgType_Invalid = 0, + RPC_TYPE__Req = 1, + RPC_TYPE__Resp = 2, + RPC_TYPE__Event = 3, + RPC_TYPE__MsgType_Max = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_TYPE) +} RpcType; +typedef enum _RpcFeature { + RPC_FEATURE__Feature_None = 0, + /* + * Bluetooth (BT) Feature + */ + /* + * add additional features here + */ + RPC_FEATURE__Feature_Bluetooth = 1 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_FEATURE) +} RpcFeature; +typedef enum _RpcFeatureCommand { + RPC_FEATURE_COMMAND__Feature_Command_None = 0, + /* + * Bluetooth (BT) Feature Commands + */ + RPC_FEATURE_COMMAND__Feature_Command_BT_Init = 1, + RPC_FEATURE_COMMAND__Feature_Command_BT_Deinit = 2, + RPC_FEATURE_COMMAND__Feature_Command_BT_Enable = 3, + /* + * add additional feature commands here + */ + RPC_FEATURE_COMMAND__Feature_Command_BT_Disable = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_FEATURE_COMMAND) +} RpcFeatureCommand; +typedef enum _RpcFeatureOption { + RPC_FEATURE_OPTION__Feature_Option_None = 0, + /* + * Bluetooth (BT) Feature Options + */ + /* + * release memory when deinit BT + */ + RPC_FEATURE_OPTION__Feature_Option_BT_Deinit_Release_Memory = 1 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_FEATURE_OPTION) +} RpcFeatureOption; +typedef enum _RpcId { + RPC_ID__MsgId_Invalid = 0, + /* + ** Request Msgs * + */ + /* + *0x100 + */ + RPC_ID__Req_Base = 256, + /* + *0x101 + */ + RPC_ID__Req_GetMACAddress = 257, + /* + *0x102 + */ + RPC_ID__Req_SetMacAddress = 258, + /* + *0x103 + */ + RPC_ID__Req_GetWifiMode = 259, + /* + *0x104 + */ + RPC_ID__Req_SetWifiMode = 260, + /* + *0x105 + */ + RPC_ID__Req_SuppDppInit = 261, + /* + *0x106 + */ + RPC_ID__Req_SuppDppDeinit = 262, + /* + *0x107 + */ + RPC_ID__Req_SuppDppBootstrapGen = 263, + /* + *0x108 + */ + RPC_ID__Req_SuppDppStartListen = 264, + /* + *0x109 + */ + RPC_ID__Req_SuppDppStopListen = 265, + /* + *0x10e + */ + RPC_ID__Req_WifiSetPs = 270, + /* + *0x10f + */ + RPC_ID__Req_WifiGetPs = 271, + /* + *0x110 + */ + RPC_ID__Req_OTABegin = 272, + /* + *0x111 + */ + RPC_ID__Req_OTAWrite = 273, + /* + *0x112 + */ + RPC_ID__Req_OTAEnd = 274, + /* + *0x113 + */ + RPC_ID__Req_WifiSetMaxTxPower = 275, + /* + *0x114 + */ + RPC_ID__Req_WifiGetMaxTxPower = 276, + /* + *0x115 + */ + RPC_ID__Req_ConfigHeartbeat = 277, + /* + *0x116 + */ + RPC_ID__Req_WifiInit = 278, + /* + *0x117 + */ + RPC_ID__Req_WifiDeinit = 279, + /* + *0x118 + */ + RPC_ID__Req_WifiStart = 280, + /* + *0x119 + */ + RPC_ID__Req_WifiStop = 281, + /* + *0x11a + */ + RPC_ID__Req_WifiConnect = 282, + /* + *0x11b + */ + RPC_ID__Req_WifiDisconnect = 283, + /* + *0x11c + */ + RPC_ID__Req_WifiSetConfig = 284, + /* + *0x11d + */ + RPC_ID__Req_WifiGetConfig = 285, + /* + *0x11e + */ + RPC_ID__Req_WifiScanStart = 286, + /* + *0x11f + */ + RPC_ID__Req_WifiScanStop = 287, + /* + *0x120 + */ + RPC_ID__Req_WifiScanGetApNum = 288, + /* + *0x121 + */ + RPC_ID__Req_WifiScanGetApRecords = 289, + /* + *0x122 + */ + RPC_ID__Req_WifiClearApList = 290, + /* + *0x123 + */ + RPC_ID__Req_WifiRestore = 291, + /* + *0x124 + */ + RPC_ID__Req_WifiClearFastConnect = 292, + /* + *0x125 + */ + RPC_ID__Req_WifiDeauthSta = 293, + /* + *0x126 + */ + RPC_ID__Req_WifiStaGetApInfo = 294, + /* + *Req_WifiSetPs = 295; //0x127 + *Req_WifiGetPs = 296; //0x128 + */ + /* + *0x129 + */ + RPC_ID__Req_WifiSetProtocol = 297, + /* + *0x12a + */ + RPC_ID__Req_WifiGetProtocol = 298, + /* + *0x12b + */ + RPC_ID__Req_WifiSetBandwidth = 299, + /* + *0x12c + */ + RPC_ID__Req_WifiGetBandwidth = 300, + /* + *0x12d + */ + RPC_ID__Req_WifiSetChannel = 301, + /* + *0x12e + */ + RPC_ID__Req_WifiGetChannel = 302, + /* + *0x12f + */ + RPC_ID__Req_WifiSetCountry = 303, + /* + *0x130 + */ + RPC_ID__Req_WifiGetCountry = 304, + /* + * Req_WifiSetPromiscuousRxCb = 305; //0x131 + */ + /* + *0x131 + */ + RPC_ID__Req_WifiSetPromiscuous = 305, + /* + *0x132 + */ + RPC_ID__Req_WifiGetPromiscuous = 306, + /* + *0x133 + */ + RPC_ID__Req_WifiSetPromiscuousFilter = 307, + /* + *0x134 + */ + RPC_ID__Req_WifiGetPromiscuousFilter = 308, + /* + *0x135 + */ + RPC_ID__Req_WifiSetPromiscuousCtrlFilter = 309, + /* + *0x136 + */ + RPC_ID__Req_WifiGetPromiscuousCtrlFilter = 310, + /* + *0x137 + */ + RPC_ID__Req_WifiApGetStaList = 311, + /* + *0x138 + */ + RPC_ID__Req_WifiApGetStaAid = 312, + /* + *0x139 + */ + RPC_ID__Req_WifiSetStorage = 313, + /* + *0x13a + */ + RPC_ID__Req_WifiSetVendorIe = 314, + /* + * Req_WifiSetVendorIeCb = 315; //0x13b + */ + /* + *0x13b + */ + RPC_ID__Req_WifiSetEventMask = 315, + /* + *0x13c + */ + RPC_ID__Req_WifiGetEventMask = 316, + /* + *0x13d + */ + RPC_ID__Req_Wifi80211Tx = 317, + /* + * Req_WifiSetCsiRxCb = 318; //0x13e + */ + /* + *0x13e + */ + RPC_ID__Req_WifiSetCsiConfig = 318, + /* + *0x13f + */ + RPC_ID__Req_WifiSetCsi = 319, + /* + *0x140 + */ + RPC_ID__Req_WifiSetAntGpio = 320, + /* + *0x141 + */ + RPC_ID__Req_WifiGetAntGpio = 321, + /* + *0x142 + */ + RPC_ID__Req_WifiSetAnt = 322, + /* + *0x143 + */ + RPC_ID__Req_WifiGetAnt = 323, + /* + *0x144 + */ + RPC_ID__Req_WifiGetTsfTime = 324, + /* + *0x145 + */ + RPC_ID__Req_WifiSetInactiveTime = 325, + /* + *0x146 + */ + RPC_ID__Req_WifiGetInactiveTime = 326, + /* + *0x147 + */ + RPC_ID__Req_WifiStatisDump = 327, + /* + *0x148 + */ + RPC_ID__Req_WifiSetRssiThreshold = 328, + /* + *0x149 + */ + RPC_ID__Req_WifiFtmInitiateSession = 329, + /* + *0x14a + */ + RPC_ID__Req_WifiFtmEndSession = 330, + /* + *0x14b + */ + RPC_ID__Req_WifiFtmRespSetOffset = 331, + /* + *0x14c + */ + RPC_ID__Req_WifiConfig11bRate = 332, + /* + *0x14d + */ + RPC_ID__Req_WifiConnectionlessModuleSetWakeInterval = 333, + /* + *0x14e + */ + RPC_ID__Req_WifiSetCountryCode = 334, + /* + *0x14f + */ + RPC_ID__Req_WifiGetCountryCode = 335, + /* + *0x150 + */ + RPC_ID__Req_WifiConfig80211TxRate = 336, + /* + *0x151 + */ + RPC_ID__Req_WifiDisablePmfConfig = 337, + /* + *0x152 + */ + RPC_ID__Req_WifiStaGetAid = 338, + /* + *0x153 + */ + RPC_ID__Req_WifiStaGetNegotiatedPhymode = 339, + /* + *0x154 + */ + RPC_ID__Req_WifiSetDynamicCs = 340, + /* + *0x155 + */ + RPC_ID__Req_WifiStaGetRssi = 341, + /* + *0x156 + */ + RPC_ID__Req_WifiSetProtocols = 342, + /* + *0x157 + */ + RPC_ID__Req_WifiGetProtocols = 343, + /* + *0x158 + */ + RPC_ID__Req_WifiSetBandwidths = 344, + /* + *0x159 + */ + RPC_ID__Req_WifiGetBandwidths = 345, + /* + *0x15a + */ + RPC_ID__Req_WifiSetBand = 346, + /* + *0x15b + */ + RPC_ID__Req_WifiGetBand = 347, + /* + *0x15c + */ + RPC_ID__Req_WifiSetBandMode = 348, + /* + *0x15d + */ + RPC_ID__Req_WifiGetBandMode = 349, + /* + *0x15e + */ + RPC_ID__Req_GetCoprocessorFwVersion = 350, + /* + *0x15f + */ + RPC_ID__Req_WifiScanGetApRecord = 351, + /* + *0x160 + */ + RPC_ID__Req_SetDhcpDnsStatus = 352, + /* + *0x161 + */ + RPC_ID__Req_GetDhcpDnsStatus = 353, + /* + *0x162 + */ + RPC_ID__Req_WifiStaTwtConfig = 354, + /* + *0x163 + */ + RPC_ID__Req_WifiStaItwtSetup = 355, + /* + *0x164 + */ + RPC_ID__Req_WifiStaItwtTeardown = 356, + /* + *0x165 + */ + RPC_ID__Req_WifiStaItwtSuspend = 357, + /* + *0x166 + */ + RPC_ID__Req_WifiStaItwtGetFlowIdStatus = 358, + /* + *0x167 + */ + RPC_ID__Req_WifiStaItwtSendProbeReq = 359, + /* + *0x168 + */ + RPC_ID__Req_WifiStaItwtSetTargetWakeTimeOffset = 360, + /* + *0x169 + */ + RPC_ID__Req_WifiStaEnterpriseEnable = 361, + /* + *0x16A + */ + RPC_ID__Req_WifiStaEnterpriseDisable = 362, + /* + *0x16B + */ + RPC_ID__Req_EapSetIdentity = 363, + /* + *0x16C + */ + RPC_ID__Req_EapClearIdentity = 364, + /* + *0x16D + */ + RPC_ID__Req_EapSetUsername = 365, + /* + *0x16E + */ + RPC_ID__Req_EapClearUsername = 366, + /* + *0x16F + */ + RPC_ID__Req_EapSetPassword = 367, + /* + *0x170 + */ + RPC_ID__Req_EapClearPassword = 368, + /* + *0x171 + */ + RPC_ID__Req_EapSetNewPassword = 369, + /* + *0x172 + */ + RPC_ID__Req_EapClearNewPassword = 370, + /* + *0x173 + */ + RPC_ID__Req_EapSetCaCert = 371, + /* + *0x174 + */ + RPC_ID__Req_EapClearCaCert = 372, + /* + *0x175 + */ + RPC_ID__Req_EapSetCertificateAndKey = 373, + /* + *0x176 + */ + RPC_ID__Req_EapClearCertificateAndKey = 374, + /* + *0x177 + */ + RPC_ID__Req_EapGetDisableTimeCheck = 375, + /* + *0x178 + */ + RPC_ID__Req_EapSetTtlsPhase2Method = 376, + /* + *0x179 + */ + RPC_ID__Req_EapSetSuitebCertification = 377, + /* + *0x17A + */ + RPC_ID__Req_EapSetPacFile = 378, + /* + *0x17B + */ + RPC_ID__Req_EapSetFastParams = 379, + /* + *0x17C + */ + RPC_ID__Req_EapUseDefaultCertBundle = 380, + /* + *0x17D + */ + RPC_ID__Req_WifiSetOkcSupport = 381, + /* + *0x17E + */ + RPC_ID__Req_EapSetDomainName = 382, + /* + *0x17F + */ + RPC_ID__Req_EapSetDisableTimeCheck = 383, + /* + *0x180 + */ + RPC_ID__Req_EapSetEapMethods = 384, + /* + *0x181 + */ + RPC_ID__Req_IfaceMacAddrSetGet = 385, + /* + *0x182 + */ + RPC_ID__Req_IfaceMacAddrLenGet = 386, + /* + * Common RPC to handle simple feature control with one optional parameter + * Supported Features: + * - BT Init/Deinit/Enable/Disable + */ + /* + *0x183 + */ + RPC_ID__Req_FeatureControl = 387, + /* + * Add new control path command response before Req_Max + * and update Req_Max + */ + /* + *0x184 + */ + RPC_ID__Req_Max = 388, + /* + ** Response Msgs * + */ + RPC_ID__Resp_Base = 512, + RPC_ID__Resp_GetMACAddress = 513, + RPC_ID__Resp_SetMacAddress = 514, + RPC_ID__Resp_GetWifiMode = 515, + RPC_ID__Resp_SetWifiMode = 516, + RPC_ID__Resp_SuppDppInit = 517, + RPC_ID__Resp_SuppDppDeinit = 518, + RPC_ID__Resp_SuppDppBootstrapGen = 519, + RPC_ID__Resp_SuppDppStartListen = 520, + RPC_ID__Resp_SuppDppStopListen = 521, + RPC_ID__Resp_WifiSetPs = 526, + RPC_ID__Resp_WifiGetPs = 527, + RPC_ID__Resp_OTABegin = 528, + RPC_ID__Resp_OTAWrite = 529, + RPC_ID__Resp_OTAEnd = 530, + RPC_ID__Resp_WifiSetMaxTxPower = 531, + RPC_ID__Resp_WifiGetMaxTxPower = 532, + RPC_ID__Resp_ConfigHeartbeat = 533, + RPC_ID__Resp_WifiInit = 534, + RPC_ID__Resp_WifiDeinit = 535, + RPC_ID__Resp_WifiStart = 536, + RPC_ID__Resp_WifiStop = 537, + RPC_ID__Resp_WifiConnect = 538, + RPC_ID__Resp_WifiDisconnect = 539, + RPC_ID__Resp_WifiSetConfig = 540, + RPC_ID__Resp_WifiGetConfig = 541, + RPC_ID__Resp_WifiScanStart = 542, + RPC_ID__Resp_WifiScanStop = 543, + RPC_ID__Resp_WifiScanGetApNum = 544, + RPC_ID__Resp_WifiScanGetApRecords = 545, + RPC_ID__Resp_WifiClearApList = 546, + RPC_ID__Resp_WifiRestore = 547, + RPC_ID__Resp_WifiClearFastConnect = 548, + RPC_ID__Resp_WifiDeauthSta = 549, + RPC_ID__Resp_WifiStaGetApInfo = 550, + /* + *Resp_WifiSetPs = 551; + *Resp_WifiGetPs = 552; + */ + RPC_ID__Resp_WifiSetProtocol = 553, + RPC_ID__Resp_WifiGetProtocol = 554, + RPC_ID__Resp_WifiSetBandwidth = 555, + RPC_ID__Resp_WifiGetBandwidth = 556, + RPC_ID__Resp_WifiSetChannel = 557, + RPC_ID__Resp_WifiGetChannel = 558, + RPC_ID__Resp_WifiSetCountry = 559, + RPC_ID__Resp_WifiGetCountry = 560, + /* + * Resp_WifiSetPromiscuousRxCb = 561; + */ + RPC_ID__Resp_WifiSetPromiscuous = 561, + RPC_ID__Resp_WifiGetPromiscuous = 562, + RPC_ID__Resp_WifiSetPromiscuousFilter = 563, + RPC_ID__Resp_WifiGetPromiscuousFilter = 564, + RPC_ID__Resp_WifiSetPromiscuousCtrlFilter = 565, + RPC_ID__Resp_WifiGetPromiscuousCtrlFilter = 566, + RPC_ID__Resp_WifiApGetStaList = 567, + RPC_ID__Resp_WifiApGetStaAid = 568, + RPC_ID__Resp_WifiSetStorage = 569, + RPC_ID__Resp_WifiSetVendorIe = 570, + /* + * Resp_WifiSetVendorIeCb = 571; + */ + RPC_ID__Resp_WifiSetEventMask = 571, + RPC_ID__Resp_WifiGetEventMask = 572, + RPC_ID__Resp_Wifi80211Tx = 573, + /* + * Resp_WifiSetCsiRxCb = 573; + */ + RPC_ID__Resp_WifiSetCsiConfig = 574, + RPC_ID__Resp_WifiSetCsi = 575, + RPC_ID__Resp_WifiSetAntGpio = 576, + RPC_ID__Resp_WifiGetAntGpio = 577, + RPC_ID__Resp_WifiSetAnt = 578, + RPC_ID__Resp_WifiGetAnt = 579, + RPC_ID__Resp_WifiGetTsfTime = 580, + RPC_ID__Resp_WifiSetInactiveTime = 581, + RPC_ID__Resp_WifiGetInactiveTime = 582, + RPC_ID__Resp_WifiStatisDump = 583, + RPC_ID__Resp_WifiSetRssiThreshold = 584, + RPC_ID__Resp_WifiFtmInitiateSession = 585, + RPC_ID__Resp_WifiFtmEndSession = 586, + RPC_ID__Resp_WifiFtmRespSetOffset = 587, + RPC_ID__Resp_WifiConfig11bRate = 588, + RPC_ID__Resp_WifiConnectionlessModuleSetWakeInterval = 589, + RPC_ID__Resp_WifiSetCountryCode = 590, + RPC_ID__Resp_WifiGetCountryCode = 591, + RPC_ID__Resp_WifiConfig80211TxRate = 592, + RPC_ID__Resp_WifiDisablePmfConfig = 593, + RPC_ID__Resp_WifiStaGetAid = 594, + RPC_ID__Resp_WifiStaGetNegotiatedPhymode = 595, + RPC_ID__Resp_WifiSetDynamicCs = 596, + RPC_ID__Resp_WifiStaGetRssi = 597, + RPC_ID__Resp_WifiSetProtocols = 598, + RPC_ID__Resp_WifiGetProtocols = 599, + RPC_ID__Resp_WifiSetBandwidths = 600, + RPC_ID__Resp_WifiGetBandwidths = 601, + RPC_ID__Resp_WifiSetBand = 602, + RPC_ID__Resp_WifiGetBand = 603, + RPC_ID__Resp_WifiSetBandMode = 604, + RPC_ID__Resp_WifiGetBandMode = 605, + RPC_ID__Resp_GetCoprocessorFwVersion = 606, + RPC_ID__Resp_WifiScanGetApRecord = 607, + RPC_ID__Resp_SetDhcpDnsStatus = 608, + RPC_ID__Resp_GetDhcpDnsStatus = 609, + RPC_ID__Resp_WifiStaTwtConfig = 610, + RPC_ID__Resp_WifiStaItwtSetup = 611, + RPC_ID__Resp_WifiStaItwtTeardown = 612, + RPC_ID__Resp_WifiStaItwtSuspend = 613, + RPC_ID__Resp_WifiStaItwtGetFlowIdStatus = 614, + RPC_ID__Resp_WifiStaItwtSendProbeReq = 615, + RPC_ID__Resp_WifiStaItwtSetTargetWakeTimeOffset = 616, + RPC_ID__Resp_WifiStaEnterpriseEnable = 617, + RPC_ID__Resp_WifiStaEnterpriseDisable = 618, + RPC_ID__Resp_EapSetIdentity = 619, + RPC_ID__Resp_EapClearIdentity = 620, + RPC_ID__Resp_EapSetUsername = 621, + RPC_ID__Resp_EapClearUsername = 622, + RPC_ID__Resp_EapSetPassword = 623, + RPC_ID__Resp_EapClearPassword = 624, + RPC_ID__Resp_EapSetNewPassword = 625, + RPC_ID__Resp_EapClearNewPassword = 626, + RPC_ID__Resp_EapSetCaCert = 627, + RPC_ID__Resp_EapClearCaCert = 628, + RPC_ID__Resp_EapSetCertificateAndKey = 629, + RPC_ID__Resp_EapClearCertificateAndKey = 630, + RPC_ID__Resp_EapGetDisableTimeCheck = 631, + RPC_ID__Resp_EapSetTtlsPhase2Method = 632, + RPC_ID__Resp_EapSetSuitebCertification = 633, + RPC_ID__Resp_EapSetPacFile = 634, + RPC_ID__Resp_EapSetFastParams = 635, + RPC_ID__Resp_EapUseDefaultCertBundle = 636, + RPC_ID__Resp_WifiSetOkcSupport = 637, + RPC_ID__Resp_EapSetDomainName = 638, + RPC_ID__Resp_EapSetDisableTimeCheck = 639, + RPC_ID__Resp_EapSetEapMethods = 640, + RPC_ID__Resp_IfaceMacAddrSetGet = 641, + RPC_ID__Resp_IfaceMacAddrLenGet = 642, + RPC_ID__Resp_FeatureControl = 643, + /* + * Add new control path command response before Resp_Max + * and update Resp_Max + */ + RPC_ID__Resp_Max = 644, + /* + ** Event Msgs * + */ + RPC_ID__Event_Base = 768, + RPC_ID__Event_ESPInit = 769, + RPC_ID__Event_Heartbeat = 770, + RPC_ID__Event_AP_StaConnected = 771, + RPC_ID__Event_AP_StaDisconnected = 772, + RPC_ID__Event_WifiEventNoArgs = 773, + RPC_ID__Event_StaScanDone = 774, + RPC_ID__Event_StaConnected = 775, + RPC_ID__Event_StaDisconnected = 776, + RPC_ID__Event_DhcpDnsStatus = 777, + RPC_ID__Event_StaItwtSetup = 778, + RPC_ID__Event_StaItwtTeardown = 779, + RPC_ID__Event_StaItwtSuspend = 780, + RPC_ID__Event_StaItwtProbe = 781, + /* + * Supplicant DPP Events received by dpp callback on host + */ + RPC_ID__Event_SuppDppUriReady = 782, + RPC_ID__Event_SuppDppCfgRecvd = 783, + RPC_ID__Event_SuppDppFail = 784, + /* + * Wifi DPP Events + */ + RPC_ID__Event_WifiDppUriReady = 785, + RPC_ID__Event_WifiDppCfgRecvd = 786, + RPC_ID__Event_WifiDppFail = 787, + /* + * Add new control path command notification before Event_Max + * and update Event_Max + */ + RPC_ID__Event_Max = 788 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_ID) +} RpcId; + +/* --- messages --- */ + +struct WifiInitConfig +{ + ProtobufCMessage base; + /* + **< WiFi static RX buffer number + */ + int32_t static_rx_buf_num; + /* + **< WiFi dynamic RX buffer number + */ + int32_t dynamic_rx_buf_num; + /* + **< WiFi TX buffer type + */ + int32_t tx_buf_type; + /* + **< WiFi static TX buffer number + */ + int32_t static_tx_buf_num; + /* + **< WiFi dynamic TX buffer number + */ + int32_t dynamic_tx_buf_num; + /* + **< WiFi TX cache buffer number + */ + int32_t cache_tx_buf_num; + /* + **< WiFi channel state information enable flag + */ + int32_t csi_enable; + /* + **< WiFi AMPDU RX feature enable flag + */ + int32_t ampdu_rx_enable; + /* + **< WiFi AMPDU TX feature enable flag + */ + int32_t ampdu_tx_enable; + /* + **< WiFi AMSDU TX feature enable flag + */ + int32_t amsdu_tx_enable; + /* + **< WiFi NVS flash enable flag + */ + int32_t nvs_enable; + /* + **< Nano option for printf/scan family enable flag + */ + int32_t nano_enable; + /* + **< WiFi Block Ack RX window size + */ + int32_t rx_ba_win; + /* + **< WiFi Task Core ID + */ + int32_t wifi_task_core_id; + /* + **< WiFi softAP maximum length of the beacon + */ + int32_t beacon_max_len; + /* + **< WiFi management short buffer number, the minimum value is 6, the maximum value is 32 + */ + int32_t mgmt_sbuf_num; + /* + **< Enables additional WiFi features and capabilities + */ + uint64_t feature_caps; + /* + **< WiFi Power Management for station at disconnected status + */ + protobuf_c_boolean sta_disconnected_pm; + /* + **< Maximum encrypt number of peers supported by espnow + */ + int32_t espnow_max_encrypt_num; + /* + **< WiFi init magic number, it should be the last field + */ + int32_t magic; + /* + **< WiFi RX MGMT buffer type + */ + int32_t rx_mgmt_buf_type; + /* + **< WiFi RX MGMT buffer number + */ + int32_t rx_mgmt_buf_num; + /* + **< WiFi TX HE TB QUEUE number for STA HE TB PPDU transmission + */ + int32_t tx_hetb_queue_num; + /* + **< enable dump sigb field + */ + int32_t dump_hesigb_enable; +}; +#define WIFI_INIT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_init_config__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiCountry +{ + ProtobufCMessage base; + /* + **< country code string of 3 chars + */ + ProtobufCBinaryData cc; + /* + **< start channel + */ + uint32_t schan; + /* + **< total channel number + */ + uint32_t nchan; + /* + **< This field is used for getting WiFi maximum transmitting power, + *call esp_wifi_set_max_tx_power to set the maximum transmitting power. + */ + int32_t max_tx_power; + /* + **< country policy + */ + int32_t policy; +}; +#define WIFI_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_country__descriptor) \ + , {0,NULL}, 0, 0, 0, 0 } + + +struct WifiActiveScanTime +{ + ProtobufCMessage base; + /* + **< minimum active scan time per channel, units: millisecond + */ + uint32_t min; + /* + **< maximum active scan time per channel, units: millisecond, values above 1500ms may + *cause station to disconnect from AP and are not recommended. + */ + uint32_t max; +}; +#define WIFI_ACTIVE_SCAN_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_active_scan_time__descriptor) \ + , 0, 0 } + + +struct WifiScanTime +{ + ProtobufCMessage base; + /* + **< active scan time per channel, units: millisecond. + */ + WifiActiveScanTime *active; + /* + **< passive scan time per channel, units: millisecond, values above 1500ms may + *cause station to disconnect from AP and are not recommended. + */ + uint32_t passive; +}; +#define WIFI_SCAN_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_time__descriptor) \ + , NULL, 0 } + + +struct WifiScanChannelBitmap +{ + ProtobufCMessage base; + /* + **< Represents 2.4 GHz channels, that bits can be set as wifi_2g_channel_bit_t shown. + */ + uint32_t ghz_2_channels; + /* + **< Represents 5 GHz channels, that bits can be set as wifi_5g_channel_bit_t shown. + */ + uint32_t ghz_5_channels; +}; +#define WIFI_SCAN_CHANNEL_BITMAP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_channel_bitmap__descriptor) \ + , 0, 0 } + + +struct WifiScanConfig +{ + ProtobufCMessage base; + /* + **< SSID of AP 33char + */ + ProtobufCBinaryData ssid; + /* + **< MAC address of AP 6char + */ + ProtobufCBinaryData bssid; + /* + **< channel, scan the specific channel + */ + uint32_t channel; + /* + **< enable to scan AP whose SSID is hidden + */ + protobuf_c_boolean show_hidden; + /* + **< scan type, active or passive + */ + int32_t scan_type; + /* + **< scan time per channel + */ + WifiScanTime *scan_time; + /* + **< time spent at home channel between scanning consecutive channels. + */ + uint32_t home_chan_dwell_time; + /* + **< Channel bitmap for setting specific channels to be scanned. + *Please note that the 'channel' parameter above needs to be set to 0 to allow scanning by bitmap. + *Also, note that only allowed channels configured by wifi_country_t can be scanned. + */ + WifiScanChannelBitmap *channel_bitmap; +}; +#define WIFI_SCAN_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_config__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, 0, NULL, 0, NULL } + + +struct WifiHeApInfo +{ + ProtobufCMessage base; + /* + *uint8_t bss_color:6; **< an unsigned integer whose value is the BSS Color of the BSS corresponding to the AP * + *uint8_t partial_bss_color:1; **< indicate if an AID assignment rule based on the BSS color * + *uint8_t bss_color_disabled:1; **< indicate if the use of BSS color is disabled * + */ + /* + * Manually have to parse for above bits + */ + uint32_t bitmask; + /* + **< in M-BSSID set, identifies the nontransmitted BSSID + */ + uint32_t bssid_index; +}; +#define WIFI_HE_AP_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_he_ap_info__descriptor) \ + , 0, 0 } + + +struct WifiApRecord +{ + ProtobufCMessage base; + /* + **< MAC address of AP 6char + */ + ProtobufCBinaryData bssid; + /* + **< SSID of AP 33char + */ + ProtobufCBinaryData ssid; + /* + **< channel of AP + */ + uint32_t primary; + /* + **< secondary channel of AP + */ + int32_t second; + /* + **< signal strength of AP + */ + int32_t rssi; + /* + **< authmode of AP + */ + int32_t authmode; + /* + **< pairwise cipher of AP + */ + int32_t pairwise_cipher; + /* + **< group cipher of AP + */ + int32_t group_cipher; + /* + **< antenna used to receive beacon from AP + */ + int32_t ant; + /* + *uint32_t phy_11b:1; **< bit: 0 flag to identify if 11b mode is enabled or not * + *uint32_t phy_11g:1; **< bit: 1 flag to identify if 11g mode is enabled or not * + *uint32_t phy_11n:1; **< bit: 2 flag to identify if 11n mode is enabled or not * + *uint32_t phy_lr:1; **< bit: 3 flag to identify if low rate is enabled or not * + *uint32_t wps:1; **< bit: 4 flag to identify if WPS is supported or not * + *uint32_t ftm_responder:1; **< bit: 5 flag to identify if FTM is supported in responder mode * + *uint32_t ftm_initiator:1; **< bit: 6 flag to identify if FTM is supported in initiator mode * + *uint32_t reserved:25; **< bit: 7..31 reserved * + */ + /* + * Manually have to parse for above bits + */ + uint32_t bitmask; + /* + **< country information of AP + */ + WifiCountry *country; + WifiHeApInfo *he_ap; + /* + **< For AP 20 MHz this value is set to 1. For AP 40 MHz this value is set to 2. + *For AP 80 MHz this value is set to 3. For AP 160MHz this value is set to 4. + *For AP 80+80MHz this value is set to 5 + */ + uint32_t bandwidth; + /* + **< This fields are used only AP bandwidth is 80 and 160 MHz, to transmit the center channel + *frequency of the BSS. For AP bandwidth is 80 + 80 MHz, it is the center channel frequency + *of the lower frequency segment. + */ + uint32_t vht_ch_freq1; + /* + **< This fields are used only AP bandwidth is 80 + 80 MHz, and is used to transmit the center + *channel frequency of the second segment. + */ + uint32_t vht_ch_freq2; +}; +#define WIFI_AP_RECORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ap_record__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, 0, 0, 0 } + + +struct WifiScanThreshold +{ + ProtobufCMessage base; + /* + **< The minimum rssi to accept in the fast scan mode + */ + int32_t rssi; + /* + **< The weakest authmode to accept in the fast scan mode + *Note: Incase this value is not set and password is set as per WPA2 standards(password len >= 8), + *it will be defaulted to WPA2 and device won't connect to deprecated WEP/WPA networks. + *Please set authmode threshold as WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK to connect to WEP/WPA networks + */ + int32_t authmode; + /* + **< The RSSI value of the 5G AP is within the rssi_5g_adjustment range compared to the 2G AP, the 5G AP will be given priority for connection. + */ + uint32_t rssi_5g_adjustment; +}; +#define WIFI_SCAN_THRESHOLD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_threshold__descriptor) \ + , 0, 0, 0 } + + +struct WifiPmfConfig +{ + ProtobufCMessage base; + /* + **< Deprecated variable. Device will always connect in PMF mode if other device also advertizes PMF capability. + */ + protobuf_c_boolean capable; + /* + **< Advertizes that Protected Management Frame is required. Device will not associate to non-PMF capable devices. + */ + protobuf_c_boolean required; +}; +#define WIFI_PMF_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_pmf_config__descriptor) \ + , 0, 0 } + + +struct WifiBssMaxIdleConfig +{ + ProtobufCMessage base; + /* + **< Sets BSS Max idle period (1 Unit = 1000TUs OR 1.024 Seconds). If there are no frames for this period from a STA, SoftAP will disassociate due to inactivity. Setting it to 0 disables the feature + */ + uint32_t period; + /* + **< Requires clients to use protected keep alive frames for BSS Max Idle period + */ + protobuf_c_boolean protected_keep_alive; +}; +#define WIFI_BSS_MAX_IDLE_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_bss_max_idle_config__descriptor) \ + , 0, 0 } + + +struct WifiApConfig +{ + ProtobufCMessage base; + /* + **< SSID of ESP32 soft-AP. If ssid_len field is 0, this must be a Null terminated string. Otherwise, length is set according to ssid_len. 32 char + */ + ProtobufCBinaryData ssid; + /* + **< Password of ESP32 soft-AP. 64 char + */ + ProtobufCBinaryData password; + /* + **< Optional length of SSID field. + */ + uint32_t ssid_len; + /* + **< Channel of ESP32 soft-AP + */ + uint32_t channel; + /* + **< Auth mode of ESP32 soft-AP. Do not support AUTH_WEP in soft-AP mode + */ + int32_t authmode; + /* + **< Broadcast SSID or not, default 0, broadcast the SSID + */ + uint32_t ssid_hidden; + /* + **< Max number of stations allowed to connect in + */ + uint32_t max_connection; + /* + **< Beacon interval which should be multiples of 100. Unit: TU(time unit, 1 TU = 1024 us). Range: 100 ~ 60000. Default value: 100 + */ + uint32_t beacon_interval; + /* + **< pairwise cipher of SoftAP, group cipher will be derived using this. + *cipher values are valid starting from WIFI_CIPHER_TYPE_TKIP, enum values before that will be considered as invalid and default cipher suites(TKIP+CCMP) will be used. + *Valid cipher suites in softAP mode are WIFI_CIPHER_TYPE_TKIP, WIFI_CIPHER_TYPE_CCMP and WIFI_CIPHER_TYPE_TKIP_CCMP. + */ + int32_t pairwise_cipher; + /* + **< Enable FTM Responder mode + */ + protobuf_c_boolean ftm_responder; + /* + **< Configuration for Protected Management Frame + */ + WifiPmfConfig *pmf_cfg; + /* + **< Configuration for SAE PWE derivation method + */ + int32_t sae_pwe_h2e; + /* + **< Channel Switch Announcement Count. Notify the station that the channel will switch after the csa_count beacon intervals. Default value: 3 + */ + uint32_t csa_count; + /* + **< Dtim period of soft-AP. Range: 1 ~ 10. Default value: 1 + */ + uint32_t dtim_period; + /* + **< Whether to enable transition disable feature + */ + uint32_t transition_disable; + /* + **< Enable SAE EXT feature. SOC_GCMP_SUPPORT is required for this feature. + */ + uint32_t sae_ext; + /* + **< Configuration for bss max idle, effective if CONFIG_WIFI_BSS_MAX_IDLE_SUPPORT is enabled + */ + WifiBssMaxIdleConfig *bss_max_idle_cfg; + /* + **< GTK rekeying interval in seconds. If set to 0, GTK rekeying is disabled. Range: 60 ~ 65535 including 0. + */ + uint32_t gtk_rekey_interval; +}; +#define WIFI_AP_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ap_config__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, NULL, 0 } + + +struct WifiStaConfig +{ + ProtobufCMessage base; + /* + **< SSID of target AP. 32char + */ + ProtobufCBinaryData ssid; + /* + **< Password of target AP. 64char + */ + ProtobufCBinaryData password; + /* + **< do all channel scan or fast scan + */ + int32_t scan_method; + /* + **< whether set MAC address of target AP or not. Generally, station_config.bssid_set needs to be 0, + *and it needs to be 1 only when users need to check the MAC address of the AP. + */ + protobuf_c_boolean bssid_set; + /* + **< MAC address of target AP 6char + */ + ProtobufCBinaryData bssid; + /* + **< channel of target AP. Set to 1~13 to scan starting from the specified channel + *before connecting to AP. If the channel of AP is unknown, set it to 0. + */ + uint32_t channel; + /* + **< Listen interval for ESP32 station to receive beacon when WIFI_PS_MAX_MODEM is set. + *Units: AP beacon intervals. Defaults to 3 if set to 0. + */ + uint32_t listen_interval; + /* + **< sort the connect AP in the list by rssi or security mode + */ + int32_t sort_method; + /* + **< When sort_method is set, only APs which have an auth mode that is more secure + *than the selected auth mode and a signal stronger than the minimum RSSI will be used. + */ + WifiScanThreshold *threshold; + /* + **< Configuration for Protected Management Frame. Will be advertized in RSN Capabilities in RSN IE. + */ + WifiPmfConfig *pmf_cfg; + /* + *uint32_t rm_enabled:1; **< Whether Radio Measurements are enabled for the connection * + *uint32_t btm_enabled:1; **< Whether BSS Transition Management is enabled for the connection * + *uint32_t mbo_enabled:1; **< Whether MBO is enabled for the connection * + *uint32_t ft_enabled:1; **< Whether FT is enabled for the connection * + *uint32_t owe_enabled:1; **< Whether OWE is enabled for the connection * + *uint32_t transition_disable:1; **< Whether to enable transition disable feature * + *uint32_t reserved:26; **< Reserved for future feature set * + */ + uint32_t bitmask; + /* + **< Whether SAE hash to element is enabled + */ + int32_t sae_pwe_h2e; + /* + **< Number of connection retries station will do before moving to next AP. + *scan_method should be set as WIFI_ALL_CHANNEL_SCAN to use this config. + *Note: Enabling this may cause connection time to increase incase best AP doesn't behave properly. + */ + uint32_t failure_retry_cnt; + /* + *uint32_t he_dcm_set:1; **< Whether DCM max.constellation for transmission and reception is set. * + *uint32_t he_dcm_max_constellation_tx:2; **< Indicate the max.constellation for DCM in TB PPDU the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. * + *uint32_t he_dcm_max_constellation_rx:2; **< Indicate the max.constellation for DCM in both Data field and HE-SIG-B field the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. * + *uint32_t he_mcs9_enabled:1; **< Whether to support HE-MCS 0 to 9. The default value is 0. * + *uint32_t he_su_beamformee_disabled:1; **< Whether to disable support for operation as an SU beamformee. * + *uint32_t he_trig_su_bmforming_feedback_disabled:1; **< Whether to disable support the transmission of SU feedback in an HE TB sounding sequence. * + *uint32_t he_trig_mu_bmforming_partial_feedback_disabled:1; **< Whether to disable support the transmission of partial-bandwidth MU feedback in an HE TB sounding sequence. * + * uint32_t he_trig_cqi_feedback_disabled:1; **< Whether to disable support the transmission of CQI feedback in an HE TB sounding sequence. * + * uint32_t vht_su_beamformee_disabled: 1; **< Whether to disable support for operation as an VHT SU beamformee. * + * uint32_t vht_mu_beamformee_disabled: 1; **< Whether to disable support for operation as an VHT MU beamformee. * + * uint32_t vht_mcs8_enabled: 1; **< Whether to support VHT-MCS8. The default value is 0. * + * uint32_t he_reserved:19; **< Reserved for future feature set * + */ + uint32_t he_bitmask; + /* + **< Password identifier for H2E. this needs to be null terminated string. SAE_H2E_IDENTIFIER_LEN chars + */ + ProtobufCBinaryData sae_h2e_identifier; + /* + **< Configuration for SAE-PK (Public Key) Authentication method + */ + uint32_t sae_pk_mode; +}; +#define WIFI_STA_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_config__descriptor) \ + , {0,NULL}, {0,NULL}, 0, 0, {0,NULL}, 0, 0, 0, NULL, NULL, 0, 0, 0, 0, {0,NULL}, 0 } + + +typedef enum { + WIFI_CONFIG__U__NOT_SET = 0, + WIFI_CONFIG__U_AP = 1, + WIFI_CONFIG__U_STA = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(WIFI_CONFIG__U__CASE) +} WifiConfig__UCase; + +struct WifiConfig +{ + ProtobufCMessage base; + WifiConfig__UCase u_case; + union { + /* + **< configuration of AP + */ + WifiApConfig *ap; + /* + **< configuration of STA + */ + WifiStaConfig *sta; + }; +}; +#define WIFI_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_config__descriptor) \ + , WIFI_CONFIG__U__NOT_SET, {0} } + + +struct WifiStaInfo +{ + ProtobufCMessage base; + /* + **< mac address 6 char + */ + ProtobufCBinaryData mac; + /* + **< current average rssi of sta connected + */ + int32_t rssi; + /* + *uint32_t phy_11b:1; **< bit: 0 flag to identify if 11b mode is enabled or not * + *uint32_t phy_11g:1; **< bit: 1 flag to identify if 11g mode is enabled or not * + *uint32_t phy_11n:1; **< bit: 2 flag to identify if 11n mode is enabled or not * + *uint32_t phy_lr:1; **< bit: 3 flag to identify if low rate is enabled or not * + *uint32_t phy_11x:1; **< bit: 4 flag to identify identify if 11ax mode is enabled or not * + *uint32_t is_mesh_child:1; **< bit: 5 flag to identify mesh child * + *uint32_t reserved:26; **< bit: 6..31 reserved * + */ + uint32_t bitmask; +}; +#define WIFI_STA_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_info__descriptor) \ + , {0,NULL}, 0, 0 } + + +struct WifiStaList +{ + ProtobufCMessage base; + /* + **< station list + */ + size_t n_sta; + WifiStaInfo **sta; + /* + **< number of stations in the list (other entries are invalid) + */ + int32_t num; +}; +#define WIFI_STA_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_list__descriptor) \ + , 0,NULL, 0 } + + +struct WifiPktRxCtrl +{ + ProtobufCMessage base; + /* + **< 8bits Received Signal Strength Indicator(RSSI) of packet. unit: dBm + */ + int32_t rssi; + /* + **< 5bits PHY rate encoding of the packet. Only valid for non HT(11bg) packet + */ + uint32_t rate; + /* + *uint32 :1; **< reserved * + */ + /* + **< 2bits 0: non HT(11bg) packet; 1: HT(11n) packet; 3: VHT(11ac) packet + */ + uint32_t sig_mode; + /* + *uint32 :16; **< reserved * + */ + /* + **< 7bits Modulation Coding Scheme. If is HT(11n) packet, shows the modulation, range from 0 to 76(MSC0 ~ MCS76) + */ + uint32_t mcs; + /* + **< 1bit Channel Bandwidth of the packet. 0: 20MHz; 1: 40MHz + */ + uint32_t cwb; + /* + *uint32 :16; **< reserved * + */ + /* + **< 1bit reserved + */ + uint32_t smoothing; + /* + **< 1bit reserved + */ + uint32_t not_sounding; + /* + *uint32 :1; **< reserved * + */ + /* + **< 1bit Aggregation. 0: MPDU packet; 1: AMPDU packet + */ + uint32_t aggregation; + /* + **< 2bits Space Time Block Code(STBC). 0: non STBC packet; 1: STBC packet + */ + uint32_t stbc; + /* + **< 1bit Flag is set for 11n packets which are LDPC + */ + uint32_t fec_coding; + /* + **< 1bit Short Guide Interval(SGI). 0: Long GI; 1: Short GI + */ + uint32_t sgi; + /* + **< 8bits noise floor of Radio Frequency Module(RF). unit: dBm + */ + int32_t noise_floor; + /* + **< 8bits ampdu cnt + */ + uint32_t ampdu_cnt; + /* + **< 4bits primary channel on which this packet is received + */ + uint32_t channel; + /* + **< 4bits secondary channel on which this packet is received. 0: none; 1: above; 2: below + */ + uint32_t secondary_channel; + /* + *uint32 :8; **< reserved * + */ + /* + **< 32bit timestamp. The local time when this packet is received. It is precise only if modem sleep or light sleep is not enabled. unit: microsecond + */ + uint32_t timestamp; + /* + *uint32 :32; **< reserved * + *unsigned :32; **< reserved * + *unsigned :31; **< reserved * + */ + /* + **< 1bit antenna number from which this packet is received. 0: WiFi antenna 0; 1: WiFi antenna 1 + */ + uint32_t ant; + /* + **< 12bits length of packet including Frame Check Sequence(FCS) + */ + uint32_t sig_len; + /* + *unsigned :12; **< reserved * + */ + /* + **< 8bits state of the packet. 0: no error; others: error numbers which are not public + */ + uint32_t rx_state; +}; +#define WIFI_PKT_RX_CTRL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_pkt_rx_ctrl__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiPromiscuousPkt +{ + ProtobufCMessage base; + /* + **< metadata header + */ + WifiPktRxCtrl *rx_ctrl; + /* + **< Note: variable length. Data or management payload. Length of payload is described by rx_ctrl.sig_len. Type of content determined by packet type argument of callback. + */ + ProtobufCBinaryData payload; +}; +#define WIFI_PROMISCUOUS_PKT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_promiscuous_pkt__descriptor) \ + , NULL, {0,NULL} } + + +struct WifiPromiscuousFilter +{ + ProtobufCMessage base; + /* + **< OR of one or more filter values WIFI_PROMIS_FILTER_* + */ + uint32_t filter_mask; +}; +#define WIFI_PROMISCUOUS_FILTER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_promiscuous_filter__descriptor) \ + , 0 } + + +struct WifiCsiConfig +{ + ProtobufCMessage base; + /* + **< enable to receive legacy long training field(lltf) data. Default enabled + */ + protobuf_c_boolean lltf_en; + /* + **< enable to receive HT long training field(htltf) data. Default enabled + */ + protobuf_c_boolean htltf_en; + /* + **< enable to receive space time block code HT long training field(stbc-htltf2) data. Default enabled + */ + protobuf_c_boolean stbc_htltf2_en; + /* + **< enable to generate htlft data by averaging lltf and ht_ltf data when receiving HT packet. Otherwise, use ht_ltf data directly. Default enabled + */ + protobuf_c_boolean ltf_merge_en; + /* + **< enable to turn on channel filter to smooth adjacent sub-carrier. Disable it to keep independence of adjacent sub-carrier. Default enabled + */ + protobuf_c_boolean channel_filter_en; + /* + **< manually scale the CSI data by left shifting or automatically scale the CSI data. + *If set true, please set the shift bits. false: automatically. true: manually. Default false + */ + protobuf_c_boolean manu_scale; + /* + **< manually left shift bits of the scale of the CSI data. The range of the left shift bits is 0~15 + */ + uint32_t shift; +}; +#define WIFI_CSI_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_csi_config__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiCsiInfo +{ + ProtobufCMessage base; + /* + **< received packet radio metadata header of the CSI data + */ + WifiPktRxCtrl *rx_ctrl; + /* + **< 6bits source MAC address of the CSI data + */ + ProtobufCBinaryData mac; + /* + **< 6bits destination MAC address of the CSI data + */ + ProtobufCBinaryData dmac; + /* + **< first four bytes of the CSI data is invalid or not + */ + protobuf_c_boolean first_word_invalid; + /* + **< Note: variable length. buffer of CSI data + */ + ProtobufCBinaryData buf; + /* + **< length of CSI data + */ + uint32_t len; +}; +#define WIFI_CSI_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_csi_info__descriptor) \ + , NULL, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0 } + + +struct WifiAntGpio +{ + ProtobufCMessage base; + /* + **< 1bit Whether this GPIO is connected to external antenna switch + */ + uint32_t gpio_select; + /* + **< 7bits The GPIO number that connects to external antenna switch + */ + uint32_t gpio_num; +}; +#define WIFI_ANT_GPIO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_gpio__descriptor) \ + , 0, 0 } + + +struct WifiAntGpioConfig +{ + ProtobufCMessage base; + /* + **< The configurations of GPIOs that connect to external antenna switch + */ + size_t n_gpio_cfgs; + WifiAntGpio **gpio_cfgs; +}; +#define WIFI_ANT_GPIO_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_gpio_config__descriptor) \ + , 0,NULL } + + +struct WifiAntConfig +{ + ProtobufCMessage base; + /* + **< WiFi antenna mode for receiving + */ + int32_t rx_ant_mode; + /* + **< Default antenna mode for receiving, it's ignored if rx_ant_mode is not WIFI_ANT_MODE_AUTO + */ + int32_t rx_ant_default; + /* + **< WiFi antenna mode for transmission, it can be set to WIFI_ANT_MODE_AUTO only if rx_ant_mode is set to WIFI_ANT_MODE_AUTO + */ + int32_t tx_ant_mode; + /* + **< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT0 + */ + uint32_t enabled_ant0; + /* + **< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT1 + */ + uint32_t enabled_ant1; +}; +#define WIFI_ANT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_config__descriptor) \ + , 0, 0, 0, 0, 0 } + + +struct WifiActionTxReq +{ + ProtobufCMessage base; + /* + **< WiFi interface to send request to + */ + int32_t ifx; + /* + **< 6bits Destination MAC address + */ + ProtobufCBinaryData dest_mac; + /* + **< Indicates no ack required + */ + protobuf_c_boolean no_ack; + /* + *TODO + *wifi_action_rx_cb_t rx_cb; **< Rx Callback to receive any response * + */ + /* + **< Length of the appended Data + */ + uint32_t data_len; + /* + **< note: variable length. Appended Data payload + */ + ProtobufCBinaryData data; +}; +#define WIFI_ACTION_TX_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_action_tx_req__descriptor) \ + , 0, {0,NULL}, 0, 0, {0,NULL} } + + +struct WifiFtmInitiatorCfg +{ + ProtobufCMessage base; + /* + **< 6bits MAC address of the FTM Responder + */ + ProtobufCBinaryData resp_mac; + /* + **< Primary channel of the FTM Responder + */ + uint32_t channel; + /* + **< No. of FTM frames requested in terms of 4 or 8 bursts (allowed values - 0(No pref), 16, 24, 32, 64) + */ + uint32_t frm_count; + /* + **< Requested time period between consecutive FTM bursts in 100's of milliseconds (0 - No pref) + */ + uint32_t burst_period; +}; +#define WIFI_FTM_INITIATOR_CFG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ftm_initiator_cfg__descriptor) \ + , {0,NULL}, 0, 0, 0 } + + +struct WifiEventStaScanDone +{ + ProtobufCMessage base; + /* + **< status of scanning APs: 0 — success, 1 - failure + */ + uint32_t status; + /* + **< number of scan results + */ + uint32_t number; + /* + **< scan sequence number, used for block scan + */ + uint32_t scan_id; +}; +#define WIFI_EVENT_STA_SCAN_DONE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_scan_done__descriptor) \ + , 0, 0, 0 } + + +struct WifiEventStaConnected +{ + ProtobufCMessage base; + /* + **< 32bytes SSID of connected AP + */ + ProtobufCBinaryData ssid; + /* + **< SSID length of connected AP + */ + uint32_t ssid_len; + /* + **< 6bytes BSSID of connected AP + */ + ProtobufCBinaryData bssid; + /* + **< channel of connected AP + */ + uint32_t channel; + /* + **< authentication mode used by AP + */ + int32_t authmode; + /* + **< authentication id assigned by the connected AP + */ + int32_t aid; +}; +#define WIFI_EVENT_STA_CONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_connected__descriptor) \ + , {0,NULL}, 0, {0,NULL}, 0, 0, 0 } + + +struct WifiEventStaDisconnected +{ + ProtobufCMessage base; + /* + **< SSID of disconnected AP + */ + ProtobufCBinaryData ssid; + /* + **< SSID length of disconnected AP + */ + uint32_t ssid_len; + /* + **< BSSID of disconnected AP + */ + ProtobufCBinaryData bssid; + /* + **< reason of disconnection + */ + uint32_t reason; + /* + **< rssi of disconnection + */ + int32_t rssi; +}; +#define WIFI_EVENT_STA_DISCONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_disconnected__descriptor) \ + , {0,NULL}, 0, {0,NULL}, 0, 0 } + + +struct WifiEventStaAuthmodeChange +{ + ProtobufCMessage base; + /* + **< the old auth mode of AP + */ + int32_t old_mode; + /* + **< the new auth mode of AP + */ + int32_t new_mode; +}; +#define WIFI_EVENT_STA_AUTHMODE_CHANGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_authmode_change__descriptor) \ + , 0, 0 } + + +struct WifiEventStaWpsErPin +{ + ProtobufCMessage base; + /* + **< 8bytes PIN code of station in enrollee mode + */ + ProtobufCBinaryData pin_code; +}; +#define WIFI_EVENT_STA_WPS_ER_PIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_wps_er_pin__descriptor) \ + , {0,NULL} } + + +struct ApCred +{ + ProtobufCMessage base; + /* + **< 32bytes SSID of AP + */ + ProtobufCBinaryData ssid; + /* + **< 64bytes Passphrase for the AP + */ + ProtobufCBinaryData passphrase; +}; +#define AP_CRED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ap_cred__descriptor) \ + , {0,NULL}, {0,NULL} } + + +struct WifiEventStaWpsErSuccess +{ + ProtobufCMessage base; + /* + **< Number of AP credentials received + */ + uint32_t ap_cred_cnt; + /* + **< All AP credentials received from WPS handshake + */ + size_t n_ap_creds; + ApCred **ap_creds; +}; +#define WIFI_EVENT_STA_WPS_ER_SUCCESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_wps_er_success__descriptor) \ + , 0, 0,NULL } + + +/* + ** Argument structure for WIFI_EVENT_AP_PROBEREQRECVED event + */ +struct WifiEventApProbeReqRx +{ + ProtobufCMessage base; + /* + **< Received probe request signal strength + */ + int32_t rssi; + /* + **< MAC address of the station which send probe request + */ + uint32_t mac; +}; +#define WIFI_EVENT_AP_PROBE_REQ_RX__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_probe_req_rx__descriptor) \ + , 0, 0 } + + +/* + ** Argument structure for WIFI_EVENT_STA_BSS_RSSI_LOW event + */ +struct WifiEventBssRssiLow +{ + ProtobufCMessage base; + /* + **< RSSI value of bss + */ + int32_t rssi; +}; +#define WIFI_EVENT_BSS_RSSI_LOW__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_bss_rssi_low__descriptor) \ + , 0 } + + +struct WifiFtmReportEntry +{ + ProtobufCMessage base; + /* + * *< Dialog Token of the FTM frame + */ + uint32_t dlog_token; + /* + * *< RSSI of the FTM frame received + */ + int32_t rssi; + /* + * *< Round Trip Time in pSec with a peer + */ + uint32_t rtt; + /* + * TODO: uint32 is supported by proto? + */ + /* + * *< Time of departure of FTM frame from FTM Responder in pSec + */ + uint64_t t1; + /* + * *< Time of arrival of FTM frame at FTM Initiator in pSec + */ + uint64_t t2; + /* + * *< Time of departure of ACK from FTM Initiator in pSec + */ + uint64_t t3; + /* + * *< Time of arrival of ACK at FTM Responder in pSec + */ + uint64_t t4; +}; +#define WIFI_FTM_REPORT_ENTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_ftm_report_entry__descriptor) \ + , 0, 0, 0, 0, 0, 0, 0 } + + +struct WifiEventFtmReport +{ + ProtobufCMessage base; + /* + * *< 6bytes MAC address of the FTM Peer + */ + ProtobufCBinaryData peer_mac; + /* + * *< Status of the FTM operation + */ + int32_t status; + /* + * *< Raw average Round-Trip-Time with peer in Nano-Seconds + */ + uint32_t rtt_raw; + /* + * *< Estimated Round-Trip-Time with peer in Nano-Seconds + */ + uint32_t rtt_est; + /* + * *< Estimated one-way distance in Centi-Meters + */ + uint32_t dist_est; + /* + * *< Note var len Pointer to FTM Report with multiple entries, should be freed after use + */ + size_t n_ftm_report_data; + WifiFtmReportEntry **ftm_report_data; + /* + * *< Number of entries in the FTM Report data + */ + uint32_t ftm_report_num_entries; +}; +#define WIFI_EVENT_FTM_REPORT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ftm_report__descriptor) \ + , {0,NULL}, 0, 0, 0, 0, 0,NULL, 0 } + + +struct WifiEventActionTxStatus +{ + ProtobufCMessage base; + /* + **< WiFi interface to send request to + */ + int32_t ifx; + /* + **< Context to identify the request + */ + uint32_t context; + /* + **< 6bytes Destination MAC address + */ + ProtobufCBinaryData da; + /* + **< Status of the operation + */ + uint32_t status; +}; +#define WIFI_EVENT_ACTION_TX_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_action_tx_status__descriptor) \ + , 0, 0, {0,NULL}, 0 } + + +struct WifiEventRocDone +{ + ProtobufCMessage base; + /* + **< Context to identify the request + */ + uint32_t context; +}; +#define WIFI_EVENT_ROC_DONE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_roc_done__descriptor) \ + , 0 } + + +struct WifiEventApWpsRgPin +{ + ProtobufCMessage base; + /* + **< 8bytes PIN code of station in enrollee mode + */ + ProtobufCBinaryData pin_code; +}; +#define WIFI_EVENT_AP_WPS_RG_PIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_pin__descriptor) \ + , {0,NULL} } + + +struct WifiEventApWpsRgFailReason +{ + ProtobufCMessage base; + /* + **< WPS failure reason wps_fail_reason_t + */ + int32_t reason; + /* + **< 6bytes Enrollee mac address + */ + ProtobufCBinaryData peer_macaddr; +}; +#define WIFI_EVENT_AP_WPS_RG_FAIL_REASON__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_fail_reason__descriptor) \ + , 0, {0,NULL} } + + +struct WifiEventApWpsRgSuccess +{ + ProtobufCMessage base; + /* + **< 6bytes Enrollee mac address + */ + ProtobufCBinaryData peer_macaddr; +}; +#define WIFI_EVENT_AP_WPS_RG_SUCCESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_success__descriptor) \ + , {0,NULL} } + + +struct WifiProtocols +{ + ProtobufCMessage base; + /* + **< Represents 2.4 GHz protocol, support 802.11b or 802.11g or 802.11n or 802.11ax or LR mode + */ + uint32_t ghz_2g; + /* + **< Represents 5 GHz protocol, support 802.11a or 802.11n or 802.11ac or 802.11ax + */ + uint32_t ghz_5g; +}; +#define WIFI_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_protocols__descriptor) \ + , 0, 0 } + + +struct WifiBandwidths +{ + ProtobufCMessage base; + /* + * Represents 2.4 GHz bandwidth + */ + uint32_t ghz_2g; + /* + * Represents 5 GHz bandwidth + */ + uint32_t ghz_5g; +}; +#define WIFI_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_bandwidths__descriptor) \ + , 0, 0 } + + +struct WifiItwtSetupConfig +{ + ProtobufCMessage base; + uint32_t setup_cmd; + /* + * uint16_t trigger : 1; **< 1: a trigger-enabled individual TWT, 0: a non-trigger-enabled individual TWT * + * uint16_t flow_type : 1; **< 0: an announced individual TWT, 1: an unannounced individual TWT * + * uint16_t flow_id : 3; **< When set up an individual TWT agreement, the flow id will be assigned by AP after a successful agreement setup. + * flow_id could be specified to a value in the range of [0, 7], but it might be changed by AP in the response. + * When change TWT parameters of the existing TWT agreement, flow_id should be an existing one. The value range is [0, 7]. * + * uint16_t wake_invl_expn : 5; **< Individual TWT Wake Interval Exponent. The value range is [0, 31]. * + * uint16_t wake_duration_unit : 1; **< Individual TWT Wake duration unit, 0: 256us 1: TU (TU = 1024us)* + * uint16_t reserved : 5; **< bit: 11.15 reserved * + */ + uint32_t bitmask_1; + uint32_t min_wake_dura; + uint32_t wake_invl_mant; + uint32_t twt_id; + uint32_t timeout_time_ms; +}; +#define WIFI_ITWT_SETUP_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_itwt_setup_config__descriptor) \ + , 0, 0, 0, 0, 0, 0 } + + +struct WifiTwtConfig +{ + ProtobufCMessage base; + /* + **< post twt wakeup event + */ + protobuf_c_boolean post_wakeup_event; + /* + **< twt enable send qos null to keep alive + */ + protobuf_c_boolean twt_enable_keep_alive; +}; +#define WIFI_TWT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&wifi_twt_config__descriptor) \ + , 0, 0 } + + +struct ConnectedSTAList +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; + int32_t rssi; +}; +#define CONNECTED_STALIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&connected_stalist__descriptor) \ + , {0,NULL}, 0 } + + +struct EapFastConfig +{ + ProtobufCMessage base; + /* + * Enable or disable Fast Provisioning in EAP-FAST (0 = disabled, 1 = enabled) + */ + int32_t fast_provisioning; + /* + * Maximum length of the PAC (Protected Access Credential) list + */ + int32_t fast_max_pac_list_len; + /* + * Set to true for binary format PAC, false for ASCII format PAC + */ + protobuf_c_boolean fast_pac_format_binary; +}; +#define EAP_FAST_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eap_fast_config__descriptor) \ + , 0, 0, 0 } + + +/* + ** Req/Resp structure * + */ +struct RpcReqGetMacAddress +{ + ProtobufCMessage base; + int32_t mode; +}; +#define RPC__REQ__GET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_mac_address__descriptor) \ + , 0 } + + +struct RpcRespGetMacAddress +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; + int32_t resp; +}; +#define RPC__RESP__GET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_mac_address__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcReqGetMode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__GET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_mode__descriptor) \ + } + + +struct RpcRespGetMode +{ + ProtobufCMessage base; + int32_t mode; + int32_t resp; +}; +#define RPC__RESP__GET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_mode__descriptor) \ + , 0, 0 } + + +struct RpcReqSetMode +{ + ProtobufCMessage base; + int32_t mode; +}; +#define RPC__REQ__SET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_mode__descriptor) \ + , 0 } + + +struct RpcRespSetMode +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_mode__descriptor) \ + , 0 } + + +struct RpcReqGetPs +{ + ProtobufCMessage base; +}; +#define RPC__REQ__GET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_ps__descriptor) \ + } + + +struct RpcRespGetPs +{ + ProtobufCMessage base; + int32_t resp; + int32_t type; +}; +#define RPC__RESP__GET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_ps__descriptor) \ + , 0, 0 } + + +struct RpcReqSetPs +{ + ProtobufCMessage base; + int32_t type; +}; +#define RPC__REQ__SET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_ps__descriptor) \ + , 0 } + + +struct RpcRespSetPs +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_PS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_ps__descriptor) \ + , 0 } + + +struct RpcReqSetMacAddress +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; + int32_t mode; +}; +#define RPC__REQ__SET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_mac_address__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespSetMacAddress +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_MAC_ADDRESS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_mac_address__descriptor) \ + , 0 } + + +struct RpcReqOTABegin +{ + ProtobufCMessage base; +}; +#define RPC__REQ__OTABEGIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otabegin__descriptor) \ + } + + +struct RpcRespOTABegin +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__OTABEGIN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otabegin__descriptor) \ + , 0 } + + +struct RpcReqOTAWrite +{ + ProtobufCMessage base; + ProtobufCBinaryData ota_data; +}; +#define RPC__REQ__OTAWRITE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otawrite__descriptor) \ + , {0,NULL} } + + +struct RpcRespOTAWrite +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__OTAWRITE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otawrite__descriptor) \ + , 0 } + + +struct RpcReqOTAEnd +{ + ProtobufCMessage base; +}; +#define RPC__REQ__OTAEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otaend__descriptor) \ + } + + +struct RpcRespOTAEnd +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__OTAEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otaend__descriptor) \ + , 0 } + + +struct RpcReqWifiSetMaxTxPower +{ + ProtobufCMessage base; + int32_t power; +}; +#define RPC__REQ__WIFI_SET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_max_tx_power__descriptor) \ + , 0 } + + +struct RpcRespWifiSetMaxTxPower +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_max_tx_power__descriptor) \ + , 0 } + + +struct RpcReqWifiGetMaxTxPower +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_max_tx_power__descriptor) \ + } + + +struct RpcRespWifiGetMaxTxPower +{ + ProtobufCMessage base; + int32_t power; + int32_t resp; +}; +#define RPC__RESP__WIFI_GET_MAX_TX_POWER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_max_tx_power__descriptor) \ + , 0, 0 } + + +struct RpcReqConfigHeartbeat +{ + ProtobufCMessage base; + protobuf_c_boolean enable; + int32_t duration; +}; +#define RPC__REQ__CONFIG_HEARTBEAT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__config_heartbeat__descriptor) \ + , 0, 0 } + + +struct RpcRespConfigHeartbeat +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__CONFIG_HEARTBEAT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__config_heartbeat__descriptor) \ + , 0 } + + +struct RpcReqWifiInit +{ + ProtobufCMessage base; + WifiInitConfig *cfg; +}; +#define RPC__REQ__WIFI_INIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_init__descriptor) \ + , NULL } + + +struct RpcRespWifiInit +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_INIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_init__descriptor) \ + , 0 } + + +struct RpcReqWifiDeinit +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_DEINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_deinit__descriptor) \ + } + + +struct RpcRespWifiDeinit +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_DEINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_deinit__descriptor) \ + , 0 } + + +struct RpcReqWifiSetConfig +{ + ProtobufCMessage base; + int32_t iface; + WifiConfig *cfg; +}; +#define RPC__REQ__WIFI_SET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_config__descriptor) \ + , 0, NULL } + + +struct RpcRespWifiSetConfig +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_config__descriptor) \ + , 0 } + + +struct RpcReqWifiGetConfig +{ + ProtobufCMessage base; + int32_t iface; +}; +#define RPC__REQ__WIFI_GET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_config__descriptor) \ + , 0 } + + +struct RpcRespWifiGetConfig +{ + ProtobufCMessage base; + int32_t resp; + int32_t iface; + WifiConfig *cfg; +}; +#define RPC__RESP__WIFI_GET_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_config__descriptor) \ + , 0, 0, NULL } + + +struct RpcReqWifiConnect +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_connect__descriptor) \ + } + + +struct RpcRespWifiConnect +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_connect__descriptor) \ + , 0 } + + +struct RpcReqWifiDisconnect +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_DISCONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_disconnect__descriptor) \ + } + + +struct RpcRespWifiDisconnect +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_DISCONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_disconnect__descriptor) \ + , 0 } + + +struct RpcReqWifiStart +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_start__descriptor) \ + } + + +struct RpcRespWifiStart +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_start__descriptor) \ + , 0 } + + +struct RpcReqWifiStop +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_stop__descriptor) \ + } + + +struct RpcRespWifiStop +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_stop__descriptor) \ + , 0 } + + +struct RpcReqWifiScanStart +{ + ProtobufCMessage base; + WifiScanConfig *config; + protobuf_c_boolean block; + int32_t config_set; +}; +#define RPC__REQ__WIFI_SCAN_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_start__descriptor) \ + , NULL, 0, 0 } + + +struct RpcRespWifiScanStart +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SCAN_START__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_start__descriptor) \ + , 0 } + + +struct RpcReqWifiScanStop +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_SCAN_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_stop__descriptor) \ + } + + +struct RpcRespWifiScanStop +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SCAN_STOP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_stop__descriptor) \ + , 0 } + + +struct RpcReqWifiScanGetApNum +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_SCAN_GET_AP_NUM__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_num__descriptor) \ + } + + +struct RpcRespWifiScanGetApNum +{ + ProtobufCMessage base; + int32_t resp; + int32_t number; +}; +#define RPC__RESP__WIFI_SCAN_GET_AP_NUM__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_num__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiScanGetApRecords +{ + ProtobufCMessage base; + int32_t number; +}; +#define RPC__REQ__WIFI_SCAN_GET_AP_RECORDS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_records__descriptor) \ + , 0 } + + +struct RpcRespWifiScanGetApRecords +{ + ProtobufCMessage base; + int32_t resp; + int32_t number; + size_t n_ap_records; + WifiApRecord **ap_records; +}; +#define RPC__RESP__WIFI_SCAN_GET_AP_RECORDS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_records__descriptor) \ + , 0, 0, 0,NULL } + + +struct RpcReqWifiScanGetApRecord +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_SCAN_GET_AP_RECORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_record__descriptor) \ + } + + +struct RpcRespWifiScanGetApRecord +{ + ProtobufCMessage base; + int32_t resp; + WifiApRecord *ap_record; +}; +#define RPC__RESP__WIFI_SCAN_GET_AP_RECORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_record__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiClearApList +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_CLEAR_AP_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_clear_ap_list__descriptor) \ + } + + +struct RpcRespWifiClearApList +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_CLEAR_AP_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_clear_ap_list__descriptor) \ + , 0 } + + +struct RpcReqWifiRestore +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_RESTORE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_restore__descriptor) \ + } + + +struct RpcRespWifiRestore +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_RESTORE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_restore__descriptor) \ + , 0 } + + +struct RpcReqWifiClearFastConnect +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_CLEAR_FAST_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_clear_fast_connect__descriptor) \ + } + + +struct RpcRespWifiClearFastConnect +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_CLEAR_FAST_CONNECT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_clear_fast_connect__descriptor) \ + , 0 } + + +struct RpcReqWifiDeauthSta +{ + ProtobufCMessage base; + int32_t aid; +}; +#define RPC__REQ__WIFI_DEAUTH_STA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_deauth_sta__descriptor) \ + , 0 } + + +struct RpcRespWifiDeauthSta +{ + ProtobufCMessage base; + int32_t resp; + int32_t aid; +}; +#define RPC__RESP__WIFI_DEAUTH_STA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_deauth_sta__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaGetApInfo +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_AP_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_ap_info__descriptor) \ + } + + +struct RpcRespWifiStaGetApInfo +{ + ProtobufCMessage base; + int32_t resp; + WifiApRecord *ap_record; +}; +#define RPC__RESP__WIFI_STA_GET_AP_INFO__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_ap_info__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiSetProtocol +{ + ProtobufCMessage base; + int32_t ifx; + int32_t protocol_bitmap; +}; +#define RPC__REQ__WIFI_SET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_protocol__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetProtocol +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_protocol__descriptor) \ + , 0 } + + +struct RpcReqWifiGetProtocol +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_protocol__descriptor) \ + , 0 } + + +struct RpcRespWifiGetProtocol +{ + ProtobufCMessage base; + int32_t resp; + int32_t protocol_bitmap; +}; +#define RPC__RESP__WIFI_GET_PROTOCOL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_protocol__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetBandwidth +{ + ProtobufCMessage base; + int32_t ifx; + int32_t bw; +}; +#define RPC__REQ__WIFI_SET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_bandwidth__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetBandwidth +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_bandwidth__descriptor) \ + , 0 } + + +struct RpcReqWifiGetBandwidth +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_bandwidth__descriptor) \ + , 0 } + + +struct RpcRespWifiGetBandwidth +{ + ProtobufCMessage base; + int32_t resp; + int32_t bw; +}; +#define RPC__RESP__WIFI_GET_BANDWIDTH__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_bandwidth__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetChannel +{ + ProtobufCMessage base; + int32_t primary; + int32_t second; +}; +#define RPC__REQ__WIFI_SET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_channel__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetChannel +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_channel__descriptor) \ + , 0 } + + +struct RpcReqWifiGetChannel +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_channel__descriptor) \ + } + + +struct RpcRespWifiGetChannel +{ + ProtobufCMessage base; + int32_t resp; + int32_t primary; + int32_t second; +}; +#define RPC__RESP__WIFI_GET_CHANNEL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_channel__descriptor) \ + , 0, 0, 0 } + + +struct RpcReqWifiSetStorage +{ + ProtobufCMessage base; + int32_t storage; +}; +#define RPC__REQ__WIFI_SET_STORAGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_storage__descriptor) \ + , 0 } + + +struct RpcRespWifiSetStorage +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_STORAGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_storage__descriptor) \ + , 0 } + + +struct RpcReqWifiSetCountryCode +{ + ProtobufCMessage base; + ProtobufCBinaryData country; + protobuf_c_boolean ieee80211d_enabled; +}; +#define RPC__REQ__WIFI_SET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_country_code__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespWifiSetCountryCode +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_country_code__descriptor) \ + , 0 } + + +struct RpcReqWifiGetCountryCode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_country_code__descriptor) \ + } + + +struct RpcRespWifiGetCountryCode +{ + ProtobufCMessage base; + int32_t resp; + ProtobufCBinaryData country; +}; +#define RPC__RESP__WIFI_GET_COUNTRY_CODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_country_code__descriptor) \ + , 0, {0,NULL} } + + +struct RpcReqWifiSetCountry +{ + ProtobufCMessage base; + WifiCountry *country; +}; +#define RPC__REQ__WIFI_SET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_country__descriptor) \ + , NULL } + + +struct RpcRespWifiSetCountry +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_country__descriptor) \ + , 0 } + + +struct RpcReqWifiGetCountry +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_country__descriptor) \ + } + + +struct RpcRespWifiGetCountry +{ + ProtobufCMessage base; + int32_t resp; + WifiCountry *country; +}; +#define RPC__RESP__WIFI_GET_COUNTRY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_country__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiApGetStaList +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_AP_GET_STA_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_ap_get_sta_list__descriptor) \ + } + + +struct RpcRespWifiApGetStaList +{ + ProtobufCMessage base; + int32_t resp; + WifiStaList *sta_list; +}; +#define RPC__RESP__WIFI_AP_GET_STA_LIST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_ap_get_sta_list__descriptor) \ + , 0, NULL } + + +struct RpcReqWifiApGetStaAid +{ + ProtobufCMessage base; + ProtobufCBinaryData mac; +}; +#define RPC__REQ__WIFI_AP_GET_STA_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_ap_get_sta_aid__descriptor) \ + , {0,NULL} } + + +struct RpcReqWifiStaGetNegotiatedPhymode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_negotiated_phymode__descriptor) \ + } + + +struct RpcRespWifiStaGetNegotiatedPhymode +{ + ProtobufCMessage base; + int32_t resp; + uint32_t phymode; +}; +#define RPC__RESP__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_negotiated_phymode__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiApGetStaAid +{ + ProtobufCMessage base; + int32_t resp; + uint32_t aid; +}; +#define RPC__RESP__WIFI_AP_GET_STA_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_ap_get_sta_aid__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaGetRssi +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_RSSI__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_rssi__descriptor) \ + } + + +struct RpcRespWifiStaGetRssi +{ + ProtobufCMessage base; + int32_t resp; + int32_t rssi; +}; +#define RPC__RESP__WIFI_STA_GET_RSSI__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_rssi__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaGetAid +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_GET_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_aid__descriptor) \ + } + + +struct RpcRespWifiStaGetAid +{ + ProtobufCMessage base; + int32_t resp; + uint32_t aid; +}; +#define RPC__RESP__WIFI_STA_GET_AID__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_aid__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetProtocols +{ + ProtobufCMessage base; + int32_t ifx; + WifiProtocols *protocols; +}; +#define RPC__REQ__WIFI_SET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_protocols__descriptor) \ + , 0, NULL } + + +struct RpcRespWifiSetProtocols +{ + ProtobufCMessage base; + int32_t resp; + uint32_t ifx; +}; +#define RPC__RESP__WIFI_SET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_protocols__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiGetProtocols +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_protocols__descriptor) \ + , 0 } + + +struct RpcRespWifiGetProtocols +{ + ProtobufCMessage base; + int32_t resp; + int32_t ifx; + WifiProtocols *protocols; +}; +#define RPC__RESP__WIFI_GET_PROTOCOLS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_protocols__descriptor) \ + , 0, 0, NULL } + + +struct RpcReqWifiSetBandwidths +{ + ProtobufCMessage base; + int32_t ifx; + WifiBandwidths *bandwidths; +}; +#define RPC__REQ__WIFI_SET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_bandwidths__descriptor) \ + , 0, NULL } + + +struct RpcRespWifiSetBandwidths +{ + ProtobufCMessage base; + int32_t resp; + int32_t ifx; +}; +#define RPC__RESP__WIFI_SET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_bandwidths__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiGetBandwidths +{ + ProtobufCMessage base; + int32_t ifx; +}; +#define RPC__REQ__WIFI_GET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_bandwidths__descriptor) \ + , 0 } + + +struct RpcRespWifiGetBandwidths +{ + ProtobufCMessage base; + int32_t resp; + int32_t ifx; + WifiBandwidths *bandwidths; +}; +#define RPC__RESP__WIFI_GET_BANDWIDTHS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_bandwidths__descriptor) \ + , 0, 0, NULL } + + +struct RpcReqWifiSetBand +{ + ProtobufCMessage base; + uint32_t band; +}; +#define RPC__REQ__WIFI_SET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_band__descriptor) \ + , 0 } + + +struct RpcRespWifiSetBand +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_band__descriptor) \ + , 0 } + + +struct RpcReqWifiGetBand +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_band__descriptor) \ + } + + +struct RpcRespWifiGetBand +{ + ProtobufCMessage base; + int32_t resp; + uint32_t band; +}; +#define RPC__RESP__WIFI_GET_BAND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_band__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetBandMode +{ + ProtobufCMessage base; + uint32_t bandmode; +}; +#define RPC__REQ__WIFI_SET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_band_mode__descriptor) \ + , 0 } + + +struct RpcRespWifiSetBandMode +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_band_mode__descriptor) \ + , 0 } + + +struct RpcReqWifiGetBandMode +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_GET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_band_mode__descriptor) \ + } + + +struct RpcRespWifiGetBandMode +{ + ProtobufCMessage base; + int32_t resp; + uint32_t bandmode; +}; +#define RPC__RESP__WIFI_GET_BAND_MODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_band_mode__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiSetInactiveTime +{ + ProtobufCMessage base; + uint32_t ifx; + uint32_t sec; +}; +#define RPC__REQ__WIFI_SET_INACTIVE_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_inactive_time__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiSetInactiveTime +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_INACTIVE_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_inactive_time__descriptor) \ + , 0 } + + +struct RpcReqWifiGetInactiveTime +{ + ProtobufCMessage base; + uint32_t ifx; +}; +#define RPC__REQ__WIFI_GET_INACTIVE_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_inactive_time__descriptor) \ + , 0 } + + +struct RpcRespWifiGetInactiveTime +{ + ProtobufCMessage base; + int32_t resp; + uint32_t sec; +}; +#define RPC__RESP__WIFI_GET_INACTIVE_TIME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_inactive_time__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaItwtSetup +{ + ProtobufCMessage base; + WifiItwtSetupConfig *setup_config; +}; +#define RPC__REQ__WIFI_STA_ITWT_SETUP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_setup__descriptor) \ + , NULL } + + +struct RpcRespWifiStaItwtSetup +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ITWT_SETUP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_setup__descriptor) \ + , 0 } + + +struct RpcReqWifiStaItwtTeardown +{ + ProtobufCMessage base; + int32_t flow_id; +}; +#define RPC__REQ__WIFI_STA_ITWT_TEARDOWN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_teardown__descriptor) \ + , 0 } + + +struct RpcRespWifiStaItwtTeardown +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ITWT_TEARDOWN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_teardown__descriptor) \ + , 0 } + + +struct RpcReqWifiStaItwtSuspend +{ + ProtobufCMessage base; + int32_t flow_id; + int32_t suspend_time_ms; +}; +#define RPC__REQ__WIFI_STA_ITWT_SUSPEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_suspend__descriptor) \ + , 0, 0 } + + +struct RpcRespWifiStaItwtSuspend +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ITWT_SUSPEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_suspend__descriptor) \ + , 0 } + + +struct RpcReqWifiStaItwtGetFlowIdStatus +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_ITWT_GET_FLOW_ID_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor) \ + } + + +struct RpcRespWifiStaItwtGetFlowIdStatus +{ + ProtobufCMessage base; + int32_t resp; + int32_t flow_id_bitmap; +}; +#define RPC__RESP__WIFI_STA_ITWT_GET_FLOW_ID_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor) \ + , 0, 0 } + + +struct RpcReqWifiStaItwtSendProbeReq +{ + ProtobufCMessage base; + int32_t timeout_ms; +}; +#define RPC__REQ__WIFI_STA_ITWT_SEND_PROBE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_send_probe_req__descriptor) \ + , 0 } + + +struct RpcRespWifiStaItwtSendProbeReq +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ITWT_SEND_PROBE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_send_probe_req__descriptor) \ + , 0 } + + +struct RpcReqWifiStaItwtSetTargetWakeTimeOffset +{ + ProtobufCMessage base; + int32_t offset_us; +}; +#define RPC__REQ__WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor) \ + , 0 } + + +struct RpcRespWifiStaItwtSetTargetWakeTimeOffset +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor) \ + , 0 } + + +struct RpcReqWifiStaTwtConfig +{ + ProtobufCMessage base; + WifiTwtConfig *config; +}; +#define RPC__REQ__WIFI_STA_TWT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_twt_config__descriptor) \ + , NULL } + + +struct RpcRespWifiStaTwtConfig +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_TWT_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_twt_config__descriptor) \ + , 0 } + + +struct RpcReqGetCoprocessorFwVersion +{ + ProtobufCMessage base; +}; +#define RPC__REQ__GET_COPROCESSOR_FW_VERSION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_coprocessor_fw_version__descriptor) \ + } + + +struct RpcRespGetCoprocessorFwVersion +{ + ProtobufCMessage base; + int32_t resp; + uint32_t major1; + uint32_t minor1; + uint32_t patch1; +}; +#define RPC__RESP__GET_COPROCESSOR_FW_VERSION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_coprocessor_fw_version__descriptor) \ + , 0, 0, 0, 0 } + + +struct RpcReqSetDhcpDnsStatus +{ + ProtobufCMessage base; + int32_t iface; + int32_t net_link_up; + int32_t dhcp_up; + ProtobufCBinaryData dhcp_ip; + ProtobufCBinaryData dhcp_nm; + ProtobufCBinaryData dhcp_gw; + int32_t dns_up; + ProtobufCBinaryData dns_ip; + int32_t dns_type; +}; +#define RPC__REQ__SET_DHCP_DNS_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_dhcp_dns_status__descriptor) \ + , 0, 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0 } + + +struct RpcRespSetDhcpDnsStatus +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SET_DHCP_DNS_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_dhcp_dns_status__descriptor) \ + , 0 } + + +struct RpcReqGetDhcpDnsStatus +{ + ProtobufCMessage base; + int32_t iface; +}; +#define RPC__REQ__GET_DHCP_DNS_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_dhcp_dns_status__descriptor) \ + , 0 } + + +struct RpcRespGetDhcpDnsStatus +{ + ProtobufCMessage base; + int32_t iface; + int32_t net_link_up; + int32_t dhcp_up; + ProtobufCBinaryData dhcp_ip; + ProtobufCBinaryData dhcp_nm; + ProtobufCBinaryData dhcp_gw; + int32_t dns_up; + ProtobufCBinaryData dns_ip; + int32_t dns_type; + int32_t resp; +}; +#define RPC__RESP__GET_DHCP_DNS_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_dhcp_dns_status__descriptor) \ + , 0, 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0, 0 } + + +struct RpcReqSuppDppInit +{ + ProtobufCMessage base; + /* + * enables sending of Event_SuppDpp to host via callback + */ + protobuf_c_boolean cb; +}; +#define RPC__REQ__SUPP_DPP_INIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_init__descriptor) \ + , 0 } + + +struct RpcRespSuppDppInit +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SUPP_DPP_INIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_init__descriptor) \ + , 0 } + + +struct RpcReqSuppDppDeinit +{ + ProtobufCMessage base; +}; +#define RPC__REQ__SUPP_DPP_DEINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_deinit__descriptor) \ + } + + +struct RpcRespSuppDppDeinit +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SUPP_DPP_DEINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_deinit__descriptor) \ + , 0 } + + +struct RpcReqSuppDppBootstrapGen +{ + ProtobufCMessage base; + /* + * DPP Bootstrapping listen channels separated by commas + */ + ProtobufCBinaryData chan_list; + /* + * Bootstrap method type, only QR Code method is supported for now. + */ + int32_t type; + /* + * (Optional) 32 byte Raw Private Key for generating a Bootstrapping Public Key + */ + ProtobufCBinaryData key; + /* + * (Optional) Ancillary Device Information like Serial Number + */ + ProtobufCBinaryData info; +}; +#define RPC__REQ__SUPP_DPP_BOOTSTRAP_GEN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_bootstrap_gen__descriptor) \ + , {0,NULL}, 0, {0,NULL}, {0,NULL} } + + +struct RpcRespSuppDppBootstrapGen +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SUPP_DPP_BOOTSTRAP_GEN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_bootstrap_gen__descriptor) \ + , 0 } + + +struct RpcReqSuppDppStartListen +{ + ProtobufCMessage base; +}; +#define RPC__REQ__SUPP_DPP_START_LISTEN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_start_listen__descriptor) \ + } + + +struct RpcRespSuppDppStartListen +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SUPP_DPP_START_LISTEN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_start_listen__descriptor) \ + , 0 } + + +struct RpcReqSuppDppStopListen +{ + ProtobufCMessage base; +}; +#define RPC__REQ__SUPP_DPP_STOP_LISTEN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_stop_listen__descriptor) \ + } + + +struct RpcRespSuppDppStopListen +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__SUPP_DPP_STOP_LISTEN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_stop_listen__descriptor) \ + , 0 } + + +struct RpcReqIfaceMacAddrSetGet +{ + ProtobufCMessage base; + protobuf_c_boolean set; + uint32_t type; + /* + * only valid for set + */ + ProtobufCBinaryData mac; +}; +#define RPC__REQ__IFACE_MAC_ADDR_SET_GET__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__iface_mac_addr_set_get__descriptor) \ + , 0, 0, {0,NULL} } + + +struct RpcRespIfaceMacAddrSetGet +{ + ProtobufCMessage base; + int32_t resp; + protobuf_c_boolean set; + uint32_t type; + ProtobufCBinaryData mac; +}; +#define RPC__RESP__IFACE_MAC_ADDR_SET_GET__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__iface_mac_addr_set_get__descriptor) \ + , 0, 0, 0, {0,NULL} } + + +struct RpcReqIfaceMacAddrLenGet +{ + ProtobufCMessage base; + uint32_t type; +}; +#define RPC__REQ__IFACE_MAC_ADDR_LEN_GET__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__iface_mac_addr_len_get__descriptor) \ + , 0 } + + +struct RpcRespIfaceMacAddrLenGet +{ + ProtobufCMessage base; + int32_t resp; + uint32_t type; + uint32_t len; +}; +#define RPC__RESP__IFACE_MAC_ADDR_LEN_GET__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__iface_mac_addr_len_get__descriptor) \ + , 0, 0, 0 } + + +struct RpcReqFeatureControl +{ + ProtobufCMessage base; + RpcFeature feature; + RpcFeatureCommand command; + RpcFeatureOption option; +}; +#define RPC__REQ__FEATURE_CONTROL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__feature_control__descriptor) \ + , RPC_FEATURE__Feature_None, RPC_FEATURE_COMMAND__Feature_Command_None, RPC_FEATURE_OPTION__Feature_Option_None } + + +struct RpcRespFeatureControl +{ + ProtobufCMessage base; + int32_t resp; + RpcFeature feature; + RpcFeatureCommand command; + RpcFeatureOption option; +}; +#define RPC__RESP__FEATURE_CONTROL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__feature_control__descriptor) \ + , 0, RPC_FEATURE__Feature_None, RPC_FEATURE_COMMAND__Feature_Command_None, RPC_FEATURE_OPTION__Feature_Option_None } + + +struct RpcEventWifiEventNoArgs +{ + ProtobufCMessage base; + int32_t resp; + int32_t event_id; +}; +#define RPC__EVENT__WIFI_EVENT_NO_ARGS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_event_no_args__descriptor) \ + , 0, 0 } + + +struct RpcEventESPInit +{ + ProtobufCMessage base; + ProtobufCBinaryData init_data; +}; +#define RPC__EVENT__ESPINIT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__espinit__descriptor) \ + , {0,NULL} } + + +struct RpcEventHeartbeat +{ + ProtobufCMessage base; + int32_t hb_num; +}; +#define RPC__EVENT__HEARTBEAT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__heartbeat__descriptor) \ + , 0 } + + +struct RpcEventAPStaDisconnected +{ + ProtobufCMessage base; + int32_t resp; + ProtobufCBinaryData mac; + uint32_t aid; + protobuf_c_boolean is_mesh_child; + uint32_t reason; +}; +#define RPC__EVENT__AP__STA_DISCONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__ap__sta_disconnected__descriptor) \ + , 0, {0,NULL}, 0, 0, 0 } + + +struct RpcEventAPStaConnected +{ + ProtobufCMessage base; + int32_t resp; + ProtobufCBinaryData mac; + uint32_t aid; + protobuf_c_boolean is_mesh_child; +}; +#define RPC__EVENT__AP__STA_CONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__ap__sta_connected__descriptor) \ + , 0, {0,NULL}, 0, 0 } + + +struct RpcEventStaScanDone +{ + ProtobufCMessage base; + int32_t resp; + WifiEventStaScanDone *scan_done; +}; +#define RPC__EVENT__STA_SCAN_DONE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_scan_done__descriptor) \ + , 0, NULL } + + +struct RpcEventStaConnected +{ + ProtobufCMessage base; + int32_t resp; + WifiEventStaConnected *sta_connected; +}; +#define RPC__EVENT__STA_CONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_connected__descriptor) \ + , 0, NULL } + + +struct RpcEventStaDisconnected +{ + ProtobufCMessage base; + int32_t resp; + WifiEventStaDisconnected *sta_disconnected; +}; +#define RPC__EVENT__STA_DISCONNECTED__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_disconnected__descriptor) \ + , 0, NULL } + + +struct RpcEventDhcpDnsStatus +{ + ProtobufCMessage base; + int32_t iface; + int32_t net_link_up; + int32_t dhcp_up; + ProtobufCBinaryData dhcp_ip; + ProtobufCBinaryData dhcp_nm; + ProtobufCBinaryData dhcp_gw; + int32_t dns_up; + ProtobufCBinaryData dns_ip; + int32_t dns_type; + int32_t resp; +}; +#define RPC__EVENT__DHCP_DNS_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__dhcp_dns_status__descriptor) \ + , 0, 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0, 0 } + + +struct RpcEventStaItwtSetup +{ + ProtobufCMessage base; + int32_t resp; + WifiItwtSetupConfig *config; + int32_t status; + uint32_t reason; + uint64_t target_wake_time; +}; +#define RPC__EVENT__STA_ITWT_SETUP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_setup__descriptor) \ + , 0, NULL, 0, 0, 0 } + + +struct RpcEventStaItwtTeardown +{ + ProtobufCMessage base; + int32_t resp; + uint32_t flow_id; + uint32_t status; +}; +#define RPC__EVENT__STA_ITWT_TEARDOWN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_teardown__descriptor) \ + , 0, 0, 0 } + + +struct RpcEventStaItwtSuspend +{ + ProtobufCMessage base; + int32_t resp; + int32_t status; + uint32_t flow_id_bitmap; + /* + * represents uint32_t actual_suspend_time_ms[] + */ + size_t n_actual_suspend_time_ms; + uint32_t *actual_suspend_time_ms; +}; +#define RPC__EVENT__STA_ITWT_SUSPEND__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_suspend__descriptor) \ + , 0, 0, 0, 0,NULL } + + +struct RpcEventStaItwtProbe +{ + ProtobufCMessage base; + int32_t resp; + int32_t status; + uint32_t reason; +}; +#define RPC__EVENT__STA_ITWT_PROBE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_probe__descriptor) \ + , 0, 0, 0 } + + +struct RpcReqWifiStaEnterpriseEnable +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_ENTERPRISE_ENABLE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_enterprise_enable__descriptor) \ + } + + +struct RpcRespWifiStaEnterpriseEnable +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ENTERPRISE_ENABLE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_enterprise_enable__descriptor) \ + , 0 } + + +struct RpcReqWifiStaEnterpriseDisable +{ + ProtobufCMessage base; +}; +#define RPC__REQ__WIFI_STA_ENTERPRISE_DISABLE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_enterprise_disable__descriptor) \ + } + + +struct RpcRespWifiStaEnterpriseDisable +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_STA_ENTERPRISE_DISABLE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_enterprise_disable__descriptor) \ + , 0 } + + +struct RpcReqEapSetIdentity +{ + ProtobufCMessage base; + ProtobufCBinaryData identity; + int32_t len; +}; +#define RPC__REQ__EAP_SET_IDENTITY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_identity__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespEapSetIdentity +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_IDENTITY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_identity__descriptor) \ + , 0 } + + +struct RpcReqEapClearIdentity +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_CLEAR_IDENTITY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_identity__descriptor) \ + } + + +struct RpcRespEapClearIdentity +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_CLEAR_IDENTITY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_identity__descriptor) \ + , 0 } + + +struct RpcReqEapSetUsername +{ + ProtobufCMessage base; + ProtobufCBinaryData username; + int32_t len; +}; +#define RPC__REQ__EAP_SET_USERNAME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_username__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespEapSetUsername +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_USERNAME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_username__descriptor) \ + , 0 } + + +struct RpcReqEapClearUsername +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_CLEAR_USERNAME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_username__descriptor) \ + } + + +struct RpcRespEapClearUsername +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_CLEAR_USERNAME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_username__descriptor) \ + , 0 } + + +struct RpcReqEapSetPassword +{ + ProtobufCMessage base; + ProtobufCBinaryData password; + int32_t len; +}; +#define RPC__REQ__EAP_SET_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_password__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespEapSetPassword +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_password__descriptor) \ + , 0 } + + +struct RpcReqEapClearPassword +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_CLEAR_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_password__descriptor) \ + } + + +struct RpcRespEapClearPassword +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_CLEAR_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_password__descriptor) \ + , 0 } + + +struct RpcReqEapSetNewPassword +{ + ProtobufCMessage base; + ProtobufCBinaryData new_password; + int32_t len; +}; +#define RPC__REQ__EAP_SET_NEW_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_new_password__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespEapSetNewPassword +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_NEW_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_new_password__descriptor) \ + , 0 } + + +struct RpcReqEapClearNewPassword +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_CLEAR_NEW_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_new_password__descriptor) \ + } + + +struct RpcRespEapClearNewPassword +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_CLEAR_NEW_PASSWORD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_new_password__descriptor) \ + , 0 } + + +struct RpcReqEapSetCaCert +{ + ProtobufCMessage base; + ProtobufCBinaryData ca_cert; + int32_t ca_cert_len; +}; +#define RPC__REQ__EAP_SET_CA_CERT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_ca_cert__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespEapSetCaCert +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_CA_CERT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_ca_cert__descriptor) \ + , 0 } + + +struct RpcReqEapClearCaCert +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_CLEAR_CA_CERT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_ca_cert__descriptor) \ + } + + +struct RpcRespEapClearCaCert +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_CLEAR_CA_CERT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_ca_cert__descriptor) \ + , 0 } + + +struct RpcReqEapSetCertificateAndKey +{ + ProtobufCMessage base; + ProtobufCBinaryData client_cert; + int32_t client_cert_len; + ProtobufCBinaryData private_key; + int32_t private_key_len; + ProtobufCBinaryData private_key_password; + int32_t private_key_passwd_len; +}; +#define RPC__REQ__EAP_SET_CERTIFICATE_AND_KEY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_certificate_and_key__descriptor) \ + , {0,NULL}, 0, {0,NULL}, 0, {0,NULL}, 0 } + + +struct RpcRespEapSetCertificateAndKey +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_CERTIFICATE_AND_KEY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_certificate_and_key__descriptor) \ + , 0 } + + +struct RpcReqEapClearCertificateAndKey +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_CLEAR_CERTIFICATE_AND_KEY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_certificate_and_key__descriptor) \ + } + + +struct RpcRespEapClearCertificateAndKey +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_CLEAR_CERTIFICATE_AND_KEY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_certificate_and_key__descriptor) \ + , 0 } + + +struct RpcReqEapSetDisableTimeCheck +{ + ProtobufCMessage base; + protobuf_c_boolean disable; +}; +#define RPC__REQ__EAP_SET_DISABLE_TIME_CHECK__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_disable_time_check__descriptor) \ + , 0 } + + +struct RpcRespEapSetDisableTimeCheck +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_DISABLE_TIME_CHECK__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_disable_time_check__descriptor) \ + , 0 } + + +struct RpcReqEapGetDisableTimeCheck +{ + ProtobufCMessage base; +}; +#define RPC__REQ__EAP_GET_DISABLE_TIME_CHECK__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_get_disable_time_check__descriptor) \ + } + + +struct RpcRespEapGetDisableTimeCheck +{ + ProtobufCMessage base; + int32_t resp; + protobuf_c_boolean disable; +}; +#define RPC__RESP__EAP_GET_DISABLE_TIME_CHECK__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_get_disable_time_check__descriptor) \ + , 0, 0 } + + +struct RpcReqEapSetTtlsPhase2Method +{ + ProtobufCMessage base; + int32_t type; +}; +#define RPC__REQ__EAP_SET_TTLS_PHASE2_METHOD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_ttls_phase2_method__descriptor) \ + , 0 } + + +struct RpcRespEapSetTtlsPhase2Method +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_TTLS_PHASE2_METHOD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_ttls_phase2_method__descriptor) \ + , 0 } + + +struct RpcReqEapSetSuiteb192bitCertification +{ + ProtobufCMessage base; + protobuf_c_boolean enable; +}; +#define RPC__REQ__EAP_SET_SUITEB192BIT_CERTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_suiteb192bit_certification__descriptor) \ + , 0 } + + +struct RpcRespEapSetSuiteb192bitCertification +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_SUITEB192BIT_CERTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_suiteb192bit_certification__descriptor) \ + , 0 } + + +struct RpcReqEapSetPacFile +{ + ProtobufCMessage base; + ProtobufCBinaryData pac_file; + int32_t pac_file_len; +}; +#define RPC__REQ__EAP_SET_PAC_FILE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_pac_file__descriptor) \ + , {0,NULL}, 0 } + + +struct RpcRespEapSetPacFile +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_PAC_FILE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_pac_file__descriptor) \ + , 0 } + + +struct RpcReqEapSetFastParams +{ + ProtobufCMessage base; + EapFastConfig *eap_fast_config; +}; +#define RPC__REQ__EAP_SET_FAST_PARAMS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_fast_params__descriptor) \ + , NULL } + + +struct RpcRespEapSetFastParams +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_FAST_PARAMS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_fast_params__descriptor) \ + , 0 } + + +struct RpcReqEapUseDefaultCertBundle +{ + ProtobufCMessage base; + protobuf_c_boolean use_default_bundle; +}; +#define RPC__REQ__EAP_USE_DEFAULT_CERT_BUNDLE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_use_default_cert_bundle__descriptor) \ + , 0 } + + +struct RpcRespEapUseDefaultCertBundle +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_USE_DEFAULT_CERT_BUNDLE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_use_default_cert_bundle__descriptor) \ + , 0 } + + +struct RpcReqWifiSetOkcSupport +{ + ProtobufCMessage base; + protobuf_c_boolean enable; +}; +#define RPC__REQ__WIFI_SET_OKC_SUPPORT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_okc_support__descriptor) \ + , 0 } + + +struct RpcRespWifiSetOkcSupport +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__WIFI_SET_OKC_SUPPORT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_okc_support__descriptor) \ + , 0 } + + +struct RpcReqEapSetDomainName +{ + ProtobufCMessage base; + ProtobufCBinaryData domain_name; +}; +#define RPC__REQ__EAP_SET_DOMAIN_NAME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_domain_name__descriptor) \ + , {0,NULL} } + + +struct RpcRespEapSetDomainName +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_DOMAIN_NAME__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_domain_name__descriptor) \ + , 0 } + + +struct RpcReqEapSetEapMethods +{ + ProtobufCMessage base; + int32_t methods; +}; +#define RPC__REQ__EAP_SET_EAP_METHODS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_eap_methods__descriptor) \ + , 0 } + + +struct RpcRespEapSetEapMethods +{ + ProtobufCMessage base; + int32_t resp; +}; +#define RPC__RESP__EAP_SET_EAP_METHODS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_eap_methods__descriptor) \ + , 0 } + + +struct RpcEventSuppDppUriReady +{ + ProtobufCMessage base; + int32_t resp; + /* + * QR Code to configure the enrollee + */ + ProtobufCBinaryData qrcode; +}; +#define RPC__EVENT__SUPP_DPP_URI_READY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__supp_dpp_uri_ready__descriptor) \ + , 0, {0,NULL} } + + +struct RpcEventSuppDppCfgRecvd +{ + ProtobufCMessage base; + int32_t resp; + WifiConfig *cfg; +}; +#define RPC__EVENT__SUPP_DPP_CFG_RECVD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__supp_dpp_cfg_recvd__descriptor) \ + , 0, NULL } + + +struct RpcEventSuppDppFail +{ + ProtobufCMessage base; + int32_t resp; + /* + * failure reason + */ + int32_t reason; +}; +#define RPC__EVENT__SUPP_DPP_FAIL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__supp_dpp_fail__descriptor) \ + , 0, 0 } + + +struct RpcEventWifiDppUriReady +{ + ProtobufCMessage base; + int32_t resp; + /* + * QR Code to configure the enrollee + */ + ProtobufCBinaryData qrcode; +}; +#define RPC__EVENT__WIFI_DPP_URI_READY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_dpp_uri_ready__descriptor) \ + , 0, {0,NULL} } + + +struct RpcEventWifiDppCfgRecvd +{ + ProtobufCMessage base; + int32_t resp; + WifiConfig *cfg; +}; +#define RPC__EVENT__WIFI_DPP_CFG_RECVD__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_dpp_cfg_recvd__descriptor) \ + , 0, NULL } + + +struct RpcEventWifiDppFail +{ + ProtobufCMessage base; + int32_t resp; + /* + * failure reason + */ + int32_t reason; +}; +#define RPC__EVENT__WIFI_DPP_FAIL__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_dpp_fail__descriptor) \ + , 0, 0 } + + +typedef enum { + RPC__PAYLOAD__NOT_SET = 0, + RPC__PAYLOAD_REQ_GET_MAC_ADDRESS = 257, + RPC__PAYLOAD_REQ_SET_MAC_ADDRESS = 258, + RPC__PAYLOAD_REQ_GET_WIFI_MODE = 259, + RPC__PAYLOAD_REQ_SET_WIFI_MODE = 260, + RPC__PAYLOAD_REQ_SUPP_DPP_INIT = 261, + RPC__PAYLOAD_REQ_SUPP_DPP_DEINIT = 262, + RPC__PAYLOAD_REQ_SUPP_DPP_BOOTSTRAP_GEN = 263, + RPC__PAYLOAD_REQ_SUPP_DPP_START_LISTEN = 264, + RPC__PAYLOAD_REQ_SUPP_DPP_STOP_LISTEN = 265, + RPC__PAYLOAD_REQ_WIFI_SET_PS = 270, + RPC__PAYLOAD_REQ_WIFI_GET_PS = 271, + RPC__PAYLOAD_REQ_OTA_BEGIN = 272, + RPC__PAYLOAD_REQ_OTA_WRITE = 273, + RPC__PAYLOAD_REQ_OTA_END = 274, + RPC__PAYLOAD_REQ_SET_WIFI_MAX_TX_POWER = 275, + RPC__PAYLOAD_REQ_GET_WIFI_MAX_TX_POWER = 276, + RPC__PAYLOAD_REQ_CONFIG_HEARTBEAT = 277, + RPC__PAYLOAD_REQ_WIFI_INIT = 278, + RPC__PAYLOAD_REQ_WIFI_DEINIT = 279, + RPC__PAYLOAD_REQ_WIFI_START = 280, + RPC__PAYLOAD_REQ_WIFI_STOP = 281, + RPC__PAYLOAD_REQ_WIFI_CONNECT = 282, + RPC__PAYLOAD_REQ_WIFI_DISCONNECT = 283, + RPC__PAYLOAD_REQ_WIFI_SET_CONFIG = 284, + RPC__PAYLOAD_REQ_WIFI_GET_CONFIG = 285, + RPC__PAYLOAD_REQ_WIFI_SCAN_START = 286, + RPC__PAYLOAD_REQ_WIFI_SCAN_STOP = 287, + RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_NUM = 288, + RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_RECORDS = 289, + RPC__PAYLOAD_REQ_WIFI_CLEAR_AP_LIST = 290, + RPC__PAYLOAD_REQ_WIFI_RESTORE = 291, + RPC__PAYLOAD_REQ_WIFI_CLEAR_FAST_CONNECT = 292, + RPC__PAYLOAD_REQ_WIFI_DEAUTH_STA = 293, + RPC__PAYLOAD_REQ_WIFI_STA_GET_AP_INFO = 294, + RPC__PAYLOAD_REQ_WIFI_SET_PROTOCOL = 297, + RPC__PAYLOAD_REQ_WIFI_GET_PROTOCOL = 298, + RPC__PAYLOAD_REQ_WIFI_SET_BANDWIDTH = 299, + RPC__PAYLOAD_REQ_WIFI_GET_BANDWIDTH = 300, + RPC__PAYLOAD_REQ_WIFI_SET_CHANNEL = 301, + RPC__PAYLOAD_REQ_WIFI_GET_CHANNEL = 302, + RPC__PAYLOAD_REQ_WIFI_SET_COUNTRY = 303, + RPC__PAYLOAD_REQ_WIFI_GET_COUNTRY = 304, + RPC__PAYLOAD_REQ_WIFI_AP_GET_STA_LIST = 311, + RPC__PAYLOAD_REQ_WIFI_AP_GET_STA_AID = 312, + RPC__PAYLOAD_REQ_WIFI_SET_STORAGE = 313, + RPC__PAYLOAD_REQ_WIFI_SET_INACTIVE_TIME = 325, + RPC__PAYLOAD_REQ_WIFI_GET_INACTIVE_TIME = 326, + RPC__PAYLOAD_REQ_WIFI_SET_COUNTRY_CODE = 334, + RPC__PAYLOAD_REQ_WIFI_GET_COUNTRY_CODE = 335, + RPC__PAYLOAD_REQ_WIFI_STA_GET_AID = 338, + RPC__PAYLOAD_REQ_WIFI_STA_GET_NEGOTIATED_PHYMODE = 339, + RPC__PAYLOAD_REQ_WIFI_STA_GET_RSSI = 341, + RPC__PAYLOAD_REQ_WIFI_SET_PROTOCOLS = 342, + RPC__PAYLOAD_REQ_WIFI_GET_PROTOCOLS = 343, + RPC__PAYLOAD_REQ_WIFI_SET_BANDWIDTHS = 344, + RPC__PAYLOAD_REQ_WIFI_GET_BANDWIDTHS = 345, + RPC__PAYLOAD_REQ_WIFI_SET_BAND = 346, + RPC__PAYLOAD_REQ_WIFI_GET_BAND = 347, + RPC__PAYLOAD_REQ_WIFI_SET_BANDMODE = 348, + RPC__PAYLOAD_REQ_WIFI_GET_BANDMODE = 349, + RPC__PAYLOAD_REQ_GET_COPROCESSOR_FWVERSION = 350, + RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_RECORD = 351, + RPC__PAYLOAD_REQ_SET_DHCP_DNS = 352, + RPC__PAYLOAD_REQ_GET_DHCP_DNS = 353, + RPC__PAYLOAD_REQ_WIFI_STA_TWT_CONFIG = 354, + RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SETUP = 355, + RPC__PAYLOAD_REQ_WIFI_STA_ITWT_TEARDOWN = 356, + RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SUSPEND = 357, + RPC__PAYLOAD_REQ_WIFI_STA_ITWT_GET_FLOW_ID_STATUS = 358, + RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SEND_PROBE_REQ = 359, + RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET = 360, + RPC__PAYLOAD_REQ_WIFI_STA_ENTERPRISE_ENABLE = 361, + RPC__PAYLOAD_REQ_WIFI_STA_ENTERPRISE_DISABLE = 362, + RPC__PAYLOAD_REQ_EAP_SET_IDENTITY = 363, + RPC__PAYLOAD_REQ_EAP_CLEAR_IDENTITY = 364, + RPC__PAYLOAD_REQ_EAP_SET_USERNAME = 365, + RPC__PAYLOAD_REQ_EAP_CLEAR_USERNAME = 366, + RPC__PAYLOAD_REQ_EAP_SET_PASSWORD = 367, + RPC__PAYLOAD_REQ_EAP_CLEAR_PASSWORD = 368, + RPC__PAYLOAD_REQ_EAP_SET_NEW_PASSWORD = 369, + RPC__PAYLOAD_REQ_EAP_CLEAR_NEW_PASSWORD = 370, + RPC__PAYLOAD_REQ_EAP_SET_CA_CERT = 371, + RPC__PAYLOAD_REQ_EAP_CLEAR_CA_CERT = 372, + RPC__PAYLOAD_REQ_EAP_SET_CERTIFICATE_AND_KEY = 373, + RPC__PAYLOAD_REQ_EAP_CLEAR_CERTIFICATE_AND_KEY = 374, + RPC__PAYLOAD_REQ_EAP_GET_DISABLE_TIME_CHECK = 375, + RPC__PAYLOAD_REQ_EAP_SET_TTLS_PHASE2_METHOD = 376, + RPC__PAYLOAD_REQ_EAP_SET_SUITEB_CERTIFICATION = 377, + RPC__PAYLOAD_REQ_EAP_SET_PAC_FILE = 378, + RPC__PAYLOAD_REQ_EAP_SET_FAST_PARAMS = 379, + RPC__PAYLOAD_REQ_EAP_USE_DEFAULT_CERT_BUNDLE = 380, + RPC__PAYLOAD_REQ_WIFI_SET_OKC_SUPPORT = 381, + RPC__PAYLOAD_REQ_EAP_SET_DOMAIN_NAME = 382, + RPC__PAYLOAD_REQ_EAP_SET_DISABLE_TIME_CHECK = 383, + RPC__PAYLOAD_REQ_EAP_SET_EAP_METHODS = 384, + RPC__PAYLOAD_REQ_IFACE_MAC_ADDR_SET_GET = 385, + RPC__PAYLOAD_REQ_IFACE_MAC_ADDR_LEN_GET = 386, + RPC__PAYLOAD_REQ_FEATURE_CONTROL = 387, + RPC__PAYLOAD_RESP_GET_MAC_ADDRESS = 513, + RPC__PAYLOAD_RESP_SET_MAC_ADDRESS = 514, + RPC__PAYLOAD_RESP_GET_WIFI_MODE = 515, + RPC__PAYLOAD_RESP_SET_WIFI_MODE = 516, + RPC__PAYLOAD_RESP_SUPP_DPP_INIT = 517, + RPC__PAYLOAD_RESP_SUPP_DPP_DEINIT = 518, + RPC__PAYLOAD_RESP_SUPP_DPP_BOOTSTRAP_GEN = 519, + RPC__PAYLOAD_RESP_SUPP_DPP_START_LISTEN = 520, + RPC__PAYLOAD_RESP_SUPP_DPP_STOP_LISTEN = 521, + RPC__PAYLOAD_RESP_WIFI_SET_PS = 526, + RPC__PAYLOAD_RESP_WIFI_GET_PS = 527, + RPC__PAYLOAD_RESP_OTA_BEGIN = 528, + RPC__PAYLOAD_RESP_OTA_WRITE = 529, + RPC__PAYLOAD_RESP_OTA_END = 530, + RPC__PAYLOAD_RESP_SET_WIFI_MAX_TX_POWER = 531, + RPC__PAYLOAD_RESP_GET_WIFI_MAX_TX_POWER = 532, + RPC__PAYLOAD_RESP_CONFIG_HEARTBEAT = 533, + RPC__PAYLOAD_RESP_WIFI_INIT = 534, + RPC__PAYLOAD_RESP_WIFI_DEINIT = 535, + RPC__PAYLOAD_RESP_WIFI_START = 536, + RPC__PAYLOAD_RESP_WIFI_STOP = 537, + RPC__PAYLOAD_RESP_WIFI_CONNECT = 538, + RPC__PAYLOAD_RESP_WIFI_DISCONNECT = 539, + RPC__PAYLOAD_RESP_WIFI_SET_CONFIG = 540, + RPC__PAYLOAD_RESP_WIFI_GET_CONFIG = 541, + RPC__PAYLOAD_RESP_WIFI_SCAN_START = 542, + RPC__PAYLOAD_RESP_WIFI_SCAN_STOP = 543, + RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_NUM = 544, + RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_RECORDS = 545, + RPC__PAYLOAD_RESP_WIFI_CLEAR_AP_LIST = 546, + RPC__PAYLOAD_RESP_WIFI_RESTORE = 547, + RPC__PAYLOAD_RESP_WIFI_CLEAR_FAST_CONNECT = 548, + RPC__PAYLOAD_RESP_WIFI_DEAUTH_STA = 549, + RPC__PAYLOAD_RESP_WIFI_STA_GET_AP_INFO = 550, + RPC__PAYLOAD_RESP_WIFI_SET_PROTOCOL = 553, + RPC__PAYLOAD_RESP_WIFI_GET_PROTOCOL = 554, + RPC__PAYLOAD_RESP_WIFI_SET_BANDWIDTH = 555, + RPC__PAYLOAD_RESP_WIFI_GET_BANDWIDTH = 556, + RPC__PAYLOAD_RESP_WIFI_SET_CHANNEL = 557, + RPC__PAYLOAD_RESP_WIFI_GET_CHANNEL = 558, + RPC__PAYLOAD_RESP_WIFI_SET_COUNTRY = 559, + RPC__PAYLOAD_RESP_WIFI_GET_COUNTRY = 560, + RPC__PAYLOAD_RESP_WIFI_AP_GET_STA_LIST = 567, + RPC__PAYLOAD_RESP_WIFI_AP_GET_STA_AID = 568, + RPC__PAYLOAD_RESP_WIFI_SET_STORAGE = 569, + RPC__PAYLOAD_RESP_WIFI_SET_INACTIVE_TIME = 581, + RPC__PAYLOAD_RESP_WIFI_GET_INACTIVE_TIME = 582, + RPC__PAYLOAD_RESP_WIFI_SET_COUNTRY_CODE = 590, + RPC__PAYLOAD_RESP_WIFI_GET_COUNTRY_CODE = 591, + RPC__PAYLOAD_RESP_WIFI_STA_GET_AID = 594, + RPC__PAYLOAD_RESP_WIFI_STA_GET_NEGOTIATED_PHYMODE = 595, + RPC__PAYLOAD_RESP_WIFI_STA_GET_RSSI = 597, + RPC__PAYLOAD_RESP_WIFI_SET_PROTOCOLS = 598, + RPC__PAYLOAD_RESP_WIFI_GET_PROTOCOLS = 599, + RPC__PAYLOAD_RESP_WIFI_SET_BANDWIDTHS = 600, + RPC__PAYLOAD_RESP_WIFI_GET_BANDWIDTHS = 601, + RPC__PAYLOAD_RESP_WIFI_SET_BAND = 602, + RPC__PAYLOAD_RESP_WIFI_GET_BAND = 603, + RPC__PAYLOAD_RESP_WIFI_SET_BANDMODE = 604, + RPC__PAYLOAD_RESP_WIFI_GET_BANDMODE = 605, + RPC__PAYLOAD_RESP_GET_COPROCESSOR_FWVERSION = 606, + RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_RECORD = 607, + RPC__PAYLOAD_RESP_SET_DHCP_DNS = 608, + RPC__PAYLOAD_RESP_GET_DHCP_DNS = 609, + RPC__PAYLOAD_RESP_WIFI_STA_TWT_CONFIG = 610, + RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SETUP = 611, + RPC__PAYLOAD_RESP_WIFI_STA_ITWT_TEARDOWN = 612, + RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SUSPEND = 613, + RPC__PAYLOAD_RESP_WIFI_STA_ITWT_GET_FLOW_ID_STATUS = 614, + RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SEND_PROBE_REQ = 615, + RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET = 616, + RPC__PAYLOAD_RESP_WIFI_STA_ENTERPRISE_ENABLE = 617, + RPC__PAYLOAD_RESP_WIFI_STA_ENTERPRISE_DISABLE = 618, + RPC__PAYLOAD_RESP_EAP_SET_IDENTITY = 619, + RPC__PAYLOAD_RESP_EAP_CLEAR_IDENTITY = 620, + RPC__PAYLOAD_RESP_EAP_SET_USERNAME = 621, + RPC__PAYLOAD_RESP_EAP_CLEAR_USERNAME = 622, + RPC__PAYLOAD_RESP_EAP_SET_PASSWORD = 623, + RPC__PAYLOAD_RESP_EAP_CLEAR_PASSWORD = 624, + RPC__PAYLOAD_RESP_EAP_SET_NEW_PASSWORD = 625, + RPC__PAYLOAD_RESP_EAP_CLEAR_NEW_PASSWORD = 626, + RPC__PAYLOAD_RESP_EAP_SET_CA_CERT = 627, + RPC__PAYLOAD_RESP_EAP_CLEAR_CA_CERT = 628, + RPC__PAYLOAD_RESP_EAP_SET_CERTIFICATE_AND_KEY = 629, + RPC__PAYLOAD_RESP_EAP_CLEAR_CERTIFICATE_AND_KEY = 630, + RPC__PAYLOAD_RESP_EAP_GET_DISABLE_TIME_CHECK = 631, + RPC__PAYLOAD_RESP_EAP_SET_TTLS_PHASE2_METHOD = 632, + RPC__PAYLOAD_RESP_EAP_SET_SUITEB_CERTIFICATION = 633, + RPC__PAYLOAD_RESP_EAP_SET_PAC_FILE = 634, + RPC__PAYLOAD_RESP_EAP_SET_FAST_PARAMS = 635, + RPC__PAYLOAD_RESP_EAP_USE_DEFAULT_CERT_BUNDLE = 636, + RPC__PAYLOAD_RESP_WIFI_SET_OKC_SUPPORT = 637, + RPC__PAYLOAD_RESP_EAP_SET_DOMAIN_NAME = 638, + RPC__PAYLOAD_RESP_EAP_SET_DISABLE_TIME_CHECK = 639, + RPC__PAYLOAD_RESP_EAP_SET_EAP_METHODS = 640, + RPC__PAYLOAD_RESP_IFACE_MAC_ADDR_SET_GET = 641, + RPC__PAYLOAD_RESP_IFACE_MAC_ADDR_LEN_GET = 642, + RPC__PAYLOAD_RESP_FEATURE_CONTROL = 643, + RPC__PAYLOAD_EVENT_ESP_INIT = 769, + RPC__PAYLOAD_EVENT_HEARTBEAT = 770, + RPC__PAYLOAD_EVENT_AP_STA_CONNECTED = 771, + RPC__PAYLOAD_EVENT_AP_STA_DISCONNECTED = 772, + RPC__PAYLOAD_EVENT_WIFI_EVENT_NO_ARGS = 773, + RPC__PAYLOAD_EVENT_STA_SCAN_DONE = 774, + RPC__PAYLOAD_EVENT_STA_CONNECTED = 775, + RPC__PAYLOAD_EVENT_STA_DISCONNECTED = 776, + RPC__PAYLOAD_EVENT_DHCP_DNS = 777, + RPC__PAYLOAD_EVENT_STA_ITWT_SETUP = 778, + RPC__PAYLOAD_EVENT_STA_ITWT_TEARDOWN = 779, + RPC__PAYLOAD_EVENT_STA_ITWT_SUSPEND = 780, + RPC__PAYLOAD_EVENT_STA_ITWT_PROBE = 781, + RPC__PAYLOAD_EVENT_SUPP_DPP_URI_READY = 782, + RPC__PAYLOAD_EVENT_SUPP_DPP_CFG_RECVD = 783, + RPC__PAYLOAD_EVENT_SUPP_DPP_FAIL = 784, + RPC__PAYLOAD_EVENT_WIFI_DPP_URI_READY = 785, + RPC__PAYLOAD_EVENT_WIFI_DPP_CFG_RECVD = 786, + RPC__PAYLOAD_EVENT_WIFI_DPP_FAIL = 787 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__PAYLOAD__CASE) +} Rpc__PayloadCase; + +struct Rpc +{ + ProtobufCMessage base; + /* + * msg_type could be req, resp or Event + */ + RpcType msg_type; + /* + * msg id + */ + RpcId msg_id; + /* + * UID of message + */ + uint32_t uid; + Rpc__PayloadCase payload_case; + union { + /* + ** Requests * + */ + RpcReqGetMacAddress *req_get_mac_address; + RpcReqSetMacAddress *req_set_mac_address; + RpcReqGetMode *req_get_wifi_mode; + RpcReqSetMode *req_set_wifi_mode; + RpcReqSuppDppInit *req_supp_dpp_init; + RpcReqSuppDppDeinit *req_supp_dpp_deinit; + RpcReqSuppDppBootstrapGen *req_supp_dpp_bootstrap_gen; + RpcReqSuppDppStartListen *req_supp_dpp_start_listen; + RpcReqSuppDppStopListen *req_supp_dpp_stop_listen; + RpcReqSetPs *req_wifi_set_ps; + RpcReqGetPs *req_wifi_get_ps; + RpcReqOTABegin *req_ota_begin; + RpcReqOTAWrite *req_ota_write; + RpcReqOTAEnd *req_ota_end; + RpcReqWifiSetMaxTxPower *req_set_wifi_max_tx_power; + RpcReqWifiGetMaxTxPower *req_get_wifi_max_tx_power; + RpcReqConfigHeartbeat *req_config_heartbeat; + RpcReqWifiInit *req_wifi_init; + RpcReqWifiDeinit *req_wifi_deinit; + RpcReqWifiStart *req_wifi_start; + RpcReqWifiStop *req_wifi_stop; + RpcReqWifiConnect *req_wifi_connect; + RpcReqWifiDisconnect *req_wifi_disconnect; + RpcReqWifiSetConfig *req_wifi_set_config; + RpcReqWifiGetConfig *req_wifi_get_config; + RpcReqWifiScanStart *req_wifi_scan_start; + RpcReqWifiScanStop *req_wifi_scan_stop; + RpcReqWifiScanGetApNum *req_wifi_scan_get_ap_num; + RpcReqWifiScanGetApRecords *req_wifi_scan_get_ap_records; + RpcReqWifiClearApList *req_wifi_clear_ap_list; + RpcReqWifiRestore *req_wifi_restore; + RpcReqWifiClearFastConnect *req_wifi_clear_fast_connect; + RpcReqWifiDeauthSta *req_wifi_deauth_sta; + RpcReqWifiStaGetApInfo *req_wifi_sta_get_ap_info; + RpcReqWifiSetProtocol *req_wifi_set_protocol; + RpcReqWifiGetProtocol *req_wifi_get_protocol; + RpcReqWifiSetBandwidth *req_wifi_set_bandwidth; + RpcReqWifiGetBandwidth *req_wifi_get_bandwidth; + RpcReqWifiSetChannel *req_wifi_set_channel; + RpcReqWifiGetChannel *req_wifi_get_channel; + RpcReqWifiSetCountry *req_wifi_set_country; + RpcReqWifiGetCountry *req_wifi_get_country; + RpcReqWifiApGetStaList *req_wifi_ap_get_sta_list; + RpcReqWifiApGetStaAid *req_wifi_ap_get_sta_aid; + RpcReqWifiSetStorage *req_wifi_set_storage; + RpcReqWifiSetInactiveTime *req_wifi_set_inactive_time; + RpcReqWifiGetInactiveTime *req_wifi_get_inactive_time; + RpcReqWifiSetCountryCode *req_wifi_set_country_code; + RpcReqWifiGetCountryCode *req_wifi_get_country_code; + RpcReqWifiStaGetAid *req_wifi_sta_get_aid; + RpcReqWifiStaGetNegotiatedPhymode *req_wifi_sta_get_negotiated_phymode; + RpcReqWifiStaGetRssi *req_wifi_sta_get_rssi; + RpcReqWifiSetProtocols *req_wifi_set_protocols; + RpcReqWifiGetProtocols *req_wifi_get_protocols; + RpcReqWifiSetBandwidths *req_wifi_set_bandwidths; + RpcReqWifiGetBandwidths *req_wifi_get_bandwidths; + RpcReqWifiSetBand *req_wifi_set_band; + RpcReqWifiGetBand *req_wifi_get_band; + RpcReqWifiSetBandMode *req_wifi_set_bandmode; + RpcReqWifiGetBandMode *req_wifi_get_bandmode; + RpcReqGetCoprocessorFwVersion *req_get_coprocessor_fwversion; + RpcReqWifiScanGetApRecord *req_wifi_scan_get_ap_record; + RpcReqSetDhcpDnsStatus *req_set_dhcp_dns; + RpcReqGetDhcpDnsStatus *req_get_dhcp_dns; + RpcReqWifiStaTwtConfig *req_wifi_sta_twt_config; + RpcReqWifiStaItwtSetup *req_wifi_sta_itwt_setup; + RpcReqWifiStaItwtTeardown *req_wifi_sta_itwt_teardown; + RpcReqWifiStaItwtSuspend *req_wifi_sta_itwt_suspend; + RpcReqWifiStaItwtGetFlowIdStatus *req_wifi_sta_itwt_get_flow_id_status; + RpcReqWifiStaItwtSendProbeReq *req_wifi_sta_itwt_send_probe_req; + RpcReqWifiStaItwtSetTargetWakeTimeOffset *req_wifi_sta_itwt_set_target_wake_time_offset; + RpcReqWifiStaEnterpriseEnable *req_wifi_sta_enterprise_enable; + RpcReqWifiStaEnterpriseDisable *req_wifi_sta_enterprise_disable; + RpcReqEapSetIdentity *req_eap_set_identity; + RpcReqEapClearIdentity *req_eap_clear_identity; + RpcReqEapSetUsername *req_eap_set_username; + RpcReqEapClearUsername *req_eap_clear_username; + RpcReqEapSetPassword *req_eap_set_password; + RpcReqEapClearPassword *req_eap_clear_password; + RpcReqEapSetNewPassword *req_eap_set_new_password; + RpcReqEapClearNewPassword *req_eap_clear_new_password; + RpcReqEapSetCaCert *req_eap_set_ca_cert; + RpcReqEapClearCaCert *req_eap_clear_ca_cert; + RpcReqEapSetCertificateAndKey *req_eap_set_certificate_and_key; + RpcReqEapClearCertificateAndKey *req_eap_clear_certificate_and_key; + RpcReqEapGetDisableTimeCheck *req_eap_get_disable_time_check; + RpcReqEapSetTtlsPhase2Method *req_eap_set_ttls_phase2_method; + RpcReqEapSetSuiteb192bitCertification *req_eap_set_suiteb_certification; + RpcReqEapSetPacFile *req_eap_set_pac_file; + RpcReqEapSetFastParams *req_eap_set_fast_params; + RpcReqEapUseDefaultCertBundle *req_eap_use_default_cert_bundle; + RpcReqWifiSetOkcSupport *req_wifi_set_okc_support; + RpcReqEapSetDomainName *req_eap_set_domain_name; + RpcReqEapSetDisableTimeCheck *req_eap_set_disable_time_check; + RpcReqEapSetEapMethods *req_eap_set_eap_methods; + RpcReqIfaceMacAddrSetGet *req_iface_mac_addr_set_get; + RpcReqIfaceMacAddrLenGet *req_iface_mac_addr_len_get; + RpcReqFeatureControl *req_feature_control; + /* + ** Responses * + */ + RpcRespGetMacAddress *resp_get_mac_address; + RpcRespSetMacAddress *resp_set_mac_address; + RpcRespGetMode *resp_get_wifi_mode; + RpcRespSetMode *resp_set_wifi_mode; + RpcRespSuppDppInit *resp_supp_dpp_init; + RpcRespSuppDppDeinit *resp_supp_dpp_deinit; + RpcRespSuppDppBootstrapGen *resp_supp_dpp_bootstrap_gen; + RpcRespSuppDppStartListen *resp_supp_dpp_start_listen; + RpcRespSuppDppStopListen *resp_supp_dpp_stop_listen; + RpcRespSetPs *resp_wifi_set_ps; + RpcRespGetPs *resp_wifi_get_ps; + RpcRespOTABegin *resp_ota_begin; + RpcRespOTAWrite *resp_ota_write; + RpcRespOTAEnd *resp_ota_end; + RpcRespWifiSetMaxTxPower *resp_set_wifi_max_tx_power; + RpcRespWifiGetMaxTxPower *resp_get_wifi_max_tx_power; + RpcRespConfigHeartbeat *resp_config_heartbeat; + RpcRespWifiInit *resp_wifi_init; + RpcRespWifiDeinit *resp_wifi_deinit; + RpcRespWifiStart *resp_wifi_start; + RpcRespWifiStop *resp_wifi_stop; + RpcRespWifiConnect *resp_wifi_connect; + RpcRespWifiDisconnect *resp_wifi_disconnect; + RpcRespWifiSetConfig *resp_wifi_set_config; + RpcRespWifiGetConfig *resp_wifi_get_config; + RpcRespWifiScanStart *resp_wifi_scan_start; + RpcRespWifiScanStop *resp_wifi_scan_stop; + RpcRespWifiScanGetApNum *resp_wifi_scan_get_ap_num; + RpcRespWifiScanGetApRecords *resp_wifi_scan_get_ap_records; + RpcRespWifiClearApList *resp_wifi_clear_ap_list; + RpcRespWifiRestore *resp_wifi_restore; + RpcRespWifiClearFastConnect *resp_wifi_clear_fast_connect; + RpcRespWifiDeauthSta *resp_wifi_deauth_sta; + RpcRespWifiStaGetApInfo *resp_wifi_sta_get_ap_info; + RpcRespWifiSetProtocol *resp_wifi_set_protocol; + RpcRespWifiGetProtocol *resp_wifi_get_protocol; + RpcRespWifiSetBandwidth *resp_wifi_set_bandwidth; + RpcRespWifiGetBandwidth *resp_wifi_get_bandwidth; + RpcRespWifiSetChannel *resp_wifi_set_channel; + RpcRespWifiGetChannel *resp_wifi_get_channel; + RpcRespWifiSetCountry *resp_wifi_set_country; + RpcRespWifiGetCountry *resp_wifi_get_country; + RpcRespWifiApGetStaList *resp_wifi_ap_get_sta_list; + RpcRespWifiApGetStaAid *resp_wifi_ap_get_sta_aid; + RpcRespWifiSetStorage *resp_wifi_set_storage; + RpcRespWifiSetInactiveTime *resp_wifi_set_inactive_time; + RpcRespWifiGetInactiveTime *resp_wifi_get_inactive_time; + RpcRespWifiSetCountryCode *resp_wifi_set_country_code; + RpcRespWifiGetCountryCode *resp_wifi_get_country_code; + RpcRespWifiStaGetAid *resp_wifi_sta_get_aid; + RpcRespWifiStaGetNegotiatedPhymode *resp_wifi_sta_get_negotiated_phymode; + RpcRespWifiStaGetRssi *resp_wifi_sta_get_rssi; + RpcRespWifiSetProtocols *resp_wifi_set_protocols; + RpcRespWifiGetProtocols *resp_wifi_get_protocols; + RpcRespWifiSetBandwidths *resp_wifi_set_bandwidths; + RpcRespWifiGetBandwidths *resp_wifi_get_bandwidths; + RpcRespWifiSetBand *resp_wifi_set_band; + RpcRespWifiGetBand *resp_wifi_get_band; + RpcRespWifiSetBandMode *resp_wifi_set_bandmode; + RpcRespWifiGetBandMode *resp_wifi_get_bandmode; + RpcRespGetCoprocessorFwVersion *resp_get_coprocessor_fwversion; + RpcRespWifiScanGetApRecord *resp_wifi_scan_get_ap_record; + RpcRespSetDhcpDnsStatus *resp_set_dhcp_dns; + RpcRespGetDhcpDnsStatus *resp_get_dhcp_dns; + RpcRespWifiStaTwtConfig *resp_wifi_sta_twt_config; + RpcRespWifiStaItwtSetup *resp_wifi_sta_itwt_setup; + RpcRespWifiStaItwtTeardown *resp_wifi_sta_itwt_teardown; + RpcRespWifiStaItwtSuspend *resp_wifi_sta_itwt_suspend; + RpcRespWifiStaItwtGetFlowIdStatus *resp_wifi_sta_itwt_get_flow_id_status; + RpcRespWifiStaItwtSendProbeReq *resp_wifi_sta_itwt_send_probe_req; + RpcRespWifiStaItwtSetTargetWakeTimeOffset *resp_wifi_sta_itwt_set_target_wake_time_offset; + RpcRespWifiStaEnterpriseEnable *resp_wifi_sta_enterprise_enable; + RpcRespWifiStaEnterpriseDisable *resp_wifi_sta_enterprise_disable; + RpcRespEapSetIdentity *resp_eap_set_identity; + RpcRespEapClearIdentity *resp_eap_clear_identity; + RpcRespEapSetUsername *resp_eap_set_username; + RpcRespEapClearUsername *resp_eap_clear_username; + RpcRespEapSetPassword *resp_eap_set_password; + RpcRespEapClearPassword *resp_eap_clear_password; + RpcRespEapSetNewPassword *resp_eap_set_new_password; + RpcRespEapClearNewPassword *resp_eap_clear_new_password; + RpcRespEapSetCaCert *resp_eap_set_ca_cert; + RpcRespEapClearCaCert *resp_eap_clear_ca_cert; + RpcRespEapSetCertificateAndKey *resp_eap_set_certificate_and_key; + RpcRespEapClearCertificateAndKey *resp_eap_clear_certificate_and_key; + RpcRespEapGetDisableTimeCheck *resp_eap_get_disable_time_check; + RpcRespEapSetTtlsPhase2Method *resp_eap_set_ttls_phase2_method; + RpcRespEapSetSuiteb192bitCertification *resp_eap_set_suiteb_certification; + RpcRespEapSetPacFile *resp_eap_set_pac_file; + RpcRespEapSetFastParams *resp_eap_set_fast_params; + RpcRespEapUseDefaultCertBundle *resp_eap_use_default_cert_bundle; + RpcRespWifiSetOkcSupport *resp_wifi_set_okc_support; + RpcRespEapSetDomainName *resp_eap_set_domain_name; + RpcRespEapSetDisableTimeCheck *resp_eap_set_disable_time_check; + RpcRespEapSetEapMethods *resp_eap_set_eap_methods; + RpcRespIfaceMacAddrSetGet *resp_iface_mac_addr_set_get; + RpcRespIfaceMacAddrLenGet *resp_iface_mac_addr_len_get; + RpcRespFeatureControl *resp_feature_control; + /* + ** Notifications * + */ + RpcEventESPInit *event_esp_init; + RpcEventHeartbeat *event_heartbeat; + RpcEventAPStaConnected *event_ap_sta_connected; + RpcEventAPStaDisconnected *event_ap_sta_disconnected; + RpcEventWifiEventNoArgs *event_wifi_event_no_args; + RpcEventStaScanDone *event_sta_scan_done; + RpcEventStaConnected *event_sta_connected; + RpcEventStaDisconnected *event_sta_disconnected; + RpcEventDhcpDnsStatus *event_dhcp_dns; + RpcEventStaItwtSetup *event_sta_itwt_setup; + RpcEventStaItwtTeardown *event_sta_itwt_teardown; + RpcEventStaItwtSuspend *event_sta_itwt_suspend; + RpcEventStaItwtProbe *event_sta_itwt_probe; + RpcEventSuppDppUriReady *event_supp_dpp_uri_ready; + RpcEventSuppDppCfgRecvd *event_supp_dpp_cfg_recvd; + RpcEventSuppDppFail *event_supp_dpp_fail; + RpcEventWifiDppUriReady *event_wifi_dpp_uri_ready; + RpcEventWifiDppCfgRecvd *event_wifi_dpp_cfg_recvd; + RpcEventWifiDppFail *event_wifi_dpp_fail; + }; +}; +#define RPC__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&rpc__descriptor) \ + , RPC_TYPE__MsgType_Invalid, RPC_ID__MsgId_Invalid, 0, RPC__PAYLOAD__NOT_SET, {0} } + + +/* WifiInitConfig methods */ +void wifi_init_config__init + (WifiInitConfig *message); +size_t wifi_init_config__get_packed_size + (const WifiInitConfig *message); +size_t wifi_init_config__pack + (const WifiInitConfig *message, + uint8_t *out); +size_t wifi_init_config__pack_to_buffer + (const WifiInitConfig *message, + ProtobufCBuffer *buffer); +WifiInitConfig * + wifi_init_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_init_config__free_unpacked + (WifiInitConfig *message, + ProtobufCAllocator *allocator); +/* WifiCountry methods */ +void wifi_country__init + (WifiCountry *message); +size_t wifi_country__get_packed_size + (const WifiCountry *message); +size_t wifi_country__pack + (const WifiCountry *message, + uint8_t *out); +size_t wifi_country__pack_to_buffer + (const WifiCountry *message, + ProtobufCBuffer *buffer); +WifiCountry * + wifi_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_country__free_unpacked + (WifiCountry *message, + ProtobufCAllocator *allocator); +/* WifiActiveScanTime methods */ +void wifi_active_scan_time__init + (WifiActiveScanTime *message); +size_t wifi_active_scan_time__get_packed_size + (const WifiActiveScanTime *message); +size_t wifi_active_scan_time__pack + (const WifiActiveScanTime *message, + uint8_t *out); +size_t wifi_active_scan_time__pack_to_buffer + (const WifiActiveScanTime *message, + ProtobufCBuffer *buffer); +WifiActiveScanTime * + wifi_active_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_active_scan_time__free_unpacked + (WifiActiveScanTime *message, + ProtobufCAllocator *allocator); +/* WifiScanTime methods */ +void wifi_scan_time__init + (WifiScanTime *message); +size_t wifi_scan_time__get_packed_size + (const WifiScanTime *message); +size_t wifi_scan_time__pack + (const WifiScanTime *message, + uint8_t *out); +size_t wifi_scan_time__pack_to_buffer + (const WifiScanTime *message, + ProtobufCBuffer *buffer); +WifiScanTime * + wifi_scan_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_time__free_unpacked + (WifiScanTime *message, + ProtobufCAllocator *allocator); +/* WifiScanChannelBitmap methods */ +void wifi_scan_channel_bitmap__init + (WifiScanChannelBitmap *message); +size_t wifi_scan_channel_bitmap__get_packed_size + (const WifiScanChannelBitmap *message); +size_t wifi_scan_channel_bitmap__pack + (const WifiScanChannelBitmap *message, + uint8_t *out); +size_t wifi_scan_channel_bitmap__pack_to_buffer + (const WifiScanChannelBitmap *message, + ProtobufCBuffer *buffer); +WifiScanChannelBitmap * + wifi_scan_channel_bitmap__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_channel_bitmap__free_unpacked + (WifiScanChannelBitmap *message, + ProtobufCAllocator *allocator); +/* WifiScanConfig methods */ +void wifi_scan_config__init + (WifiScanConfig *message); +size_t wifi_scan_config__get_packed_size + (const WifiScanConfig *message); +size_t wifi_scan_config__pack + (const WifiScanConfig *message, + uint8_t *out); +size_t wifi_scan_config__pack_to_buffer + (const WifiScanConfig *message, + ProtobufCBuffer *buffer); +WifiScanConfig * + wifi_scan_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_config__free_unpacked + (WifiScanConfig *message, + ProtobufCAllocator *allocator); +/* WifiHeApInfo methods */ +void wifi_he_ap_info__init + (WifiHeApInfo *message); +size_t wifi_he_ap_info__get_packed_size + (const WifiHeApInfo *message); +size_t wifi_he_ap_info__pack + (const WifiHeApInfo *message, + uint8_t *out); +size_t wifi_he_ap_info__pack_to_buffer + (const WifiHeApInfo *message, + ProtobufCBuffer *buffer); +WifiHeApInfo * + wifi_he_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_he_ap_info__free_unpacked + (WifiHeApInfo *message, + ProtobufCAllocator *allocator); +/* WifiApRecord methods */ +void wifi_ap_record__init + (WifiApRecord *message); +size_t wifi_ap_record__get_packed_size + (const WifiApRecord *message); +size_t wifi_ap_record__pack + (const WifiApRecord *message, + uint8_t *out); +size_t wifi_ap_record__pack_to_buffer + (const WifiApRecord *message, + ProtobufCBuffer *buffer); +WifiApRecord * + wifi_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ap_record__free_unpacked + (WifiApRecord *message, + ProtobufCAllocator *allocator); +/* WifiScanThreshold methods */ +void wifi_scan_threshold__init + (WifiScanThreshold *message); +size_t wifi_scan_threshold__get_packed_size + (const WifiScanThreshold *message); +size_t wifi_scan_threshold__pack + (const WifiScanThreshold *message, + uint8_t *out); +size_t wifi_scan_threshold__pack_to_buffer + (const WifiScanThreshold *message, + ProtobufCBuffer *buffer); +WifiScanThreshold * + wifi_scan_threshold__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_scan_threshold__free_unpacked + (WifiScanThreshold *message, + ProtobufCAllocator *allocator); +/* WifiPmfConfig methods */ +void wifi_pmf_config__init + (WifiPmfConfig *message); +size_t wifi_pmf_config__get_packed_size + (const WifiPmfConfig *message); +size_t wifi_pmf_config__pack + (const WifiPmfConfig *message, + uint8_t *out); +size_t wifi_pmf_config__pack_to_buffer + (const WifiPmfConfig *message, + ProtobufCBuffer *buffer); +WifiPmfConfig * + wifi_pmf_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_pmf_config__free_unpacked + (WifiPmfConfig *message, + ProtobufCAllocator *allocator); +/* WifiBssMaxIdleConfig methods */ +void wifi_bss_max_idle_config__init + (WifiBssMaxIdleConfig *message); +size_t wifi_bss_max_idle_config__get_packed_size + (const WifiBssMaxIdleConfig *message); +size_t wifi_bss_max_idle_config__pack + (const WifiBssMaxIdleConfig *message, + uint8_t *out); +size_t wifi_bss_max_idle_config__pack_to_buffer + (const WifiBssMaxIdleConfig *message, + ProtobufCBuffer *buffer); +WifiBssMaxIdleConfig * + wifi_bss_max_idle_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_bss_max_idle_config__free_unpacked + (WifiBssMaxIdleConfig *message, + ProtobufCAllocator *allocator); +/* WifiApConfig methods */ +void wifi_ap_config__init + (WifiApConfig *message); +size_t wifi_ap_config__get_packed_size + (const WifiApConfig *message); +size_t wifi_ap_config__pack + (const WifiApConfig *message, + uint8_t *out); +size_t wifi_ap_config__pack_to_buffer + (const WifiApConfig *message, + ProtobufCBuffer *buffer); +WifiApConfig * + wifi_ap_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ap_config__free_unpacked + (WifiApConfig *message, + ProtobufCAllocator *allocator); +/* WifiStaConfig methods */ +void wifi_sta_config__init + (WifiStaConfig *message); +size_t wifi_sta_config__get_packed_size + (const WifiStaConfig *message); +size_t wifi_sta_config__pack + (const WifiStaConfig *message, + uint8_t *out); +size_t wifi_sta_config__pack_to_buffer + (const WifiStaConfig *message, + ProtobufCBuffer *buffer); +WifiStaConfig * + wifi_sta_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_sta_config__free_unpacked + (WifiStaConfig *message, + ProtobufCAllocator *allocator); +/* WifiConfig methods */ +void wifi_config__init + (WifiConfig *message); +size_t wifi_config__get_packed_size + (const WifiConfig *message); +size_t wifi_config__pack + (const WifiConfig *message, + uint8_t *out); +size_t wifi_config__pack_to_buffer + (const WifiConfig *message, + ProtobufCBuffer *buffer); +WifiConfig * + wifi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_config__free_unpacked + (WifiConfig *message, + ProtobufCAllocator *allocator); +/* WifiStaInfo methods */ +void wifi_sta_info__init + (WifiStaInfo *message); +size_t wifi_sta_info__get_packed_size + (const WifiStaInfo *message); +size_t wifi_sta_info__pack + (const WifiStaInfo *message, + uint8_t *out); +size_t wifi_sta_info__pack_to_buffer + (const WifiStaInfo *message, + ProtobufCBuffer *buffer); +WifiStaInfo * + wifi_sta_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_sta_info__free_unpacked + (WifiStaInfo *message, + ProtobufCAllocator *allocator); +/* WifiStaList methods */ +void wifi_sta_list__init + (WifiStaList *message); +size_t wifi_sta_list__get_packed_size + (const WifiStaList *message); +size_t wifi_sta_list__pack + (const WifiStaList *message, + uint8_t *out); +size_t wifi_sta_list__pack_to_buffer + (const WifiStaList *message, + ProtobufCBuffer *buffer); +WifiStaList * + wifi_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_sta_list__free_unpacked + (WifiStaList *message, + ProtobufCAllocator *allocator); +/* WifiPktRxCtrl methods */ +void wifi_pkt_rx_ctrl__init + (WifiPktRxCtrl *message); +size_t wifi_pkt_rx_ctrl__get_packed_size + (const WifiPktRxCtrl *message); +size_t wifi_pkt_rx_ctrl__pack + (const WifiPktRxCtrl *message, + uint8_t *out); +size_t wifi_pkt_rx_ctrl__pack_to_buffer + (const WifiPktRxCtrl *message, + ProtobufCBuffer *buffer); +WifiPktRxCtrl * + wifi_pkt_rx_ctrl__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_pkt_rx_ctrl__free_unpacked + (WifiPktRxCtrl *message, + ProtobufCAllocator *allocator); +/* WifiPromiscuousPkt methods */ +void wifi_promiscuous_pkt__init + (WifiPromiscuousPkt *message); +size_t wifi_promiscuous_pkt__get_packed_size + (const WifiPromiscuousPkt *message); +size_t wifi_promiscuous_pkt__pack + (const WifiPromiscuousPkt *message, + uint8_t *out); +size_t wifi_promiscuous_pkt__pack_to_buffer + (const WifiPromiscuousPkt *message, + ProtobufCBuffer *buffer); +WifiPromiscuousPkt * + wifi_promiscuous_pkt__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_promiscuous_pkt__free_unpacked + (WifiPromiscuousPkt *message, + ProtobufCAllocator *allocator); +/* WifiPromiscuousFilter methods */ +void wifi_promiscuous_filter__init + (WifiPromiscuousFilter *message); +size_t wifi_promiscuous_filter__get_packed_size + (const WifiPromiscuousFilter *message); +size_t wifi_promiscuous_filter__pack + (const WifiPromiscuousFilter *message, + uint8_t *out); +size_t wifi_promiscuous_filter__pack_to_buffer + (const WifiPromiscuousFilter *message, + ProtobufCBuffer *buffer); +WifiPromiscuousFilter * + wifi_promiscuous_filter__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_promiscuous_filter__free_unpacked + (WifiPromiscuousFilter *message, + ProtobufCAllocator *allocator); +/* WifiCsiConfig methods */ +void wifi_csi_config__init + (WifiCsiConfig *message); +size_t wifi_csi_config__get_packed_size + (const WifiCsiConfig *message); +size_t wifi_csi_config__pack + (const WifiCsiConfig *message, + uint8_t *out); +size_t wifi_csi_config__pack_to_buffer + (const WifiCsiConfig *message, + ProtobufCBuffer *buffer); +WifiCsiConfig * + wifi_csi_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_csi_config__free_unpacked + (WifiCsiConfig *message, + ProtobufCAllocator *allocator); +/* WifiCsiInfo methods */ +void wifi_csi_info__init + (WifiCsiInfo *message); +size_t wifi_csi_info__get_packed_size + (const WifiCsiInfo *message); +size_t wifi_csi_info__pack + (const WifiCsiInfo *message, + uint8_t *out); +size_t wifi_csi_info__pack_to_buffer + (const WifiCsiInfo *message, + ProtobufCBuffer *buffer); +WifiCsiInfo * + wifi_csi_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_csi_info__free_unpacked + (WifiCsiInfo *message, + ProtobufCAllocator *allocator); +/* WifiAntGpio methods */ +void wifi_ant_gpio__init + (WifiAntGpio *message); +size_t wifi_ant_gpio__get_packed_size + (const WifiAntGpio *message); +size_t wifi_ant_gpio__pack + (const WifiAntGpio *message, + uint8_t *out); +size_t wifi_ant_gpio__pack_to_buffer + (const WifiAntGpio *message, + ProtobufCBuffer *buffer); +WifiAntGpio * + wifi_ant_gpio__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ant_gpio__free_unpacked + (WifiAntGpio *message, + ProtobufCAllocator *allocator); +/* WifiAntGpioConfig methods */ +void wifi_ant_gpio_config__init + (WifiAntGpioConfig *message); +size_t wifi_ant_gpio_config__get_packed_size + (const WifiAntGpioConfig *message); +size_t wifi_ant_gpio_config__pack + (const WifiAntGpioConfig *message, + uint8_t *out); +size_t wifi_ant_gpio_config__pack_to_buffer + (const WifiAntGpioConfig *message, + ProtobufCBuffer *buffer); +WifiAntGpioConfig * + wifi_ant_gpio_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ant_gpio_config__free_unpacked + (WifiAntGpioConfig *message, + ProtobufCAllocator *allocator); +/* WifiAntConfig methods */ +void wifi_ant_config__init + (WifiAntConfig *message); +size_t wifi_ant_config__get_packed_size + (const WifiAntConfig *message); +size_t wifi_ant_config__pack + (const WifiAntConfig *message, + uint8_t *out); +size_t wifi_ant_config__pack_to_buffer + (const WifiAntConfig *message, + ProtobufCBuffer *buffer); +WifiAntConfig * + wifi_ant_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ant_config__free_unpacked + (WifiAntConfig *message, + ProtobufCAllocator *allocator); +/* WifiActionTxReq methods */ +void wifi_action_tx_req__init + (WifiActionTxReq *message); +size_t wifi_action_tx_req__get_packed_size + (const WifiActionTxReq *message); +size_t wifi_action_tx_req__pack + (const WifiActionTxReq *message, + uint8_t *out); +size_t wifi_action_tx_req__pack_to_buffer + (const WifiActionTxReq *message, + ProtobufCBuffer *buffer); +WifiActionTxReq * + wifi_action_tx_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_action_tx_req__free_unpacked + (WifiActionTxReq *message, + ProtobufCAllocator *allocator); +/* WifiFtmInitiatorCfg methods */ +void wifi_ftm_initiator_cfg__init + (WifiFtmInitiatorCfg *message); +size_t wifi_ftm_initiator_cfg__get_packed_size + (const WifiFtmInitiatorCfg *message); +size_t wifi_ftm_initiator_cfg__pack + (const WifiFtmInitiatorCfg *message, + uint8_t *out); +size_t wifi_ftm_initiator_cfg__pack_to_buffer + (const WifiFtmInitiatorCfg *message, + ProtobufCBuffer *buffer); +WifiFtmInitiatorCfg * + wifi_ftm_initiator_cfg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ftm_initiator_cfg__free_unpacked + (WifiFtmInitiatorCfg *message, + ProtobufCAllocator *allocator); +/* WifiEventStaScanDone methods */ +void wifi_event_sta_scan_done__init + (WifiEventStaScanDone *message); +size_t wifi_event_sta_scan_done__get_packed_size + (const WifiEventStaScanDone *message); +size_t wifi_event_sta_scan_done__pack + (const WifiEventStaScanDone *message, + uint8_t *out); +size_t wifi_event_sta_scan_done__pack_to_buffer + (const WifiEventStaScanDone *message, + ProtobufCBuffer *buffer); +WifiEventStaScanDone * + wifi_event_sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_scan_done__free_unpacked + (WifiEventStaScanDone *message, + ProtobufCAllocator *allocator); +/* WifiEventStaConnected methods */ +void wifi_event_sta_connected__init + (WifiEventStaConnected *message); +size_t wifi_event_sta_connected__get_packed_size + (const WifiEventStaConnected *message); +size_t wifi_event_sta_connected__pack + (const WifiEventStaConnected *message, + uint8_t *out); +size_t wifi_event_sta_connected__pack_to_buffer + (const WifiEventStaConnected *message, + ProtobufCBuffer *buffer); +WifiEventStaConnected * + wifi_event_sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_connected__free_unpacked + (WifiEventStaConnected *message, + ProtobufCAllocator *allocator); +/* WifiEventStaDisconnected methods */ +void wifi_event_sta_disconnected__init + (WifiEventStaDisconnected *message); +size_t wifi_event_sta_disconnected__get_packed_size + (const WifiEventStaDisconnected *message); +size_t wifi_event_sta_disconnected__pack + (const WifiEventStaDisconnected *message, + uint8_t *out); +size_t wifi_event_sta_disconnected__pack_to_buffer + (const WifiEventStaDisconnected *message, + ProtobufCBuffer *buffer); +WifiEventStaDisconnected * + wifi_event_sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_disconnected__free_unpacked + (WifiEventStaDisconnected *message, + ProtobufCAllocator *allocator); +/* WifiEventStaAuthmodeChange methods */ +void wifi_event_sta_authmode_change__init + (WifiEventStaAuthmodeChange *message); +size_t wifi_event_sta_authmode_change__get_packed_size + (const WifiEventStaAuthmodeChange *message); +size_t wifi_event_sta_authmode_change__pack + (const WifiEventStaAuthmodeChange *message, + uint8_t *out); +size_t wifi_event_sta_authmode_change__pack_to_buffer + (const WifiEventStaAuthmodeChange *message, + ProtobufCBuffer *buffer); +WifiEventStaAuthmodeChange * + wifi_event_sta_authmode_change__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_authmode_change__free_unpacked + (WifiEventStaAuthmodeChange *message, + ProtobufCAllocator *allocator); +/* WifiEventStaWpsErPin methods */ +void wifi_event_sta_wps_er_pin__init + (WifiEventStaWpsErPin *message); +size_t wifi_event_sta_wps_er_pin__get_packed_size + (const WifiEventStaWpsErPin *message); +size_t wifi_event_sta_wps_er_pin__pack + (const WifiEventStaWpsErPin *message, + uint8_t *out); +size_t wifi_event_sta_wps_er_pin__pack_to_buffer + (const WifiEventStaWpsErPin *message, + ProtobufCBuffer *buffer); +WifiEventStaWpsErPin * + wifi_event_sta_wps_er_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_wps_er_pin__free_unpacked + (WifiEventStaWpsErPin *message, + ProtobufCAllocator *allocator); +/* ApCred methods */ +void ap_cred__init + (ApCred *message); +size_t ap_cred__get_packed_size + (const ApCred *message); +size_t ap_cred__pack + (const ApCred *message, + uint8_t *out); +size_t ap_cred__pack_to_buffer + (const ApCred *message, + ProtobufCBuffer *buffer); +ApCred * + ap_cred__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ap_cred__free_unpacked + (ApCred *message, + ProtobufCAllocator *allocator); +/* WifiEventStaWpsErSuccess methods */ +void wifi_event_sta_wps_er_success__init + (WifiEventStaWpsErSuccess *message); +size_t wifi_event_sta_wps_er_success__get_packed_size + (const WifiEventStaWpsErSuccess *message); +size_t wifi_event_sta_wps_er_success__pack + (const WifiEventStaWpsErSuccess *message, + uint8_t *out); +size_t wifi_event_sta_wps_er_success__pack_to_buffer + (const WifiEventStaWpsErSuccess *message, + ProtobufCBuffer *buffer); +WifiEventStaWpsErSuccess * + wifi_event_sta_wps_er_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_sta_wps_er_success__free_unpacked + (WifiEventStaWpsErSuccess *message, + ProtobufCAllocator *allocator); +/* WifiEventApProbeReqRx methods */ +void wifi_event_ap_probe_req_rx__init + (WifiEventApProbeReqRx *message); +size_t wifi_event_ap_probe_req_rx__get_packed_size + (const WifiEventApProbeReqRx *message); +size_t wifi_event_ap_probe_req_rx__pack + (const WifiEventApProbeReqRx *message, + uint8_t *out); +size_t wifi_event_ap_probe_req_rx__pack_to_buffer + (const WifiEventApProbeReqRx *message, + ProtobufCBuffer *buffer); +WifiEventApProbeReqRx * + wifi_event_ap_probe_req_rx__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_probe_req_rx__free_unpacked + (WifiEventApProbeReqRx *message, + ProtobufCAllocator *allocator); +/* WifiEventBssRssiLow methods */ +void wifi_event_bss_rssi_low__init + (WifiEventBssRssiLow *message); +size_t wifi_event_bss_rssi_low__get_packed_size + (const WifiEventBssRssiLow *message); +size_t wifi_event_bss_rssi_low__pack + (const WifiEventBssRssiLow *message, + uint8_t *out); +size_t wifi_event_bss_rssi_low__pack_to_buffer + (const WifiEventBssRssiLow *message, + ProtobufCBuffer *buffer); +WifiEventBssRssiLow * + wifi_event_bss_rssi_low__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_bss_rssi_low__free_unpacked + (WifiEventBssRssiLow *message, + ProtobufCAllocator *allocator); +/* WifiFtmReportEntry methods */ +void wifi_ftm_report_entry__init + (WifiFtmReportEntry *message); +size_t wifi_ftm_report_entry__get_packed_size + (const WifiFtmReportEntry *message); +size_t wifi_ftm_report_entry__pack + (const WifiFtmReportEntry *message, + uint8_t *out); +size_t wifi_ftm_report_entry__pack_to_buffer + (const WifiFtmReportEntry *message, + ProtobufCBuffer *buffer); +WifiFtmReportEntry * + wifi_ftm_report_entry__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_ftm_report_entry__free_unpacked + (WifiFtmReportEntry *message, + ProtobufCAllocator *allocator); +/* WifiEventFtmReport methods */ +void wifi_event_ftm_report__init + (WifiEventFtmReport *message); +size_t wifi_event_ftm_report__get_packed_size + (const WifiEventFtmReport *message); +size_t wifi_event_ftm_report__pack + (const WifiEventFtmReport *message, + uint8_t *out); +size_t wifi_event_ftm_report__pack_to_buffer + (const WifiEventFtmReport *message, + ProtobufCBuffer *buffer); +WifiEventFtmReport * + wifi_event_ftm_report__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ftm_report__free_unpacked + (WifiEventFtmReport *message, + ProtobufCAllocator *allocator); +/* WifiEventActionTxStatus methods */ +void wifi_event_action_tx_status__init + (WifiEventActionTxStatus *message); +size_t wifi_event_action_tx_status__get_packed_size + (const WifiEventActionTxStatus *message); +size_t wifi_event_action_tx_status__pack + (const WifiEventActionTxStatus *message, + uint8_t *out); +size_t wifi_event_action_tx_status__pack_to_buffer + (const WifiEventActionTxStatus *message, + ProtobufCBuffer *buffer); +WifiEventActionTxStatus * + wifi_event_action_tx_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_action_tx_status__free_unpacked + (WifiEventActionTxStatus *message, + ProtobufCAllocator *allocator); +/* WifiEventRocDone methods */ +void wifi_event_roc_done__init + (WifiEventRocDone *message); +size_t wifi_event_roc_done__get_packed_size + (const WifiEventRocDone *message); +size_t wifi_event_roc_done__pack + (const WifiEventRocDone *message, + uint8_t *out); +size_t wifi_event_roc_done__pack_to_buffer + (const WifiEventRocDone *message, + ProtobufCBuffer *buffer); +WifiEventRocDone * + wifi_event_roc_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_roc_done__free_unpacked + (WifiEventRocDone *message, + ProtobufCAllocator *allocator); +/* WifiEventApWpsRgPin methods */ +void wifi_event_ap_wps_rg_pin__init + (WifiEventApWpsRgPin *message); +size_t wifi_event_ap_wps_rg_pin__get_packed_size + (const WifiEventApWpsRgPin *message); +size_t wifi_event_ap_wps_rg_pin__pack + (const WifiEventApWpsRgPin *message, + uint8_t *out); +size_t wifi_event_ap_wps_rg_pin__pack_to_buffer + (const WifiEventApWpsRgPin *message, + ProtobufCBuffer *buffer); +WifiEventApWpsRgPin * + wifi_event_ap_wps_rg_pin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_wps_rg_pin__free_unpacked + (WifiEventApWpsRgPin *message, + ProtobufCAllocator *allocator); +/* WifiEventApWpsRgFailReason methods */ +void wifi_event_ap_wps_rg_fail_reason__init + (WifiEventApWpsRgFailReason *message); +size_t wifi_event_ap_wps_rg_fail_reason__get_packed_size + (const WifiEventApWpsRgFailReason *message); +size_t wifi_event_ap_wps_rg_fail_reason__pack + (const WifiEventApWpsRgFailReason *message, + uint8_t *out); +size_t wifi_event_ap_wps_rg_fail_reason__pack_to_buffer + (const WifiEventApWpsRgFailReason *message, + ProtobufCBuffer *buffer); +WifiEventApWpsRgFailReason * + wifi_event_ap_wps_rg_fail_reason__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_wps_rg_fail_reason__free_unpacked + (WifiEventApWpsRgFailReason *message, + ProtobufCAllocator *allocator); +/* WifiEventApWpsRgSuccess methods */ +void wifi_event_ap_wps_rg_success__init + (WifiEventApWpsRgSuccess *message); +size_t wifi_event_ap_wps_rg_success__get_packed_size + (const WifiEventApWpsRgSuccess *message); +size_t wifi_event_ap_wps_rg_success__pack + (const WifiEventApWpsRgSuccess *message, + uint8_t *out); +size_t wifi_event_ap_wps_rg_success__pack_to_buffer + (const WifiEventApWpsRgSuccess *message, + ProtobufCBuffer *buffer); +WifiEventApWpsRgSuccess * + wifi_event_ap_wps_rg_success__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_event_ap_wps_rg_success__free_unpacked + (WifiEventApWpsRgSuccess *message, + ProtobufCAllocator *allocator); +/* WifiProtocols methods */ +void wifi_protocols__init + (WifiProtocols *message); +size_t wifi_protocols__get_packed_size + (const WifiProtocols *message); +size_t wifi_protocols__pack + (const WifiProtocols *message, + uint8_t *out); +size_t wifi_protocols__pack_to_buffer + (const WifiProtocols *message, + ProtobufCBuffer *buffer); +WifiProtocols * + wifi_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_protocols__free_unpacked + (WifiProtocols *message, + ProtobufCAllocator *allocator); +/* WifiBandwidths methods */ +void wifi_bandwidths__init + (WifiBandwidths *message); +size_t wifi_bandwidths__get_packed_size + (const WifiBandwidths *message); +size_t wifi_bandwidths__pack + (const WifiBandwidths *message, + uint8_t *out); +size_t wifi_bandwidths__pack_to_buffer + (const WifiBandwidths *message, + ProtobufCBuffer *buffer); +WifiBandwidths * + wifi_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_bandwidths__free_unpacked + (WifiBandwidths *message, + ProtobufCAllocator *allocator); +/* WifiItwtSetupConfig methods */ +void wifi_itwt_setup_config__init + (WifiItwtSetupConfig *message); +size_t wifi_itwt_setup_config__get_packed_size + (const WifiItwtSetupConfig *message); +size_t wifi_itwt_setup_config__pack + (const WifiItwtSetupConfig *message, + uint8_t *out); +size_t wifi_itwt_setup_config__pack_to_buffer + (const WifiItwtSetupConfig *message, + ProtobufCBuffer *buffer); +WifiItwtSetupConfig * + wifi_itwt_setup_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_itwt_setup_config__free_unpacked + (WifiItwtSetupConfig *message, + ProtobufCAllocator *allocator); +/* WifiTwtConfig methods */ +void wifi_twt_config__init + (WifiTwtConfig *message); +size_t wifi_twt_config__get_packed_size + (const WifiTwtConfig *message); +size_t wifi_twt_config__pack + (const WifiTwtConfig *message, + uint8_t *out); +size_t wifi_twt_config__pack_to_buffer + (const WifiTwtConfig *message, + ProtobufCBuffer *buffer); +WifiTwtConfig * + wifi_twt_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void wifi_twt_config__free_unpacked + (WifiTwtConfig *message, + ProtobufCAllocator *allocator); +/* ConnectedSTAList methods */ +void connected_stalist__init + (ConnectedSTAList *message); +size_t connected_stalist__get_packed_size + (const ConnectedSTAList *message); +size_t connected_stalist__pack + (const ConnectedSTAList *message, + uint8_t *out); +size_t connected_stalist__pack_to_buffer + (const ConnectedSTAList *message, + ProtobufCBuffer *buffer); +ConnectedSTAList * + connected_stalist__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void connected_stalist__free_unpacked + (ConnectedSTAList *message, + ProtobufCAllocator *allocator); +/* EapFastConfig methods */ +void eap_fast_config__init + (EapFastConfig *message); +size_t eap_fast_config__get_packed_size + (const EapFastConfig *message); +size_t eap_fast_config__pack + (const EapFastConfig *message, + uint8_t *out); +size_t eap_fast_config__pack_to_buffer + (const EapFastConfig *message, + ProtobufCBuffer *buffer); +EapFastConfig * + eap_fast_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eap_fast_config__free_unpacked + (EapFastConfig *message, + ProtobufCAllocator *allocator); +/* RpcReqGetMacAddress methods */ +void rpc__req__get_mac_address__init + (RpcReqGetMacAddress *message); +size_t rpc__req__get_mac_address__get_packed_size + (const RpcReqGetMacAddress *message); +size_t rpc__req__get_mac_address__pack + (const RpcReqGetMacAddress *message, + uint8_t *out); +size_t rpc__req__get_mac_address__pack_to_buffer + (const RpcReqGetMacAddress *message, + ProtobufCBuffer *buffer); +RpcReqGetMacAddress * + rpc__req__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_mac_address__free_unpacked + (RpcReqGetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcRespGetMacAddress methods */ +void rpc__resp__get_mac_address__init + (RpcRespGetMacAddress *message); +size_t rpc__resp__get_mac_address__get_packed_size + (const RpcRespGetMacAddress *message); +size_t rpc__resp__get_mac_address__pack + (const RpcRespGetMacAddress *message, + uint8_t *out); +size_t rpc__resp__get_mac_address__pack_to_buffer + (const RpcRespGetMacAddress *message, + ProtobufCBuffer *buffer); +RpcRespGetMacAddress * + rpc__resp__get_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_mac_address__free_unpacked + (RpcRespGetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcReqGetMode methods */ +void rpc__req__get_mode__init + (RpcReqGetMode *message); +size_t rpc__req__get_mode__get_packed_size + (const RpcReqGetMode *message); +size_t rpc__req__get_mode__pack + (const RpcReqGetMode *message, + uint8_t *out); +size_t rpc__req__get_mode__pack_to_buffer + (const RpcReqGetMode *message, + ProtobufCBuffer *buffer); +RpcReqGetMode * + rpc__req__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_mode__free_unpacked + (RpcReqGetMode *message, + ProtobufCAllocator *allocator); +/* RpcRespGetMode methods */ +void rpc__resp__get_mode__init + (RpcRespGetMode *message); +size_t rpc__resp__get_mode__get_packed_size + (const RpcRespGetMode *message); +size_t rpc__resp__get_mode__pack + (const RpcRespGetMode *message, + uint8_t *out); +size_t rpc__resp__get_mode__pack_to_buffer + (const RpcRespGetMode *message, + ProtobufCBuffer *buffer); +RpcRespGetMode * + rpc__resp__get_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_mode__free_unpacked + (RpcRespGetMode *message, + ProtobufCAllocator *allocator); +/* RpcReqSetMode methods */ +void rpc__req__set_mode__init + (RpcReqSetMode *message); +size_t rpc__req__set_mode__get_packed_size + (const RpcReqSetMode *message); +size_t rpc__req__set_mode__pack + (const RpcReqSetMode *message, + uint8_t *out); +size_t rpc__req__set_mode__pack_to_buffer + (const RpcReqSetMode *message, + ProtobufCBuffer *buffer); +RpcReqSetMode * + rpc__req__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_mode__free_unpacked + (RpcReqSetMode *message, + ProtobufCAllocator *allocator); +/* RpcRespSetMode methods */ +void rpc__resp__set_mode__init + (RpcRespSetMode *message); +size_t rpc__resp__set_mode__get_packed_size + (const RpcRespSetMode *message); +size_t rpc__resp__set_mode__pack + (const RpcRespSetMode *message, + uint8_t *out); +size_t rpc__resp__set_mode__pack_to_buffer + (const RpcRespSetMode *message, + ProtobufCBuffer *buffer); +RpcRespSetMode * + rpc__resp__set_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_mode__free_unpacked + (RpcRespSetMode *message, + ProtobufCAllocator *allocator); +/* RpcReqGetPs methods */ +void rpc__req__get_ps__init + (RpcReqGetPs *message); +size_t rpc__req__get_ps__get_packed_size + (const RpcReqGetPs *message); +size_t rpc__req__get_ps__pack + (const RpcReqGetPs *message, + uint8_t *out); +size_t rpc__req__get_ps__pack_to_buffer + (const RpcReqGetPs *message, + ProtobufCBuffer *buffer); +RpcReqGetPs * + rpc__req__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_ps__free_unpacked + (RpcReqGetPs *message, + ProtobufCAllocator *allocator); +/* RpcRespGetPs methods */ +void rpc__resp__get_ps__init + (RpcRespGetPs *message); +size_t rpc__resp__get_ps__get_packed_size + (const RpcRespGetPs *message); +size_t rpc__resp__get_ps__pack + (const RpcRespGetPs *message, + uint8_t *out); +size_t rpc__resp__get_ps__pack_to_buffer + (const RpcRespGetPs *message, + ProtobufCBuffer *buffer); +RpcRespGetPs * + rpc__resp__get_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_ps__free_unpacked + (RpcRespGetPs *message, + ProtobufCAllocator *allocator); +/* RpcReqSetPs methods */ +void rpc__req__set_ps__init + (RpcReqSetPs *message); +size_t rpc__req__set_ps__get_packed_size + (const RpcReqSetPs *message); +size_t rpc__req__set_ps__pack + (const RpcReqSetPs *message, + uint8_t *out); +size_t rpc__req__set_ps__pack_to_buffer + (const RpcReqSetPs *message, + ProtobufCBuffer *buffer); +RpcReqSetPs * + rpc__req__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_ps__free_unpacked + (RpcReqSetPs *message, + ProtobufCAllocator *allocator); +/* RpcRespSetPs methods */ +void rpc__resp__set_ps__init + (RpcRespSetPs *message); +size_t rpc__resp__set_ps__get_packed_size + (const RpcRespSetPs *message); +size_t rpc__resp__set_ps__pack + (const RpcRespSetPs *message, + uint8_t *out); +size_t rpc__resp__set_ps__pack_to_buffer + (const RpcRespSetPs *message, + ProtobufCBuffer *buffer); +RpcRespSetPs * + rpc__resp__set_ps__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_ps__free_unpacked + (RpcRespSetPs *message, + ProtobufCAllocator *allocator); +/* RpcReqSetMacAddress methods */ +void rpc__req__set_mac_address__init + (RpcReqSetMacAddress *message); +size_t rpc__req__set_mac_address__get_packed_size + (const RpcReqSetMacAddress *message); +size_t rpc__req__set_mac_address__pack + (const RpcReqSetMacAddress *message, + uint8_t *out); +size_t rpc__req__set_mac_address__pack_to_buffer + (const RpcReqSetMacAddress *message, + ProtobufCBuffer *buffer); +RpcReqSetMacAddress * + rpc__req__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_mac_address__free_unpacked + (RpcReqSetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcRespSetMacAddress methods */ +void rpc__resp__set_mac_address__init + (RpcRespSetMacAddress *message); +size_t rpc__resp__set_mac_address__get_packed_size + (const RpcRespSetMacAddress *message); +size_t rpc__resp__set_mac_address__pack + (const RpcRespSetMacAddress *message, + uint8_t *out); +size_t rpc__resp__set_mac_address__pack_to_buffer + (const RpcRespSetMacAddress *message, + ProtobufCBuffer *buffer); +RpcRespSetMacAddress * + rpc__resp__set_mac_address__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_mac_address__free_unpacked + (RpcRespSetMacAddress *message, + ProtobufCAllocator *allocator); +/* RpcReqOTABegin methods */ +void rpc__req__otabegin__init + (RpcReqOTABegin *message); +size_t rpc__req__otabegin__get_packed_size + (const RpcReqOTABegin *message); +size_t rpc__req__otabegin__pack + (const RpcReqOTABegin *message, + uint8_t *out); +size_t rpc__req__otabegin__pack_to_buffer + (const RpcReqOTABegin *message, + ProtobufCBuffer *buffer); +RpcReqOTABegin * + rpc__req__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__otabegin__free_unpacked + (RpcReqOTABegin *message, + ProtobufCAllocator *allocator); +/* RpcRespOTABegin methods */ +void rpc__resp__otabegin__init + (RpcRespOTABegin *message); +size_t rpc__resp__otabegin__get_packed_size + (const RpcRespOTABegin *message); +size_t rpc__resp__otabegin__pack + (const RpcRespOTABegin *message, + uint8_t *out); +size_t rpc__resp__otabegin__pack_to_buffer + (const RpcRespOTABegin *message, + ProtobufCBuffer *buffer); +RpcRespOTABegin * + rpc__resp__otabegin__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__otabegin__free_unpacked + (RpcRespOTABegin *message, + ProtobufCAllocator *allocator); +/* RpcReqOTAWrite methods */ +void rpc__req__otawrite__init + (RpcReqOTAWrite *message); +size_t rpc__req__otawrite__get_packed_size + (const RpcReqOTAWrite *message); +size_t rpc__req__otawrite__pack + (const RpcReqOTAWrite *message, + uint8_t *out); +size_t rpc__req__otawrite__pack_to_buffer + (const RpcReqOTAWrite *message, + ProtobufCBuffer *buffer); +RpcReqOTAWrite * + rpc__req__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__otawrite__free_unpacked + (RpcReqOTAWrite *message, + ProtobufCAllocator *allocator); +/* RpcRespOTAWrite methods */ +void rpc__resp__otawrite__init + (RpcRespOTAWrite *message); +size_t rpc__resp__otawrite__get_packed_size + (const RpcRespOTAWrite *message); +size_t rpc__resp__otawrite__pack + (const RpcRespOTAWrite *message, + uint8_t *out); +size_t rpc__resp__otawrite__pack_to_buffer + (const RpcRespOTAWrite *message, + ProtobufCBuffer *buffer); +RpcRespOTAWrite * + rpc__resp__otawrite__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__otawrite__free_unpacked + (RpcRespOTAWrite *message, + ProtobufCAllocator *allocator); +/* RpcReqOTAEnd methods */ +void rpc__req__otaend__init + (RpcReqOTAEnd *message); +size_t rpc__req__otaend__get_packed_size + (const RpcReqOTAEnd *message); +size_t rpc__req__otaend__pack + (const RpcReqOTAEnd *message, + uint8_t *out); +size_t rpc__req__otaend__pack_to_buffer + (const RpcReqOTAEnd *message, + ProtobufCBuffer *buffer); +RpcReqOTAEnd * + rpc__req__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__otaend__free_unpacked + (RpcReqOTAEnd *message, + ProtobufCAllocator *allocator); +/* RpcRespOTAEnd methods */ +void rpc__resp__otaend__init + (RpcRespOTAEnd *message); +size_t rpc__resp__otaend__get_packed_size + (const RpcRespOTAEnd *message); +size_t rpc__resp__otaend__pack + (const RpcRespOTAEnd *message, + uint8_t *out); +size_t rpc__resp__otaend__pack_to_buffer + (const RpcRespOTAEnd *message, + ProtobufCBuffer *buffer); +RpcRespOTAEnd * + rpc__resp__otaend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__otaend__free_unpacked + (RpcRespOTAEnd *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetMaxTxPower methods */ +void rpc__req__wifi_set_max_tx_power__init + (RpcReqWifiSetMaxTxPower *message); +size_t rpc__req__wifi_set_max_tx_power__get_packed_size + (const RpcReqWifiSetMaxTxPower *message); +size_t rpc__req__wifi_set_max_tx_power__pack + (const RpcReqWifiSetMaxTxPower *message, + uint8_t *out); +size_t rpc__req__wifi_set_max_tx_power__pack_to_buffer + (const RpcReqWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetMaxTxPower * + rpc__req__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_max_tx_power__free_unpacked + (RpcReqWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetMaxTxPower methods */ +void rpc__resp__wifi_set_max_tx_power__init + (RpcRespWifiSetMaxTxPower *message); +size_t rpc__resp__wifi_set_max_tx_power__get_packed_size + (const RpcRespWifiSetMaxTxPower *message); +size_t rpc__resp__wifi_set_max_tx_power__pack + (const RpcRespWifiSetMaxTxPower *message, + uint8_t *out); +size_t rpc__resp__wifi_set_max_tx_power__pack_to_buffer + (const RpcRespWifiSetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetMaxTxPower * + rpc__resp__wifi_set_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_max_tx_power__free_unpacked + (RpcRespWifiSetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetMaxTxPower methods */ +void rpc__req__wifi_get_max_tx_power__init + (RpcReqWifiGetMaxTxPower *message); +size_t rpc__req__wifi_get_max_tx_power__get_packed_size + (const RpcReqWifiGetMaxTxPower *message); +size_t rpc__req__wifi_get_max_tx_power__pack + (const RpcReqWifiGetMaxTxPower *message, + uint8_t *out); +size_t rpc__req__wifi_get_max_tx_power__pack_to_buffer + (const RpcReqWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetMaxTxPower * + rpc__req__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_max_tx_power__free_unpacked + (RpcReqWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetMaxTxPower methods */ +void rpc__resp__wifi_get_max_tx_power__init + (RpcRespWifiGetMaxTxPower *message); +size_t rpc__resp__wifi_get_max_tx_power__get_packed_size + (const RpcRespWifiGetMaxTxPower *message); +size_t rpc__resp__wifi_get_max_tx_power__pack + (const RpcRespWifiGetMaxTxPower *message, + uint8_t *out); +size_t rpc__resp__wifi_get_max_tx_power__pack_to_buffer + (const RpcRespWifiGetMaxTxPower *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetMaxTxPower * + rpc__resp__wifi_get_max_tx_power__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_max_tx_power__free_unpacked + (RpcRespWifiGetMaxTxPower *message, + ProtobufCAllocator *allocator); +/* RpcReqConfigHeartbeat methods */ +void rpc__req__config_heartbeat__init + (RpcReqConfigHeartbeat *message); +size_t rpc__req__config_heartbeat__get_packed_size + (const RpcReqConfigHeartbeat *message); +size_t rpc__req__config_heartbeat__pack + (const RpcReqConfigHeartbeat *message, + uint8_t *out); +size_t rpc__req__config_heartbeat__pack_to_buffer + (const RpcReqConfigHeartbeat *message, + ProtobufCBuffer *buffer); +RpcReqConfigHeartbeat * + rpc__req__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__config_heartbeat__free_unpacked + (RpcReqConfigHeartbeat *message, + ProtobufCAllocator *allocator); +/* RpcRespConfigHeartbeat methods */ +void rpc__resp__config_heartbeat__init + (RpcRespConfigHeartbeat *message); +size_t rpc__resp__config_heartbeat__get_packed_size + (const RpcRespConfigHeartbeat *message); +size_t rpc__resp__config_heartbeat__pack + (const RpcRespConfigHeartbeat *message, + uint8_t *out); +size_t rpc__resp__config_heartbeat__pack_to_buffer + (const RpcRespConfigHeartbeat *message, + ProtobufCBuffer *buffer); +RpcRespConfigHeartbeat * + rpc__resp__config_heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__config_heartbeat__free_unpacked + (RpcRespConfigHeartbeat *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiInit methods */ +void rpc__req__wifi_init__init + (RpcReqWifiInit *message); +size_t rpc__req__wifi_init__get_packed_size + (const RpcReqWifiInit *message); +size_t rpc__req__wifi_init__pack + (const RpcReqWifiInit *message, + uint8_t *out); +size_t rpc__req__wifi_init__pack_to_buffer + (const RpcReqWifiInit *message, + ProtobufCBuffer *buffer); +RpcReqWifiInit * + rpc__req__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_init__free_unpacked + (RpcReqWifiInit *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiInit methods */ +void rpc__resp__wifi_init__init + (RpcRespWifiInit *message); +size_t rpc__resp__wifi_init__get_packed_size + (const RpcRespWifiInit *message); +size_t rpc__resp__wifi_init__pack + (const RpcRespWifiInit *message, + uint8_t *out); +size_t rpc__resp__wifi_init__pack_to_buffer + (const RpcRespWifiInit *message, + ProtobufCBuffer *buffer); +RpcRespWifiInit * + rpc__resp__wifi_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_init__free_unpacked + (RpcRespWifiInit *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiDeinit methods */ +void rpc__req__wifi_deinit__init + (RpcReqWifiDeinit *message); +size_t rpc__req__wifi_deinit__get_packed_size + (const RpcReqWifiDeinit *message); +size_t rpc__req__wifi_deinit__pack + (const RpcReqWifiDeinit *message, + uint8_t *out); +size_t rpc__req__wifi_deinit__pack_to_buffer + (const RpcReqWifiDeinit *message, + ProtobufCBuffer *buffer); +RpcReqWifiDeinit * + rpc__req__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_deinit__free_unpacked + (RpcReqWifiDeinit *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiDeinit methods */ +void rpc__resp__wifi_deinit__init + (RpcRespWifiDeinit *message); +size_t rpc__resp__wifi_deinit__get_packed_size + (const RpcRespWifiDeinit *message); +size_t rpc__resp__wifi_deinit__pack + (const RpcRespWifiDeinit *message, + uint8_t *out); +size_t rpc__resp__wifi_deinit__pack_to_buffer + (const RpcRespWifiDeinit *message, + ProtobufCBuffer *buffer); +RpcRespWifiDeinit * + rpc__resp__wifi_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_deinit__free_unpacked + (RpcRespWifiDeinit *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetConfig methods */ +void rpc__req__wifi_set_config__init + (RpcReqWifiSetConfig *message); +size_t rpc__req__wifi_set_config__get_packed_size + (const RpcReqWifiSetConfig *message); +size_t rpc__req__wifi_set_config__pack + (const RpcReqWifiSetConfig *message, + uint8_t *out); +size_t rpc__req__wifi_set_config__pack_to_buffer + (const RpcReqWifiSetConfig *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetConfig * + rpc__req__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_config__free_unpacked + (RpcReqWifiSetConfig *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetConfig methods */ +void rpc__resp__wifi_set_config__init + (RpcRespWifiSetConfig *message); +size_t rpc__resp__wifi_set_config__get_packed_size + (const RpcRespWifiSetConfig *message); +size_t rpc__resp__wifi_set_config__pack + (const RpcRespWifiSetConfig *message, + uint8_t *out); +size_t rpc__resp__wifi_set_config__pack_to_buffer + (const RpcRespWifiSetConfig *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetConfig * + rpc__resp__wifi_set_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_config__free_unpacked + (RpcRespWifiSetConfig *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetConfig methods */ +void rpc__req__wifi_get_config__init + (RpcReqWifiGetConfig *message); +size_t rpc__req__wifi_get_config__get_packed_size + (const RpcReqWifiGetConfig *message); +size_t rpc__req__wifi_get_config__pack + (const RpcReqWifiGetConfig *message, + uint8_t *out); +size_t rpc__req__wifi_get_config__pack_to_buffer + (const RpcReqWifiGetConfig *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetConfig * + rpc__req__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_config__free_unpacked + (RpcReqWifiGetConfig *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetConfig methods */ +void rpc__resp__wifi_get_config__init + (RpcRespWifiGetConfig *message); +size_t rpc__resp__wifi_get_config__get_packed_size + (const RpcRespWifiGetConfig *message); +size_t rpc__resp__wifi_get_config__pack + (const RpcRespWifiGetConfig *message, + uint8_t *out); +size_t rpc__resp__wifi_get_config__pack_to_buffer + (const RpcRespWifiGetConfig *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetConfig * + rpc__resp__wifi_get_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_config__free_unpacked + (RpcRespWifiGetConfig *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiConnect methods */ +void rpc__req__wifi_connect__init + (RpcReqWifiConnect *message); +size_t rpc__req__wifi_connect__get_packed_size + (const RpcReqWifiConnect *message); +size_t rpc__req__wifi_connect__pack + (const RpcReqWifiConnect *message, + uint8_t *out); +size_t rpc__req__wifi_connect__pack_to_buffer + (const RpcReqWifiConnect *message, + ProtobufCBuffer *buffer); +RpcReqWifiConnect * + rpc__req__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_connect__free_unpacked + (RpcReqWifiConnect *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiConnect methods */ +void rpc__resp__wifi_connect__init + (RpcRespWifiConnect *message); +size_t rpc__resp__wifi_connect__get_packed_size + (const RpcRespWifiConnect *message); +size_t rpc__resp__wifi_connect__pack + (const RpcRespWifiConnect *message, + uint8_t *out); +size_t rpc__resp__wifi_connect__pack_to_buffer + (const RpcRespWifiConnect *message, + ProtobufCBuffer *buffer); +RpcRespWifiConnect * + rpc__resp__wifi_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_connect__free_unpacked + (RpcRespWifiConnect *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiDisconnect methods */ +void rpc__req__wifi_disconnect__init + (RpcReqWifiDisconnect *message); +size_t rpc__req__wifi_disconnect__get_packed_size + (const RpcReqWifiDisconnect *message); +size_t rpc__req__wifi_disconnect__pack + (const RpcReqWifiDisconnect *message, + uint8_t *out); +size_t rpc__req__wifi_disconnect__pack_to_buffer + (const RpcReqWifiDisconnect *message, + ProtobufCBuffer *buffer); +RpcReqWifiDisconnect * + rpc__req__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_disconnect__free_unpacked + (RpcReqWifiDisconnect *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiDisconnect methods */ +void rpc__resp__wifi_disconnect__init + (RpcRespWifiDisconnect *message); +size_t rpc__resp__wifi_disconnect__get_packed_size + (const RpcRespWifiDisconnect *message); +size_t rpc__resp__wifi_disconnect__pack + (const RpcRespWifiDisconnect *message, + uint8_t *out); +size_t rpc__resp__wifi_disconnect__pack_to_buffer + (const RpcRespWifiDisconnect *message, + ProtobufCBuffer *buffer); +RpcRespWifiDisconnect * + rpc__resp__wifi_disconnect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_disconnect__free_unpacked + (RpcRespWifiDisconnect *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStart methods */ +void rpc__req__wifi_start__init + (RpcReqWifiStart *message); +size_t rpc__req__wifi_start__get_packed_size + (const RpcReqWifiStart *message); +size_t rpc__req__wifi_start__pack + (const RpcReqWifiStart *message, + uint8_t *out); +size_t rpc__req__wifi_start__pack_to_buffer + (const RpcReqWifiStart *message, + ProtobufCBuffer *buffer); +RpcReqWifiStart * + rpc__req__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_start__free_unpacked + (RpcReqWifiStart *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStart methods */ +void rpc__resp__wifi_start__init + (RpcRespWifiStart *message); +size_t rpc__resp__wifi_start__get_packed_size + (const RpcRespWifiStart *message); +size_t rpc__resp__wifi_start__pack + (const RpcRespWifiStart *message, + uint8_t *out); +size_t rpc__resp__wifi_start__pack_to_buffer + (const RpcRespWifiStart *message, + ProtobufCBuffer *buffer); +RpcRespWifiStart * + rpc__resp__wifi_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_start__free_unpacked + (RpcRespWifiStart *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStop methods */ +void rpc__req__wifi_stop__init + (RpcReqWifiStop *message); +size_t rpc__req__wifi_stop__get_packed_size + (const RpcReqWifiStop *message); +size_t rpc__req__wifi_stop__pack + (const RpcReqWifiStop *message, + uint8_t *out); +size_t rpc__req__wifi_stop__pack_to_buffer + (const RpcReqWifiStop *message, + ProtobufCBuffer *buffer); +RpcReqWifiStop * + rpc__req__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_stop__free_unpacked + (RpcReqWifiStop *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStop methods */ +void rpc__resp__wifi_stop__init + (RpcRespWifiStop *message); +size_t rpc__resp__wifi_stop__get_packed_size + (const RpcRespWifiStop *message); +size_t rpc__resp__wifi_stop__pack + (const RpcRespWifiStop *message, + uint8_t *out); +size_t rpc__resp__wifi_stop__pack_to_buffer + (const RpcRespWifiStop *message, + ProtobufCBuffer *buffer); +RpcRespWifiStop * + rpc__resp__wifi_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_stop__free_unpacked + (RpcRespWifiStop *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanStart methods */ +void rpc__req__wifi_scan_start__init + (RpcReqWifiScanStart *message); +size_t rpc__req__wifi_scan_start__get_packed_size + (const RpcReqWifiScanStart *message); +size_t rpc__req__wifi_scan_start__pack + (const RpcReqWifiScanStart *message, + uint8_t *out); +size_t rpc__req__wifi_scan_start__pack_to_buffer + (const RpcReqWifiScanStart *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanStart * + rpc__req__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_start__free_unpacked + (RpcReqWifiScanStart *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanStart methods */ +void rpc__resp__wifi_scan_start__init + (RpcRespWifiScanStart *message); +size_t rpc__resp__wifi_scan_start__get_packed_size + (const RpcRespWifiScanStart *message); +size_t rpc__resp__wifi_scan_start__pack + (const RpcRespWifiScanStart *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_start__pack_to_buffer + (const RpcRespWifiScanStart *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanStart * + rpc__resp__wifi_scan_start__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_start__free_unpacked + (RpcRespWifiScanStart *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanStop methods */ +void rpc__req__wifi_scan_stop__init + (RpcReqWifiScanStop *message); +size_t rpc__req__wifi_scan_stop__get_packed_size + (const RpcReqWifiScanStop *message); +size_t rpc__req__wifi_scan_stop__pack + (const RpcReqWifiScanStop *message, + uint8_t *out); +size_t rpc__req__wifi_scan_stop__pack_to_buffer + (const RpcReqWifiScanStop *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanStop * + rpc__req__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_stop__free_unpacked + (RpcReqWifiScanStop *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanStop methods */ +void rpc__resp__wifi_scan_stop__init + (RpcRespWifiScanStop *message); +size_t rpc__resp__wifi_scan_stop__get_packed_size + (const RpcRespWifiScanStop *message); +size_t rpc__resp__wifi_scan_stop__pack + (const RpcRespWifiScanStop *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_stop__pack_to_buffer + (const RpcRespWifiScanStop *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanStop * + rpc__resp__wifi_scan_stop__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_stop__free_unpacked + (RpcRespWifiScanStop *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanGetApNum methods */ +void rpc__req__wifi_scan_get_ap_num__init + (RpcReqWifiScanGetApNum *message); +size_t rpc__req__wifi_scan_get_ap_num__get_packed_size + (const RpcReqWifiScanGetApNum *message); +size_t rpc__req__wifi_scan_get_ap_num__pack + (const RpcReqWifiScanGetApNum *message, + uint8_t *out); +size_t rpc__req__wifi_scan_get_ap_num__pack_to_buffer + (const RpcReqWifiScanGetApNum *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanGetApNum * + rpc__req__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_get_ap_num__free_unpacked + (RpcReqWifiScanGetApNum *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanGetApNum methods */ +void rpc__resp__wifi_scan_get_ap_num__init + (RpcRespWifiScanGetApNum *message); +size_t rpc__resp__wifi_scan_get_ap_num__get_packed_size + (const RpcRespWifiScanGetApNum *message); +size_t rpc__resp__wifi_scan_get_ap_num__pack + (const RpcRespWifiScanGetApNum *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_get_ap_num__pack_to_buffer + (const RpcRespWifiScanGetApNum *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanGetApNum * + rpc__resp__wifi_scan_get_ap_num__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_get_ap_num__free_unpacked + (RpcRespWifiScanGetApNum *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanGetApRecords methods */ +void rpc__req__wifi_scan_get_ap_records__init + (RpcReqWifiScanGetApRecords *message); +size_t rpc__req__wifi_scan_get_ap_records__get_packed_size + (const RpcReqWifiScanGetApRecords *message); +size_t rpc__req__wifi_scan_get_ap_records__pack + (const RpcReqWifiScanGetApRecords *message, + uint8_t *out); +size_t rpc__req__wifi_scan_get_ap_records__pack_to_buffer + (const RpcReqWifiScanGetApRecords *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanGetApRecords * + rpc__req__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_get_ap_records__free_unpacked + (RpcReqWifiScanGetApRecords *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanGetApRecords methods */ +void rpc__resp__wifi_scan_get_ap_records__init + (RpcRespWifiScanGetApRecords *message); +size_t rpc__resp__wifi_scan_get_ap_records__get_packed_size + (const RpcRespWifiScanGetApRecords *message); +size_t rpc__resp__wifi_scan_get_ap_records__pack + (const RpcRespWifiScanGetApRecords *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_get_ap_records__pack_to_buffer + (const RpcRespWifiScanGetApRecords *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanGetApRecords * + rpc__resp__wifi_scan_get_ap_records__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_get_ap_records__free_unpacked + (RpcRespWifiScanGetApRecords *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiScanGetApRecord methods */ +void rpc__req__wifi_scan_get_ap_record__init + (RpcReqWifiScanGetApRecord *message); +size_t rpc__req__wifi_scan_get_ap_record__get_packed_size + (const RpcReqWifiScanGetApRecord *message); +size_t rpc__req__wifi_scan_get_ap_record__pack + (const RpcReqWifiScanGetApRecord *message, + uint8_t *out); +size_t rpc__req__wifi_scan_get_ap_record__pack_to_buffer + (const RpcReqWifiScanGetApRecord *message, + ProtobufCBuffer *buffer); +RpcReqWifiScanGetApRecord * + rpc__req__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_scan_get_ap_record__free_unpacked + (RpcReqWifiScanGetApRecord *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiScanGetApRecord methods */ +void rpc__resp__wifi_scan_get_ap_record__init + (RpcRespWifiScanGetApRecord *message); +size_t rpc__resp__wifi_scan_get_ap_record__get_packed_size + (const RpcRespWifiScanGetApRecord *message); +size_t rpc__resp__wifi_scan_get_ap_record__pack + (const RpcRespWifiScanGetApRecord *message, + uint8_t *out); +size_t rpc__resp__wifi_scan_get_ap_record__pack_to_buffer + (const RpcRespWifiScanGetApRecord *message, + ProtobufCBuffer *buffer); +RpcRespWifiScanGetApRecord * + rpc__resp__wifi_scan_get_ap_record__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_scan_get_ap_record__free_unpacked + (RpcRespWifiScanGetApRecord *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiClearApList methods */ +void rpc__req__wifi_clear_ap_list__init + (RpcReqWifiClearApList *message); +size_t rpc__req__wifi_clear_ap_list__get_packed_size + (const RpcReqWifiClearApList *message); +size_t rpc__req__wifi_clear_ap_list__pack + (const RpcReqWifiClearApList *message, + uint8_t *out); +size_t rpc__req__wifi_clear_ap_list__pack_to_buffer + (const RpcReqWifiClearApList *message, + ProtobufCBuffer *buffer); +RpcReqWifiClearApList * + rpc__req__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_clear_ap_list__free_unpacked + (RpcReqWifiClearApList *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiClearApList methods */ +void rpc__resp__wifi_clear_ap_list__init + (RpcRespWifiClearApList *message); +size_t rpc__resp__wifi_clear_ap_list__get_packed_size + (const RpcRespWifiClearApList *message); +size_t rpc__resp__wifi_clear_ap_list__pack + (const RpcRespWifiClearApList *message, + uint8_t *out); +size_t rpc__resp__wifi_clear_ap_list__pack_to_buffer + (const RpcRespWifiClearApList *message, + ProtobufCBuffer *buffer); +RpcRespWifiClearApList * + rpc__resp__wifi_clear_ap_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_clear_ap_list__free_unpacked + (RpcRespWifiClearApList *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiRestore methods */ +void rpc__req__wifi_restore__init + (RpcReqWifiRestore *message); +size_t rpc__req__wifi_restore__get_packed_size + (const RpcReqWifiRestore *message); +size_t rpc__req__wifi_restore__pack + (const RpcReqWifiRestore *message, + uint8_t *out); +size_t rpc__req__wifi_restore__pack_to_buffer + (const RpcReqWifiRestore *message, + ProtobufCBuffer *buffer); +RpcReqWifiRestore * + rpc__req__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_restore__free_unpacked + (RpcReqWifiRestore *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiRestore methods */ +void rpc__resp__wifi_restore__init + (RpcRespWifiRestore *message); +size_t rpc__resp__wifi_restore__get_packed_size + (const RpcRespWifiRestore *message); +size_t rpc__resp__wifi_restore__pack + (const RpcRespWifiRestore *message, + uint8_t *out); +size_t rpc__resp__wifi_restore__pack_to_buffer + (const RpcRespWifiRestore *message, + ProtobufCBuffer *buffer); +RpcRespWifiRestore * + rpc__resp__wifi_restore__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_restore__free_unpacked + (RpcRespWifiRestore *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiClearFastConnect methods */ +void rpc__req__wifi_clear_fast_connect__init + (RpcReqWifiClearFastConnect *message); +size_t rpc__req__wifi_clear_fast_connect__get_packed_size + (const RpcReqWifiClearFastConnect *message); +size_t rpc__req__wifi_clear_fast_connect__pack + (const RpcReqWifiClearFastConnect *message, + uint8_t *out); +size_t rpc__req__wifi_clear_fast_connect__pack_to_buffer + (const RpcReqWifiClearFastConnect *message, + ProtobufCBuffer *buffer); +RpcReqWifiClearFastConnect * + rpc__req__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_clear_fast_connect__free_unpacked + (RpcReqWifiClearFastConnect *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiClearFastConnect methods */ +void rpc__resp__wifi_clear_fast_connect__init + (RpcRespWifiClearFastConnect *message); +size_t rpc__resp__wifi_clear_fast_connect__get_packed_size + (const RpcRespWifiClearFastConnect *message); +size_t rpc__resp__wifi_clear_fast_connect__pack + (const RpcRespWifiClearFastConnect *message, + uint8_t *out); +size_t rpc__resp__wifi_clear_fast_connect__pack_to_buffer + (const RpcRespWifiClearFastConnect *message, + ProtobufCBuffer *buffer); +RpcRespWifiClearFastConnect * + rpc__resp__wifi_clear_fast_connect__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_clear_fast_connect__free_unpacked + (RpcRespWifiClearFastConnect *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiDeauthSta methods */ +void rpc__req__wifi_deauth_sta__init + (RpcReqWifiDeauthSta *message); +size_t rpc__req__wifi_deauth_sta__get_packed_size + (const RpcReqWifiDeauthSta *message); +size_t rpc__req__wifi_deauth_sta__pack + (const RpcReqWifiDeauthSta *message, + uint8_t *out); +size_t rpc__req__wifi_deauth_sta__pack_to_buffer + (const RpcReqWifiDeauthSta *message, + ProtobufCBuffer *buffer); +RpcReqWifiDeauthSta * + rpc__req__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_deauth_sta__free_unpacked + (RpcReqWifiDeauthSta *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiDeauthSta methods */ +void rpc__resp__wifi_deauth_sta__init + (RpcRespWifiDeauthSta *message); +size_t rpc__resp__wifi_deauth_sta__get_packed_size + (const RpcRespWifiDeauthSta *message); +size_t rpc__resp__wifi_deauth_sta__pack + (const RpcRespWifiDeauthSta *message, + uint8_t *out); +size_t rpc__resp__wifi_deauth_sta__pack_to_buffer + (const RpcRespWifiDeauthSta *message, + ProtobufCBuffer *buffer); +RpcRespWifiDeauthSta * + rpc__resp__wifi_deauth_sta__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_deauth_sta__free_unpacked + (RpcRespWifiDeauthSta *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetApInfo methods */ +void rpc__req__wifi_sta_get_ap_info__init + (RpcReqWifiStaGetApInfo *message); +size_t rpc__req__wifi_sta_get_ap_info__get_packed_size + (const RpcReqWifiStaGetApInfo *message); +size_t rpc__req__wifi_sta_get_ap_info__pack + (const RpcReqWifiStaGetApInfo *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_ap_info__pack_to_buffer + (const RpcReqWifiStaGetApInfo *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetApInfo * + rpc__req__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_ap_info__free_unpacked + (RpcReqWifiStaGetApInfo *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetApInfo methods */ +void rpc__resp__wifi_sta_get_ap_info__init + (RpcRespWifiStaGetApInfo *message); +size_t rpc__resp__wifi_sta_get_ap_info__get_packed_size + (const RpcRespWifiStaGetApInfo *message); +size_t rpc__resp__wifi_sta_get_ap_info__pack + (const RpcRespWifiStaGetApInfo *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_ap_info__pack_to_buffer + (const RpcRespWifiStaGetApInfo *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetApInfo * + rpc__resp__wifi_sta_get_ap_info__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_ap_info__free_unpacked + (RpcRespWifiStaGetApInfo *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetProtocol methods */ +void rpc__req__wifi_set_protocol__init + (RpcReqWifiSetProtocol *message); +size_t rpc__req__wifi_set_protocol__get_packed_size + (const RpcReqWifiSetProtocol *message); +size_t rpc__req__wifi_set_protocol__pack + (const RpcReqWifiSetProtocol *message, + uint8_t *out); +size_t rpc__req__wifi_set_protocol__pack_to_buffer + (const RpcReqWifiSetProtocol *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetProtocol * + rpc__req__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_protocol__free_unpacked + (RpcReqWifiSetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetProtocol methods */ +void rpc__resp__wifi_set_protocol__init + (RpcRespWifiSetProtocol *message); +size_t rpc__resp__wifi_set_protocol__get_packed_size + (const RpcRespWifiSetProtocol *message); +size_t rpc__resp__wifi_set_protocol__pack + (const RpcRespWifiSetProtocol *message, + uint8_t *out); +size_t rpc__resp__wifi_set_protocol__pack_to_buffer + (const RpcRespWifiSetProtocol *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetProtocol * + rpc__resp__wifi_set_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_protocol__free_unpacked + (RpcRespWifiSetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetProtocol methods */ +void rpc__req__wifi_get_protocol__init + (RpcReqWifiGetProtocol *message); +size_t rpc__req__wifi_get_protocol__get_packed_size + (const RpcReqWifiGetProtocol *message); +size_t rpc__req__wifi_get_protocol__pack + (const RpcReqWifiGetProtocol *message, + uint8_t *out); +size_t rpc__req__wifi_get_protocol__pack_to_buffer + (const RpcReqWifiGetProtocol *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetProtocol * + rpc__req__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_protocol__free_unpacked + (RpcReqWifiGetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetProtocol methods */ +void rpc__resp__wifi_get_protocol__init + (RpcRespWifiGetProtocol *message); +size_t rpc__resp__wifi_get_protocol__get_packed_size + (const RpcRespWifiGetProtocol *message); +size_t rpc__resp__wifi_get_protocol__pack + (const RpcRespWifiGetProtocol *message, + uint8_t *out); +size_t rpc__resp__wifi_get_protocol__pack_to_buffer + (const RpcRespWifiGetProtocol *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetProtocol * + rpc__resp__wifi_get_protocol__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_protocol__free_unpacked + (RpcRespWifiGetProtocol *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBandwidth methods */ +void rpc__req__wifi_set_bandwidth__init + (RpcReqWifiSetBandwidth *message); +size_t rpc__req__wifi_set_bandwidth__get_packed_size + (const RpcReqWifiSetBandwidth *message); +size_t rpc__req__wifi_set_bandwidth__pack + (const RpcReqWifiSetBandwidth *message, + uint8_t *out); +size_t rpc__req__wifi_set_bandwidth__pack_to_buffer + (const RpcReqWifiSetBandwidth *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBandwidth * + rpc__req__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_bandwidth__free_unpacked + (RpcReqWifiSetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBandwidth methods */ +void rpc__resp__wifi_set_bandwidth__init + (RpcRespWifiSetBandwidth *message); +size_t rpc__resp__wifi_set_bandwidth__get_packed_size + (const RpcRespWifiSetBandwidth *message); +size_t rpc__resp__wifi_set_bandwidth__pack + (const RpcRespWifiSetBandwidth *message, + uint8_t *out); +size_t rpc__resp__wifi_set_bandwidth__pack_to_buffer + (const RpcRespWifiSetBandwidth *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBandwidth * + rpc__resp__wifi_set_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_bandwidth__free_unpacked + (RpcRespWifiSetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBandwidth methods */ +void rpc__req__wifi_get_bandwidth__init + (RpcReqWifiGetBandwidth *message); +size_t rpc__req__wifi_get_bandwidth__get_packed_size + (const RpcReqWifiGetBandwidth *message); +size_t rpc__req__wifi_get_bandwidth__pack + (const RpcReqWifiGetBandwidth *message, + uint8_t *out); +size_t rpc__req__wifi_get_bandwidth__pack_to_buffer + (const RpcReqWifiGetBandwidth *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBandwidth * + rpc__req__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_bandwidth__free_unpacked + (RpcReqWifiGetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBandwidth methods */ +void rpc__resp__wifi_get_bandwidth__init + (RpcRespWifiGetBandwidth *message); +size_t rpc__resp__wifi_get_bandwidth__get_packed_size + (const RpcRespWifiGetBandwidth *message); +size_t rpc__resp__wifi_get_bandwidth__pack + (const RpcRespWifiGetBandwidth *message, + uint8_t *out); +size_t rpc__resp__wifi_get_bandwidth__pack_to_buffer + (const RpcRespWifiGetBandwidth *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBandwidth * + rpc__resp__wifi_get_bandwidth__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_bandwidth__free_unpacked + (RpcRespWifiGetBandwidth *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetChannel methods */ +void rpc__req__wifi_set_channel__init + (RpcReqWifiSetChannel *message); +size_t rpc__req__wifi_set_channel__get_packed_size + (const RpcReqWifiSetChannel *message); +size_t rpc__req__wifi_set_channel__pack + (const RpcReqWifiSetChannel *message, + uint8_t *out); +size_t rpc__req__wifi_set_channel__pack_to_buffer + (const RpcReqWifiSetChannel *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetChannel * + rpc__req__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_channel__free_unpacked + (RpcReqWifiSetChannel *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetChannel methods */ +void rpc__resp__wifi_set_channel__init + (RpcRespWifiSetChannel *message); +size_t rpc__resp__wifi_set_channel__get_packed_size + (const RpcRespWifiSetChannel *message); +size_t rpc__resp__wifi_set_channel__pack + (const RpcRespWifiSetChannel *message, + uint8_t *out); +size_t rpc__resp__wifi_set_channel__pack_to_buffer + (const RpcRespWifiSetChannel *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetChannel * + rpc__resp__wifi_set_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_channel__free_unpacked + (RpcRespWifiSetChannel *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetChannel methods */ +void rpc__req__wifi_get_channel__init + (RpcReqWifiGetChannel *message); +size_t rpc__req__wifi_get_channel__get_packed_size + (const RpcReqWifiGetChannel *message); +size_t rpc__req__wifi_get_channel__pack + (const RpcReqWifiGetChannel *message, + uint8_t *out); +size_t rpc__req__wifi_get_channel__pack_to_buffer + (const RpcReqWifiGetChannel *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetChannel * + rpc__req__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_channel__free_unpacked + (RpcReqWifiGetChannel *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetChannel methods */ +void rpc__resp__wifi_get_channel__init + (RpcRespWifiGetChannel *message); +size_t rpc__resp__wifi_get_channel__get_packed_size + (const RpcRespWifiGetChannel *message); +size_t rpc__resp__wifi_get_channel__pack + (const RpcRespWifiGetChannel *message, + uint8_t *out); +size_t rpc__resp__wifi_get_channel__pack_to_buffer + (const RpcRespWifiGetChannel *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetChannel * + rpc__resp__wifi_get_channel__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_channel__free_unpacked + (RpcRespWifiGetChannel *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetStorage methods */ +void rpc__req__wifi_set_storage__init + (RpcReqWifiSetStorage *message); +size_t rpc__req__wifi_set_storage__get_packed_size + (const RpcReqWifiSetStorage *message); +size_t rpc__req__wifi_set_storage__pack + (const RpcReqWifiSetStorage *message, + uint8_t *out); +size_t rpc__req__wifi_set_storage__pack_to_buffer + (const RpcReqWifiSetStorage *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetStorage * + rpc__req__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_storage__free_unpacked + (RpcReqWifiSetStorage *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetStorage methods */ +void rpc__resp__wifi_set_storage__init + (RpcRespWifiSetStorage *message); +size_t rpc__resp__wifi_set_storage__get_packed_size + (const RpcRespWifiSetStorage *message); +size_t rpc__resp__wifi_set_storage__pack + (const RpcRespWifiSetStorage *message, + uint8_t *out); +size_t rpc__resp__wifi_set_storage__pack_to_buffer + (const RpcRespWifiSetStorage *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetStorage * + rpc__resp__wifi_set_storage__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_storage__free_unpacked + (RpcRespWifiSetStorage *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetCountryCode methods */ +void rpc__req__wifi_set_country_code__init + (RpcReqWifiSetCountryCode *message); +size_t rpc__req__wifi_set_country_code__get_packed_size + (const RpcReqWifiSetCountryCode *message); +size_t rpc__req__wifi_set_country_code__pack + (const RpcReqWifiSetCountryCode *message, + uint8_t *out); +size_t rpc__req__wifi_set_country_code__pack_to_buffer + (const RpcReqWifiSetCountryCode *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetCountryCode * + rpc__req__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_country_code__free_unpacked + (RpcReqWifiSetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetCountryCode methods */ +void rpc__resp__wifi_set_country_code__init + (RpcRespWifiSetCountryCode *message); +size_t rpc__resp__wifi_set_country_code__get_packed_size + (const RpcRespWifiSetCountryCode *message); +size_t rpc__resp__wifi_set_country_code__pack + (const RpcRespWifiSetCountryCode *message, + uint8_t *out); +size_t rpc__resp__wifi_set_country_code__pack_to_buffer + (const RpcRespWifiSetCountryCode *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetCountryCode * + rpc__resp__wifi_set_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_country_code__free_unpacked + (RpcRespWifiSetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetCountryCode methods */ +void rpc__req__wifi_get_country_code__init + (RpcReqWifiGetCountryCode *message); +size_t rpc__req__wifi_get_country_code__get_packed_size + (const RpcReqWifiGetCountryCode *message); +size_t rpc__req__wifi_get_country_code__pack + (const RpcReqWifiGetCountryCode *message, + uint8_t *out); +size_t rpc__req__wifi_get_country_code__pack_to_buffer + (const RpcReqWifiGetCountryCode *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetCountryCode * + rpc__req__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_country_code__free_unpacked + (RpcReqWifiGetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetCountryCode methods */ +void rpc__resp__wifi_get_country_code__init + (RpcRespWifiGetCountryCode *message); +size_t rpc__resp__wifi_get_country_code__get_packed_size + (const RpcRespWifiGetCountryCode *message); +size_t rpc__resp__wifi_get_country_code__pack + (const RpcRespWifiGetCountryCode *message, + uint8_t *out); +size_t rpc__resp__wifi_get_country_code__pack_to_buffer + (const RpcRespWifiGetCountryCode *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetCountryCode * + rpc__resp__wifi_get_country_code__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_country_code__free_unpacked + (RpcRespWifiGetCountryCode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetCountry methods */ +void rpc__req__wifi_set_country__init + (RpcReqWifiSetCountry *message); +size_t rpc__req__wifi_set_country__get_packed_size + (const RpcReqWifiSetCountry *message); +size_t rpc__req__wifi_set_country__pack + (const RpcReqWifiSetCountry *message, + uint8_t *out); +size_t rpc__req__wifi_set_country__pack_to_buffer + (const RpcReqWifiSetCountry *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetCountry * + rpc__req__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_country__free_unpacked + (RpcReqWifiSetCountry *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetCountry methods */ +void rpc__resp__wifi_set_country__init + (RpcRespWifiSetCountry *message); +size_t rpc__resp__wifi_set_country__get_packed_size + (const RpcRespWifiSetCountry *message); +size_t rpc__resp__wifi_set_country__pack + (const RpcRespWifiSetCountry *message, + uint8_t *out); +size_t rpc__resp__wifi_set_country__pack_to_buffer + (const RpcRespWifiSetCountry *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetCountry * + rpc__resp__wifi_set_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_country__free_unpacked + (RpcRespWifiSetCountry *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetCountry methods */ +void rpc__req__wifi_get_country__init + (RpcReqWifiGetCountry *message); +size_t rpc__req__wifi_get_country__get_packed_size + (const RpcReqWifiGetCountry *message); +size_t rpc__req__wifi_get_country__pack + (const RpcReqWifiGetCountry *message, + uint8_t *out); +size_t rpc__req__wifi_get_country__pack_to_buffer + (const RpcReqWifiGetCountry *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetCountry * + rpc__req__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_country__free_unpacked + (RpcReqWifiGetCountry *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetCountry methods */ +void rpc__resp__wifi_get_country__init + (RpcRespWifiGetCountry *message); +size_t rpc__resp__wifi_get_country__get_packed_size + (const RpcRespWifiGetCountry *message); +size_t rpc__resp__wifi_get_country__pack + (const RpcRespWifiGetCountry *message, + uint8_t *out); +size_t rpc__resp__wifi_get_country__pack_to_buffer + (const RpcRespWifiGetCountry *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetCountry * + rpc__resp__wifi_get_country__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_country__free_unpacked + (RpcRespWifiGetCountry *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiApGetStaList methods */ +void rpc__req__wifi_ap_get_sta_list__init + (RpcReqWifiApGetStaList *message); +size_t rpc__req__wifi_ap_get_sta_list__get_packed_size + (const RpcReqWifiApGetStaList *message); +size_t rpc__req__wifi_ap_get_sta_list__pack + (const RpcReqWifiApGetStaList *message, + uint8_t *out); +size_t rpc__req__wifi_ap_get_sta_list__pack_to_buffer + (const RpcReqWifiApGetStaList *message, + ProtobufCBuffer *buffer); +RpcReqWifiApGetStaList * + rpc__req__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_ap_get_sta_list__free_unpacked + (RpcReqWifiApGetStaList *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiApGetStaList methods */ +void rpc__resp__wifi_ap_get_sta_list__init + (RpcRespWifiApGetStaList *message); +size_t rpc__resp__wifi_ap_get_sta_list__get_packed_size + (const RpcRespWifiApGetStaList *message); +size_t rpc__resp__wifi_ap_get_sta_list__pack + (const RpcRespWifiApGetStaList *message, + uint8_t *out); +size_t rpc__resp__wifi_ap_get_sta_list__pack_to_buffer + (const RpcRespWifiApGetStaList *message, + ProtobufCBuffer *buffer); +RpcRespWifiApGetStaList * + rpc__resp__wifi_ap_get_sta_list__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_ap_get_sta_list__free_unpacked + (RpcRespWifiApGetStaList *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiApGetStaAid methods */ +void rpc__req__wifi_ap_get_sta_aid__init + (RpcReqWifiApGetStaAid *message); +size_t rpc__req__wifi_ap_get_sta_aid__get_packed_size + (const RpcReqWifiApGetStaAid *message); +size_t rpc__req__wifi_ap_get_sta_aid__pack + (const RpcReqWifiApGetStaAid *message, + uint8_t *out); +size_t rpc__req__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcReqWifiApGetStaAid *message, + ProtobufCBuffer *buffer); +RpcReqWifiApGetStaAid * + rpc__req__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_ap_get_sta_aid__free_unpacked + (RpcReqWifiApGetStaAid *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetNegotiatedPhymode methods */ +void rpc__req__wifi_sta_get_negotiated_phymode__init + (RpcReqWifiStaGetNegotiatedPhymode *message); +size_t rpc__req__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcReqWifiStaGetNegotiatedPhymode *message); +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack + (const RpcReqWifiStaGetNegotiatedPhymode *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetNegotiatedPhymode * + rpc__req__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcReqWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetNegotiatedPhymode methods */ +void rpc__resp__wifi_sta_get_negotiated_phymode__init + (RpcRespWifiStaGetNegotiatedPhymode *message); +size_t rpc__resp__wifi_sta_get_negotiated_phymode__get_packed_size + (const RpcRespWifiStaGetNegotiatedPhymode *message); +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack + (const RpcRespWifiStaGetNegotiatedPhymode *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack_to_buffer + (const RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetNegotiatedPhymode * + rpc__resp__wifi_sta_get_negotiated_phymode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_negotiated_phymode__free_unpacked + (RpcRespWifiStaGetNegotiatedPhymode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiApGetStaAid methods */ +void rpc__resp__wifi_ap_get_sta_aid__init + (RpcRespWifiApGetStaAid *message); +size_t rpc__resp__wifi_ap_get_sta_aid__get_packed_size + (const RpcRespWifiApGetStaAid *message); +size_t rpc__resp__wifi_ap_get_sta_aid__pack + (const RpcRespWifiApGetStaAid *message, + uint8_t *out); +size_t rpc__resp__wifi_ap_get_sta_aid__pack_to_buffer + (const RpcRespWifiApGetStaAid *message, + ProtobufCBuffer *buffer); +RpcRespWifiApGetStaAid * + rpc__resp__wifi_ap_get_sta_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_ap_get_sta_aid__free_unpacked + (RpcRespWifiApGetStaAid *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetRssi methods */ +void rpc__req__wifi_sta_get_rssi__init + (RpcReqWifiStaGetRssi *message); +size_t rpc__req__wifi_sta_get_rssi__get_packed_size + (const RpcReqWifiStaGetRssi *message); +size_t rpc__req__wifi_sta_get_rssi__pack + (const RpcReqWifiStaGetRssi *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_rssi__pack_to_buffer + (const RpcReqWifiStaGetRssi *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetRssi * + rpc__req__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_rssi__free_unpacked + (RpcReqWifiStaGetRssi *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetRssi methods */ +void rpc__resp__wifi_sta_get_rssi__init + (RpcRespWifiStaGetRssi *message); +size_t rpc__resp__wifi_sta_get_rssi__get_packed_size + (const RpcRespWifiStaGetRssi *message); +size_t rpc__resp__wifi_sta_get_rssi__pack + (const RpcRespWifiStaGetRssi *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_rssi__pack_to_buffer + (const RpcRespWifiStaGetRssi *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetRssi * + rpc__resp__wifi_sta_get_rssi__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_rssi__free_unpacked + (RpcRespWifiStaGetRssi *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaGetAid methods */ +void rpc__req__wifi_sta_get_aid__init + (RpcReqWifiStaGetAid *message); +size_t rpc__req__wifi_sta_get_aid__get_packed_size + (const RpcReqWifiStaGetAid *message); +size_t rpc__req__wifi_sta_get_aid__pack + (const RpcReqWifiStaGetAid *message, + uint8_t *out); +size_t rpc__req__wifi_sta_get_aid__pack_to_buffer + (const RpcReqWifiStaGetAid *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaGetAid * + rpc__req__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_get_aid__free_unpacked + (RpcReqWifiStaGetAid *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaGetAid methods */ +void rpc__resp__wifi_sta_get_aid__init + (RpcRespWifiStaGetAid *message); +size_t rpc__resp__wifi_sta_get_aid__get_packed_size + (const RpcRespWifiStaGetAid *message); +size_t rpc__resp__wifi_sta_get_aid__pack + (const RpcRespWifiStaGetAid *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_get_aid__pack_to_buffer + (const RpcRespWifiStaGetAid *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaGetAid * + rpc__resp__wifi_sta_get_aid__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_get_aid__free_unpacked + (RpcRespWifiStaGetAid *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetProtocols methods */ +void rpc__req__wifi_set_protocols__init + (RpcReqWifiSetProtocols *message); +size_t rpc__req__wifi_set_protocols__get_packed_size + (const RpcReqWifiSetProtocols *message); +size_t rpc__req__wifi_set_protocols__pack + (const RpcReqWifiSetProtocols *message, + uint8_t *out); +size_t rpc__req__wifi_set_protocols__pack_to_buffer + (const RpcReqWifiSetProtocols *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetProtocols * + rpc__req__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_protocols__free_unpacked + (RpcReqWifiSetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetProtocols methods */ +void rpc__resp__wifi_set_protocols__init + (RpcRespWifiSetProtocols *message); +size_t rpc__resp__wifi_set_protocols__get_packed_size + (const RpcRespWifiSetProtocols *message); +size_t rpc__resp__wifi_set_protocols__pack + (const RpcRespWifiSetProtocols *message, + uint8_t *out); +size_t rpc__resp__wifi_set_protocols__pack_to_buffer + (const RpcRespWifiSetProtocols *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetProtocols * + rpc__resp__wifi_set_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_protocols__free_unpacked + (RpcRespWifiSetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetProtocols methods */ +void rpc__req__wifi_get_protocols__init + (RpcReqWifiGetProtocols *message); +size_t rpc__req__wifi_get_protocols__get_packed_size + (const RpcReqWifiGetProtocols *message); +size_t rpc__req__wifi_get_protocols__pack + (const RpcReqWifiGetProtocols *message, + uint8_t *out); +size_t rpc__req__wifi_get_protocols__pack_to_buffer + (const RpcReqWifiGetProtocols *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetProtocols * + rpc__req__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_protocols__free_unpacked + (RpcReqWifiGetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetProtocols methods */ +void rpc__resp__wifi_get_protocols__init + (RpcRespWifiGetProtocols *message); +size_t rpc__resp__wifi_get_protocols__get_packed_size + (const RpcRespWifiGetProtocols *message); +size_t rpc__resp__wifi_get_protocols__pack + (const RpcRespWifiGetProtocols *message, + uint8_t *out); +size_t rpc__resp__wifi_get_protocols__pack_to_buffer + (const RpcRespWifiGetProtocols *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetProtocols * + rpc__resp__wifi_get_protocols__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_protocols__free_unpacked + (RpcRespWifiGetProtocols *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBandwidths methods */ +void rpc__req__wifi_set_bandwidths__init + (RpcReqWifiSetBandwidths *message); +size_t rpc__req__wifi_set_bandwidths__get_packed_size + (const RpcReqWifiSetBandwidths *message); +size_t rpc__req__wifi_set_bandwidths__pack + (const RpcReqWifiSetBandwidths *message, + uint8_t *out); +size_t rpc__req__wifi_set_bandwidths__pack_to_buffer + (const RpcReqWifiSetBandwidths *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBandwidths * + rpc__req__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_bandwidths__free_unpacked + (RpcReqWifiSetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBandwidths methods */ +void rpc__resp__wifi_set_bandwidths__init + (RpcRespWifiSetBandwidths *message); +size_t rpc__resp__wifi_set_bandwidths__get_packed_size + (const RpcRespWifiSetBandwidths *message); +size_t rpc__resp__wifi_set_bandwidths__pack + (const RpcRespWifiSetBandwidths *message, + uint8_t *out); +size_t rpc__resp__wifi_set_bandwidths__pack_to_buffer + (const RpcRespWifiSetBandwidths *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBandwidths * + rpc__resp__wifi_set_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_bandwidths__free_unpacked + (RpcRespWifiSetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBandwidths methods */ +void rpc__req__wifi_get_bandwidths__init + (RpcReqWifiGetBandwidths *message); +size_t rpc__req__wifi_get_bandwidths__get_packed_size + (const RpcReqWifiGetBandwidths *message); +size_t rpc__req__wifi_get_bandwidths__pack + (const RpcReqWifiGetBandwidths *message, + uint8_t *out); +size_t rpc__req__wifi_get_bandwidths__pack_to_buffer + (const RpcReqWifiGetBandwidths *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBandwidths * + rpc__req__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_bandwidths__free_unpacked + (RpcReqWifiGetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBandwidths methods */ +void rpc__resp__wifi_get_bandwidths__init + (RpcRespWifiGetBandwidths *message); +size_t rpc__resp__wifi_get_bandwidths__get_packed_size + (const RpcRespWifiGetBandwidths *message); +size_t rpc__resp__wifi_get_bandwidths__pack + (const RpcRespWifiGetBandwidths *message, + uint8_t *out); +size_t rpc__resp__wifi_get_bandwidths__pack_to_buffer + (const RpcRespWifiGetBandwidths *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBandwidths * + rpc__resp__wifi_get_bandwidths__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_bandwidths__free_unpacked + (RpcRespWifiGetBandwidths *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBand methods */ +void rpc__req__wifi_set_band__init + (RpcReqWifiSetBand *message); +size_t rpc__req__wifi_set_band__get_packed_size + (const RpcReqWifiSetBand *message); +size_t rpc__req__wifi_set_band__pack + (const RpcReqWifiSetBand *message, + uint8_t *out); +size_t rpc__req__wifi_set_band__pack_to_buffer + (const RpcReqWifiSetBand *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBand * + rpc__req__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_band__free_unpacked + (RpcReqWifiSetBand *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBand methods */ +void rpc__resp__wifi_set_band__init + (RpcRespWifiSetBand *message); +size_t rpc__resp__wifi_set_band__get_packed_size + (const RpcRespWifiSetBand *message); +size_t rpc__resp__wifi_set_band__pack + (const RpcRespWifiSetBand *message, + uint8_t *out); +size_t rpc__resp__wifi_set_band__pack_to_buffer + (const RpcRespWifiSetBand *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBand * + rpc__resp__wifi_set_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_band__free_unpacked + (RpcRespWifiSetBand *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBand methods */ +void rpc__req__wifi_get_band__init + (RpcReqWifiGetBand *message); +size_t rpc__req__wifi_get_band__get_packed_size + (const RpcReqWifiGetBand *message); +size_t rpc__req__wifi_get_band__pack + (const RpcReqWifiGetBand *message, + uint8_t *out); +size_t rpc__req__wifi_get_band__pack_to_buffer + (const RpcReqWifiGetBand *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBand * + rpc__req__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_band__free_unpacked + (RpcReqWifiGetBand *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBand methods */ +void rpc__resp__wifi_get_band__init + (RpcRespWifiGetBand *message); +size_t rpc__resp__wifi_get_band__get_packed_size + (const RpcRespWifiGetBand *message); +size_t rpc__resp__wifi_get_band__pack + (const RpcRespWifiGetBand *message, + uint8_t *out); +size_t rpc__resp__wifi_get_band__pack_to_buffer + (const RpcRespWifiGetBand *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBand * + rpc__resp__wifi_get_band__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_band__free_unpacked + (RpcRespWifiGetBand *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetBandMode methods */ +void rpc__req__wifi_set_band_mode__init + (RpcReqWifiSetBandMode *message); +size_t rpc__req__wifi_set_band_mode__get_packed_size + (const RpcReqWifiSetBandMode *message); +size_t rpc__req__wifi_set_band_mode__pack + (const RpcReqWifiSetBandMode *message, + uint8_t *out); +size_t rpc__req__wifi_set_band_mode__pack_to_buffer + (const RpcReqWifiSetBandMode *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetBandMode * + rpc__req__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_band_mode__free_unpacked + (RpcReqWifiSetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetBandMode methods */ +void rpc__resp__wifi_set_band_mode__init + (RpcRespWifiSetBandMode *message); +size_t rpc__resp__wifi_set_band_mode__get_packed_size + (const RpcRespWifiSetBandMode *message); +size_t rpc__resp__wifi_set_band_mode__pack + (const RpcRespWifiSetBandMode *message, + uint8_t *out); +size_t rpc__resp__wifi_set_band_mode__pack_to_buffer + (const RpcRespWifiSetBandMode *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetBandMode * + rpc__resp__wifi_set_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_band_mode__free_unpacked + (RpcRespWifiSetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetBandMode methods */ +void rpc__req__wifi_get_band_mode__init + (RpcReqWifiGetBandMode *message); +size_t rpc__req__wifi_get_band_mode__get_packed_size + (const RpcReqWifiGetBandMode *message); +size_t rpc__req__wifi_get_band_mode__pack + (const RpcReqWifiGetBandMode *message, + uint8_t *out); +size_t rpc__req__wifi_get_band_mode__pack_to_buffer + (const RpcReqWifiGetBandMode *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetBandMode * + rpc__req__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_band_mode__free_unpacked + (RpcReqWifiGetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetBandMode methods */ +void rpc__resp__wifi_get_band_mode__init + (RpcRespWifiGetBandMode *message); +size_t rpc__resp__wifi_get_band_mode__get_packed_size + (const RpcRespWifiGetBandMode *message); +size_t rpc__resp__wifi_get_band_mode__pack + (const RpcRespWifiGetBandMode *message, + uint8_t *out); +size_t rpc__resp__wifi_get_band_mode__pack_to_buffer + (const RpcRespWifiGetBandMode *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetBandMode * + rpc__resp__wifi_get_band_mode__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_band_mode__free_unpacked + (RpcRespWifiGetBandMode *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetInactiveTime methods */ +void rpc__req__wifi_set_inactive_time__init + (RpcReqWifiSetInactiveTime *message); +size_t rpc__req__wifi_set_inactive_time__get_packed_size + (const RpcReqWifiSetInactiveTime *message); +size_t rpc__req__wifi_set_inactive_time__pack + (const RpcReqWifiSetInactiveTime *message, + uint8_t *out); +size_t rpc__req__wifi_set_inactive_time__pack_to_buffer + (const RpcReqWifiSetInactiveTime *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetInactiveTime * + rpc__req__wifi_set_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_inactive_time__free_unpacked + (RpcReqWifiSetInactiveTime *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetInactiveTime methods */ +void rpc__resp__wifi_set_inactive_time__init + (RpcRespWifiSetInactiveTime *message); +size_t rpc__resp__wifi_set_inactive_time__get_packed_size + (const RpcRespWifiSetInactiveTime *message); +size_t rpc__resp__wifi_set_inactive_time__pack + (const RpcRespWifiSetInactiveTime *message, + uint8_t *out); +size_t rpc__resp__wifi_set_inactive_time__pack_to_buffer + (const RpcRespWifiSetInactiveTime *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetInactiveTime * + rpc__resp__wifi_set_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_inactive_time__free_unpacked + (RpcRespWifiSetInactiveTime *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiGetInactiveTime methods */ +void rpc__req__wifi_get_inactive_time__init + (RpcReqWifiGetInactiveTime *message); +size_t rpc__req__wifi_get_inactive_time__get_packed_size + (const RpcReqWifiGetInactiveTime *message); +size_t rpc__req__wifi_get_inactive_time__pack + (const RpcReqWifiGetInactiveTime *message, + uint8_t *out); +size_t rpc__req__wifi_get_inactive_time__pack_to_buffer + (const RpcReqWifiGetInactiveTime *message, + ProtobufCBuffer *buffer); +RpcReqWifiGetInactiveTime * + rpc__req__wifi_get_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_get_inactive_time__free_unpacked + (RpcReqWifiGetInactiveTime *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiGetInactiveTime methods */ +void rpc__resp__wifi_get_inactive_time__init + (RpcRespWifiGetInactiveTime *message); +size_t rpc__resp__wifi_get_inactive_time__get_packed_size + (const RpcRespWifiGetInactiveTime *message); +size_t rpc__resp__wifi_get_inactive_time__pack + (const RpcRespWifiGetInactiveTime *message, + uint8_t *out); +size_t rpc__resp__wifi_get_inactive_time__pack_to_buffer + (const RpcRespWifiGetInactiveTime *message, + ProtobufCBuffer *buffer); +RpcRespWifiGetInactiveTime * + rpc__resp__wifi_get_inactive_time__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_get_inactive_time__free_unpacked + (RpcRespWifiGetInactiveTime *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaItwtSetup methods */ +void rpc__req__wifi_sta_itwt_setup__init + (RpcReqWifiStaItwtSetup *message); +size_t rpc__req__wifi_sta_itwt_setup__get_packed_size + (const RpcReqWifiStaItwtSetup *message); +size_t rpc__req__wifi_sta_itwt_setup__pack + (const RpcReqWifiStaItwtSetup *message, + uint8_t *out); +size_t rpc__req__wifi_sta_itwt_setup__pack_to_buffer + (const RpcReqWifiStaItwtSetup *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaItwtSetup * + rpc__req__wifi_sta_itwt_setup__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_itwt_setup__free_unpacked + (RpcReqWifiStaItwtSetup *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaItwtSetup methods */ +void rpc__resp__wifi_sta_itwt_setup__init + (RpcRespWifiStaItwtSetup *message); +size_t rpc__resp__wifi_sta_itwt_setup__get_packed_size + (const RpcRespWifiStaItwtSetup *message); +size_t rpc__resp__wifi_sta_itwt_setup__pack + (const RpcRespWifiStaItwtSetup *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_itwt_setup__pack_to_buffer + (const RpcRespWifiStaItwtSetup *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaItwtSetup * + rpc__resp__wifi_sta_itwt_setup__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_itwt_setup__free_unpacked + (RpcRespWifiStaItwtSetup *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaItwtTeardown methods */ +void rpc__req__wifi_sta_itwt_teardown__init + (RpcReqWifiStaItwtTeardown *message); +size_t rpc__req__wifi_sta_itwt_teardown__get_packed_size + (const RpcReqWifiStaItwtTeardown *message); +size_t rpc__req__wifi_sta_itwt_teardown__pack + (const RpcReqWifiStaItwtTeardown *message, + uint8_t *out); +size_t rpc__req__wifi_sta_itwt_teardown__pack_to_buffer + (const RpcReqWifiStaItwtTeardown *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaItwtTeardown * + rpc__req__wifi_sta_itwt_teardown__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_itwt_teardown__free_unpacked + (RpcReqWifiStaItwtTeardown *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaItwtTeardown methods */ +void rpc__resp__wifi_sta_itwt_teardown__init + (RpcRespWifiStaItwtTeardown *message); +size_t rpc__resp__wifi_sta_itwt_teardown__get_packed_size + (const RpcRespWifiStaItwtTeardown *message); +size_t rpc__resp__wifi_sta_itwt_teardown__pack + (const RpcRespWifiStaItwtTeardown *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_itwt_teardown__pack_to_buffer + (const RpcRespWifiStaItwtTeardown *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaItwtTeardown * + rpc__resp__wifi_sta_itwt_teardown__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_itwt_teardown__free_unpacked + (RpcRespWifiStaItwtTeardown *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaItwtSuspend methods */ +void rpc__req__wifi_sta_itwt_suspend__init + (RpcReqWifiStaItwtSuspend *message); +size_t rpc__req__wifi_sta_itwt_suspend__get_packed_size + (const RpcReqWifiStaItwtSuspend *message); +size_t rpc__req__wifi_sta_itwt_suspend__pack + (const RpcReqWifiStaItwtSuspend *message, + uint8_t *out); +size_t rpc__req__wifi_sta_itwt_suspend__pack_to_buffer + (const RpcReqWifiStaItwtSuspend *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaItwtSuspend * + rpc__req__wifi_sta_itwt_suspend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_itwt_suspend__free_unpacked + (RpcReqWifiStaItwtSuspend *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaItwtSuspend methods */ +void rpc__resp__wifi_sta_itwt_suspend__init + (RpcRespWifiStaItwtSuspend *message); +size_t rpc__resp__wifi_sta_itwt_suspend__get_packed_size + (const RpcRespWifiStaItwtSuspend *message); +size_t rpc__resp__wifi_sta_itwt_suspend__pack + (const RpcRespWifiStaItwtSuspend *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_itwt_suspend__pack_to_buffer + (const RpcRespWifiStaItwtSuspend *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaItwtSuspend * + rpc__resp__wifi_sta_itwt_suspend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_itwt_suspend__free_unpacked + (RpcRespWifiStaItwtSuspend *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaItwtGetFlowIdStatus methods */ +void rpc__req__wifi_sta_itwt_get_flow_id_status__init + (RpcReqWifiStaItwtGetFlowIdStatus *message); +size_t rpc__req__wifi_sta_itwt_get_flow_id_status__get_packed_size + (const RpcReqWifiStaItwtGetFlowIdStatus *message); +size_t rpc__req__wifi_sta_itwt_get_flow_id_status__pack + (const RpcReqWifiStaItwtGetFlowIdStatus *message, + uint8_t *out); +size_t rpc__req__wifi_sta_itwt_get_flow_id_status__pack_to_buffer + (const RpcReqWifiStaItwtGetFlowIdStatus *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaItwtGetFlowIdStatus * + rpc__req__wifi_sta_itwt_get_flow_id_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_itwt_get_flow_id_status__free_unpacked + (RpcReqWifiStaItwtGetFlowIdStatus *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaItwtGetFlowIdStatus methods */ +void rpc__resp__wifi_sta_itwt_get_flow_id_status__init + (RpcRespWifiStaItwtGetFlowIdStatus *message); +size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__get_packed_size + (const RpcRespWifiStaItwtGetFlowIdStatus *message); +size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__pack + (const RpcRespWifiStaItwtGetFlowIdStatus *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__pack_to_buffer + (const RpcRespWifiStaItwtGetFlowIdStatus *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaItwtGetFlowIdStatus * + rpc__resp__wifi_sta_itwt_get_flow_id_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_itwt_get_flow_id_status__free_unpacked + (RpcRespWifiStaItwtGetFlowIdStatus *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaItwtSendProbeReq methods */ +void rpc__req__wifi_sta_itwt_send_probe_req__init + (RpcReqWifiStaItwtSendProbeReq *message); +size_t rpc__req__wifi_sta_itwt_send_probe_req__get_packed_size + (const RpcReqWifiStaItwtSendProbeReq *message); +size_t rpc__req__wifi_sta_itwt_send_probe_req__pack + (const RpcReqWifiStaItwtSendProbeReq *message, + uint8_t *out); +size_t rpc__req__wifi_sta_itwt_send_probe_req__pack_to_buffer + (const RpcReqWifiStaItwtSendProbeReq *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaItwtSendProbeReq * + rpc__req__wifi_sta_itwt_send_probe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_itwt_send_probe_req__free_unpacked + (RpcReqWifiStaItwtSendProbeReq *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaItwtSendProbeReq methods */ +void rpc__resp__wifi_sta_itwt_send_probe_req__init + (RpcRespWifiStaItwtSendProbeReq *message); +size_t rpc__resp__wifi_sta_itwt_send_probe_req__get_packed_size + (const RpcRespWifiStaItwtSendProbeReq *message); +size_t rpc__resp__wifi_sta_itwt_send_probe_req__pack + (const RpcRespWifiStaItwtSendProbeReq *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_itwt_send_probe_req__pack_to_buffer + (const RpcRespWifiStaItwtSendProbeReq *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaItwtSendProbeReq * + rpc__resp__wifi_sta_itwt_send_probe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_itwt_send_probe_req__free_unpacked + (RpcRespWifiStaItwtSendProbeReq *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaItwtSetTargetWakeTimeOffset methods */ +void rpc__req__wifi_sta_itwt_set_target_wake_time_offset__init + (RpcReqWifiStaItwtSetTargetWakeTimeOffset *message); +size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__get_packed_size + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message); +size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__pack + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + uint8_t *out); +size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__pack_to_buffer + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaItwtSetTargetWakeTimeOffset * + rpc__req__wifi_sta_itwt_set_target_wake_time_offset__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_itwt_set_target_wake_time_offset__free_unpacked + (RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaItwtSetTargetWakeTimeOffset methods */ +void rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__init + (RpcRespWifiStaItwtSetTargetWakeTimeOffset *message); +size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__get_packed_size + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message); +size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__pack + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__pack_to_buffer + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaItwtSetTargetWakeTimeOffset * + rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__free_unpacked + (RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaTwtConfig methods */ +void rpc__req__wifi_sta_twt_config__init + (RpcReqWifiStaTwtConfig *message); +size_t rpc__req__wifi_sta_twt_config__get_packed_size + (const RpcReqWifiStaTwtConfig *message); +size_t rpc__req__wifi_sta_twt_config__pack + (const RpcReqWifiStaTwtConfig *message, + uint8_t *out); +size_t rpc__req__wifi_sta_twt_config__pack_to_buffer + (const RpcReqWifiStaTwtConfig *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaTwtConfig * + rpc__req__wifi_sta_twt_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_twt_config__free_unpacked + (RpcReqWifiStaTwtConfig *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaTwtConfig methods */ +void rpc__resp__wifi_sta_twt_config__init + (RpcRespWifiStaTwtConfig *message); +size_t rpc__resp__wifi_sta_twt_config__get_packed_size + (const RpcRespWifiStaTwtConfig *message); +size_t rpc__resp__wifi_sta_twt_config__pack + (const RpcRespWifiStaTwtConfig *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_twt_config__pack_to_buffer + (const RpcRespWifiStaTwtConfig *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaTwtConfig * + rpc__resp__wifi_sta_twt_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_twt_config__free_unpacked + (RpcRespWifiStaTwtConfig *message, + ProtobufCAllocator *allocator); +/* RpcReqGetCoprocessorFwVersion methods */ +void rpc__req__get_coprocessor_fw_version__init + (RpcReqGetCoprocessorFwVersion *message); +size_t rpc__req__get_coprocessor_fw_version__get_packed_size + (const RpcReqGetCoprocessorFwVersion *message); +size_t rpc__req__get_coprocessor_fw_version__pack + (const RpcReqGetCoprocessorFwVersion *message, + uint8_t *out); +size_t rpc__req__get_coprocessor_fw_version__pack_to_buffer + (const RpcReqGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer); +RpcReqGetCoprocessorFwVersion * + rpc__req__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_coprocessor_fw_version__free_unpacked + (RpcReqGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator); +/* RpcRespGetCoprocessorFwVersion methods */ +void rpc__resp__get_coprocessor_fw_version__init + (RpcRespGetCoprocessorFwVersion *message); +size_t rpc__resp__get_coprocessor_fw_version__get_packed_size + (const RpcRespGetCoprocessorFwVersion *message); +size_t rpc__resp__get_coprocessor_fw_version__pack + (const RpcRespGetCoprocessorFwVersion *message, + uint8_t *out); +size_t rpc__resp__get_coprocessor_fw_version__pack_to_buffer + (const RpcRespGetCoprocessorFwVersion *message, + ProtobufCBuffer *buffer); +RpcRespGetCoprocessorFwVersion * + rpc__resp__get_coprocessor_fw_version__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_coprocessor_fw_version__free_unpacked + (RpcRespGetCoprocessorFwVersion *message, + ProtobufCAllocator *allocator); +/* RpcReqSetDhcpDnsStatus methods */ +void rpc__req__set_dhcp_dns_status__init + (RpcReqSetDhcpDnsStatus *message); +size_t rpc__req__set_dhcp_dns_status__get_packed_size + (const RpcReqSetDhcpDnsStatus *message); +size_t rpc__req__set_dhcp_dns_status__pack + (const RpcReqSetDhcpDnsStatus *message, + uint8_t *out); +size_t rpc__req__set_dhcp_dns_status__pack_to_buffer + (const RpcReqSetDhcpDnsStatus *message, + ProtobufCBuffer *buffer); +RpcReqSetDhcpDnsStatus * + rpc__req__set_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__set_dhcp_dns_status__free_unpacked + (RpcReqSetDhcpDnsStatus *message, + ProtobufCAllocator *allocator); +/* RpcRespSetDhcpDnsStatus methods */ +void rpc__resp__set_dhcp_dns_status__init + (RpcRespSetDhcpDnsStatus *message); +size_t rpc__resp__set_dhcp_dns_status__get_packed_size + (const RpcRespSetDhcpDnsStatus *message); +size_t rpc__resp__set_dhcp_dns_status__pack + (const RpcRespSetDhcpDnsStatus *message, + uint8_t *out); +size_t rpc__resp__set_dhcp_dns_status__pack_to_buffer + (const RpcRespSetDhcpDnsStatus *message, + ProtobufCBuffer *buffer); +RpcRespSetDhcpDnsStatus * + rpc__resp__set_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__set_dhcp_dns_status__free_unpacked + (RpcRespSetDhcpDnsStatus *message, + ProtobufCAllocator *allocator); +/* RpcReqGetDhcpDnsStatus methods */ +void rpc__req__get_dhcp_dns_status__init + (RpcReqGetDhcpDnsStatus *message); +size_t rpc__req__get_dhcp_dns_status__get_packed_size + (const RpcReqGetDhcpDnsStatus *message); +size_t rpc__req__get_dhcp_dns_status__pack + (const RpcReqGetDhcpDnsStatus *message, + uint8_t *out); +size_t rpc__req__get_dhcp_dns_status__pack_to_buffer + (const RpcReqGetDhcpDnsStatus *message, + ProtobufCBuffer *buffer); +RpcReqGetDhcpDnsStatus * + rpc__req__get_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__get_dhcp_dns_status__free_unpacked + (RpcReqGetDhcpDnsStatus *message, + ProtobufCAllocator *allocator); +/* RpcRespGetDhcpDnsStatus methods */ +void rpc__resp__get_dhcp_dns_status__init + (RpcRespGetDhcpDnsStatus *message); +size_t rpc__resp__get_dhcp_dns_status__get_packed_size + (const RpcRespGetDhcpDnsStatus *message); +size_t rpc__resp__get_dhcp_dns_status__pack + (const RpcRespGetDhcpDnsStatus *message, + uint8_t *out); +size_t rpc__resp__get_dhcp_dns_status__pack_to_buffer + (const RpcRespGetDhcpDnsStatus *message, + ProtobufCBuffer *buffer); +RpcRespGetDhcpDnsStatus * + rpc__resp__get_dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__get_dhcp_dns_status__free_unpacked + (RpcRespGetDhcpDnsStatus *message, + ProtobufCAllocator *allocator); +/* RpcReqSuppDppInit methods */ +void rpc__req__supp_dpp_init__init + (RpcReqSuppDppInit *message); +size_t rpc__req__supp_dpp_init__get_packed_size + (const RpcReqSuppDppInit *message); +size_t rpc__req__supp_dpp_init__pack + (const RpcReqSuppDppInit *message, + uint8_t *out); +size_t rpc__req__supp_dpp_init__pack_to_buffer + (const RpcReqSuppDppInit *message, + ProtobufCBuffer *buffer); +RpcReqSuppDppInit * + rpc__req__supp_dpp_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__supp_dpp_init__free_unpacked + (RpcReqSuppDppInit *message, + ProtobufCAllocator *allocator); +/* RpcRespSuppDppInit methods */ +void rpc__resp__supp_dpp_init__init + (RpcRespSuppDppInit *message); +size_t rpc__resp__supp_dpp_init__get_packed_size + (const RpcRespSuppDppInit *message); +size_t rpc__resp__supp_dpp_init__pack + (const RpcRespSuppDppInit *message, + uint8_t *out); +size_t rpc__resp__supp_dpp_init__pack_to_buffer + (const RpcRespSuppDppInit *message, + ProtobufCBuffer *buffer); +RpcRespSuppDppInit * + rpc__resp__supp_dpp_init__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__supp_dpp_init__free_unpacked + (RpcRespSuppDppInit *message, + ProtobufCAllocator *allocator); +/* RpcReqSuppDppDeinit methods */ +void rpc__req__supp_dpp_deinit__init + (RpcReqSuppDppDeinit *message); +size_t rpc__req__supp_dpp_deinit__get_packed_size + (const RpcReqSuppDppDeinit *message); +size_t rpc__req__supp_dpp_deinit__pack + (const RpcReqSuppDppDeinit *message, + uint8_t *out); +size_t rpc__req__supp_dpp_deinit__pack_to_buffer + (const RpcReqSuppDppDeinit *message, + ProtobufCBuffer *buffer); +RpcReqSuppDppDeinit * + rpc__req__supp_dpp_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__supp_dpp_deinit__free_unpacked + (RpcReqSuppDppDeinit *message, + ProtobufCAllocator *allocator); +/* RpcRespSuppDppDeinit methods */ +void rpc__resp__supp_dpp_deinit__init + (RpcRespSuppDppDeinit *message); +size_t rpc__resp__supp_dpp_deinit__get_packed_size + (const RpcRespSuppDppDeinit *message); +size_t rpc__resp__supp_dpp_deinit__pack + (const RpcRespSuppDppDeinit *message, + uint8_t *out); +size_t rpc__resp__supp_dpp_deinit__pack_to_buffer + (const RpcRespSuppDppDeinit *message, + ProtobufCBuffer *buffer); +RpcRespSuppDppDeinit * + rpc__resp__supp_dpp_deinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__supp_dpp_deinit__free_unpacked + (RpcRespSuppDppDeinit *message, + ProtobufCAllocator *allocator); +/* RpcReqSuppDppBootstrapGen methods */ +void rpc__req__supp_dpp_bootstrap_gen__init + (RpcReqSuppDppBootstrapGen *message); +size_t rpc__req__supp_dpp_bootstrap_gen__get_packed_size + (const RpcReqSuppDppBootstrapGen *message); +size_t rpc__req__supp_dpp_bootstrap_gen__pack + (const RpcReqSuppDppBootstrapGen *message, + uint8_t *out); +size_t rpc__req__supp_dpp_bootstrap_gen__pack_to_buffer + (const RpcReqSuppDppBootstrapGen *message, + ProtobufCBuffer *buffer); +RpcReqSuppDppBootstrapGen * + rpc__req__supp_dpp_bootstrap_gen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__supp_dpp_bootstrap_gen__free_unpacked + (RpcReqSuppDppBootstrapGen *message, + ProtobufCAllocator *allocator); +/* RpcRespSuppDppBootstrapGen methods */ +void rpc__resp__supp_dpp_bootstrap_gen__init + (RpcRespSuppDppBootstrapGen *message); +size_t rpc__resp__supp_dpp_bootstrap_gen__get_packed_size + (const RpcRespSuppDppBootstrapGen *message); +size_t rpc__resp__supp_dpp_bootstrap_gen__pack + (const RpcRespSuppDppBootstrapGen *message, + uint8_t *out); +size_t rpc__resp__supp_dpp_bootstrap_gen__pack_to_buffer + (const RpcRespSuppDppBootstrapGen *message, + ProtobufCBuffer *buffer); +RpcRespSuppDppBootstrapGen * + rpc__resp__supp_dpp_bootstrap_gen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__supp_dpp_bootstrap_gen__free_unpacked + (RpcRespSuppDppBootstrapGen *message, + ProtobufCAllocator *allocator); +/* RpcReqSuppDppStartListen methods */ +void rpc__req__supp_dpp_start_listen__init + (RpcReqSuppDppStartListen *message); +size_t rpc__req__supp_dpp_start_listen__get_packed_size + (const RpcReqSuppDppStartListen *message); +size_t rpc__req__supp_dpp_start_listen__pack + (const RpcReqSuppDppStartListen *message, + uint8_t *out); +size_t rpc__req__supp_dpp_start_listen__pack_to_buffer + (const RpcReqSuppDppStartListen *message, + ProtobufCBuffer *buffer); +RpcReqSuppDppStartListen * + rpc__req__supp_dpp_start_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__supp_dpp_start_listen__free_unpacked + (RpcReqSuppDppStartListen *message, + ProtobufCAllocator *allocator); +/* RpcRespSuppDppStartListen methods */ +void rpc__resp__supp_dpp_start_listen__init + (RpcRespSuppDppStartListen *message); +size_t rpc__resp__supp_dpp_start_listen__get_packed_size + (const RpcRespSuppDppStartListen *message); +size_t rpc__resp__supp_dpp_start_listen__pack + (const RpcRespSuppDppStartListen *message, + uint8_t *out); +size_t rpc__resp__supp_dpp_start_listen__pack_to_buffer + (const RpcRespSuppDppStartListen *message, + ProtobufCBuffer *buffer); +RpcRespSuppDppStartListen * + rpc__resp__supp_dpp_start_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__supp_dpp_start_listen__free_unpacked + (RpcRespSuppDppStartListen *message, + ProtobufCAllocator *allocator); +/* RpcReqSuppDppStopListen methods */ +void rpc__req__supp_dpp_stop_listen__init + (RpcReqSuppDppStopListen *message); +size_t rpc__req__supp_dpp_stop_listen__get_packed_size + (const RpcReqSuppDppStopListen *message); +size_t rpc__req__supp_dpp_stop_listen__pack + (const RpcReqSuppDppStopListen *message, + uint8_t *out); +size_t rpc__req__supp_dpp_stop_listen__pack_to_buffer + (const RpcReqSuppDppStopListen *message, + ProtobufCBuffer *buffer); +RpcReqSuppDppStopListen * + rpc__req__supp_dpp_stop_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__supp_dpp_stop_listen__free_unpacked + (RpcReqSuppDppStopListen *message, + ProtobufCAllocator *allocator); +/* RpcRespSuppDppStopListen methods */ +void rpc__resp__supp_dpp_stop_listen__init + (RpcRespSuppDppStopListen *message); +size_t rpc__resp__supp_dpp_stop_listen__get_packed_size + (const RpcRespSuppDppStopListen *message); +size_t rpc__resp__supp_dpp_stop_listen__pack + (const RpcRespSuppDppStopListen *message, + uint8_t *out); +size_t rpc__resp__supp_dpp_stop_listen__pack_to_buffer + (const RpcRespSuppDppStopListen *message, + ProtobufCBuffer *buffer); +RpcRespSuppDppStopListen * + rpc__resp__supp_dpp_stop_listen__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__supp_dpp_stop_listen__free_unpacked + (RpcRespSuppDppStopListen *message, + ProtobufCAllocator *allocator); +/* RpcReqIfaceMacAddrSetGet methods */ +void rpc__req__iface_mac_addr_set_get__init + (RpcReqIfaceMacAddrSetGet *message); +size_t rpc__req__iface_mac_addr_set_get__get_packed_size + (const RpcReqIfaceMacAddrSetGet *message); +size_t rpc__req__iface_mac_addr_set_get__pack + (const RpcReqIfaceMacAddrSetGet *message, + uint8_t *out); +size_t rpc__req__iface_mac_addr_set_get__pack_to_buffer + (const RpcReqIfaceMacAddrSetGet *message, + ProtobufCBuffer *buffer); +RpcReqIfaceMacAddrSetGet * + rpc__req__iface_mac_addr_set_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__iface_mac_addr_set_get__free_unpacked + (RpcReqIfaceMacAddrSetGet *message, + ProtobufCAllocator *allocator); +/* RpcRespIfaceMacAddrSetGet methods */ +void rpc__resp__iface_mac_addr_set_get__init + (RpcRespIfaceMacAddrSetGet *message); +size_t rpc__resp__iface_mac_addr_set_get__get_packed_size + (const RpcRespIfaceMacAddrSetGet *message); +size_t rpc__resp__iface_mac_addr_set_get__pack + (const RpcRespIfaceMacAddrSetGet *message, + uint8_t *out); +size_t rpc__resp__iface_mac_addr_set_get__pack_to_buffer + (const RpcRespIfaceMacAddrSetGet *message, + ProtobufCBuffer *buffer); +RpcRespIfaceMacAddrSetGet * + rpc__resp__iface_mac_addr_set_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__iface_mac_addr_set_get__free_unpacked + (RpcRespIfaceMacAddrSetGet *message, + ProtobufCAllocator *allocator); +/* RpcReqIfaceMacAddrLenGet methods */ +void rpc__req__iface_mac_addr_len_get__init + (RpcReqIfaceMacAddrLenGet *message); +size_t rpc__req__iface_mac_addr_len_get__get_packed_size + (const RpcReqIfaceMacAddrLenGet *message); +size_t rpc__req__iface_mac_addr_len_get__pack + (const RpcReqIfaceMacAddrLenGet *message, + uint8_t *out); +size_t rpc__req__iface_mac_addr_len_get__pack_to_buffer + (const RpcReqIfaceMacAddrLenGet *message, + ProtobufCBuffer *buffer); +RpcReqIfaceMacAddrLenGet * + rpc__req__iface_mac_addr_len_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__iface_mac_addr_len_get__free_unpacked + (RpcReqIfaceMacAddrLenGet *message, + ProtobufCAllocator *allocator); +/* RpcRespIfaceMacAddrLenGet methods */ +void rpc__resp__iface_mac_addr_len_get__init + (RpcRespIfaceMacAddrLenGet *message); +size_t rpc__resp__iface_mac_addr_len_get__get_packed_size + (const RpcRespIfaceMacAddrLenGet *message); +size_t rpc__resp__iface_mac_addr_len_get__pack + (const RpcRespIfaceMacAddrLenGet *message, + uint8_t *out); +size_t rpc__resp__iface_mac_addr_len_get__pack_to_buffer + (const RpcRespIfaceMacAddrLenGet *message, + ProtobufCBuffer *buffer); +RpcRespIfaceMacAddrLenGet * + rpc__resp__iface_mac_addr_len_get__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__iface_mac_addr_len_get__free_unpacked + (RpcRespIfaceMacAddrLenGet *message, + ProtobufCAllocator *allocator); +/* RpcReqFeatureControl methods */ +void rpc__req__feature_control__init + (RpcReqFeatureControl *message); +size_t rpc__req__feature_control__get_packed_size + (const RpcReqFeatureControl *message); +size_t rpc__req__feature_control__pack + (const RpcReqFeatureControl *message, + uint8_t *out); +size_t rpc__req__feature_control__pack_to_buffer + (const RpcReqFeatureControl *message, + ProtobufCBuffer *buffer); +RpcReqFeatureControl * + rpc__req__feature_control__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__feature_control__free_unpacked + (RpcReqFeatureControl *message, + ProtobufCAllocator *allocator); +/* RpcRespFeatureControl methods */ +void rpc__resp__feature_control__init + (RpcRespFeatureControl *message); +size_t rpc__resp__feature_control__get_packed_size + (const RpcRespFeatureControl *message); +size_t rpc__resp__feature_control__pack + (const RpcRespFeatureControl *message, + uint8_t *out); +size_t rpc__resp__feature_control__pack_to_buffer + (const RpcRespFeatureControl *message, + ProtobufCBuffer *buffer); +RpcRespFeatureControl * + rpc__resp__feature_control__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__feature_control__free_unpacked + (RpcRespFeatureControl *message, + ProtobufCAllocator *allocator); +/* RpcEventWifiEventNoArgs methods */ +void rpc__event__wifi_event_no_args__init + (RpcEventWifiEventNoArgs *message); +size_t rpc__event__wifi_event_no_args__get_packed_size + (const RpcEventWifiEventNoArgs *message); +size_t rpc__event__wifi_event_no_args__pack + (const RpcEventWifiEventNoArgs *message, + uint8_t *out); +size_t rpc__event__wifi_event_no_args__pack_to_buffer + (const RpcEventWifiEventNoArgs *message, + ProtobufCBuffer *buffer); +RpcEventWifiEventNoArgs * + rpc__event__wifi_event_no_args__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__wifi_event_no_args__free_unpacked + (RpcEventWifiEventNoArgs *message, + ProtobufCAllocator *allocator); +/* RpcEventESPInit methods */ +void rpc__event__espinit__init + (RpcEventESPInit *message); +size_t rpc__event__espinit__get_packed_size + (const RpcEventESPInit *message); +size_t rpc__event__espinit__pack + (const RpcEventESPInit *message, + uint8_t *out); +size_t rpc__event__espinit__pack_to_buffer + (const RpcEventESPInit *message, + ProtobufCBuffer *buffer); +RpcEventESPInit * + rpc__event__espinit__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__espinit__free_unpacked + (RpcEventESPInit *message, + ProtobufCAllocator *allocator); +/* RpcEventHeartbeat methods */ +void rpc__event__heartbeat__init + (RpcEventHeartbeat *message); +size_t rpc__event__heartbeat__get_packed_size + (const RpcEventHeartbeat *message); +size_t rpc__event__heartbeat__pack + (const RpcEventHeartbeat *message, + uint8_t *out); +size_t rpc__event__heartbeat__pack_to_buffer + (const RpcEventHeartbeat *message, + ProtobufCBuffer *buffer); +RpcEventHeartbeat * + rpc__event__heartbeat__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__heartbeat__free_unpacked + (RpcEventHeartbeat *message, + ProtobufCAllocator *allocator); +/* RpcEventAPStaDisconnected methods */ +void rpc__event__ap__sta_disconnected__init + (RpcEventAPStaDisconnected *message); +size_t rpc__event__ap__sta_disconnected__get_packed_size + (const RpcEventAPStaDisconnected *message); +size_t rpc__event__ap__sta_disconnected__pack + (const RpcEventAPStaDisconnected *message, + uint8_t *out); +size_t rpc__event__ap__sta_disconnected__pack_to_buffer + (const RpcEventAPStaDisconnected *message, + ProtobufCBuffer *buffer); +RpcEventAPStaDisconnected * + rpc__event__ap__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__ap__sta_disconnected__free_unpacked + (RpcEventAPStaDisconnected *message, + ProtobufCAllocator *allocator); +/* RpcEventAPStaConnected methods */ +void rpc__event__ap__sta_connected__init + (RpcEventAPStaConnected *message); +size_t rpc__event__ap__sta_connected__get_packed_size + (const RpcEventAPStaConnected *message); +size_t rpc__event__ap__sta_connected__pack + (const RpcEventAPStaConnected *message, + uint8_t *out); +size_t rpc__event__ap__sta_connected__pack_to_buffer + (const RpcEventAPStaConnected *message, + ProtobufCBuffer *buffer); +RpcEventAPStaConnected * + rpc__event__ap__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__ap__sta_connected__free_unpacked + (RpcEventAPStaConnected *message, + ProtobufCAllocator *allocator); +/* RpcEventStaScanDone methods */ +void rpc__event__sta_scan_done__init + (RpcEventStaScanDone *message); +size_t rpc__event__sta_scan_done__get_packed_size + (const RpcEventStaScanDone *message); +size_t rpc__event__sta_scan_done__pack + (const RpcEventStaScanDone *message, + uint8_t *out); +size_t rpc__event__sta_scan_done__pack_to_buffer + (const RpcEventStaScanDone *message, + ProtobufCBuffer *buffer); +RpcEventStaScanDone * + rpc__event__sta_scan_done__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_scan_done__free_unpacked + (RpcEventStaScanDone *message, + ProtobufCAllocator *allocator); +/* RpcEventStaConnected methods */ +void rpc__event__sta_connected__init + (RpcEventStaConnected *message); +size_t rpc__event__sta_connected__get_packed_size + (const RpcEventStaConnected *message); +size_t rpc__event__sta_connected__pack + (const RpcEventStaConnected *message, + uint8_t *out); +size_t rpc__event__sta_connected__pack_to_buffer + (const RpcEventStaConnected *message, + ProtobufCBuffer *buffer); +RpcEventStaConnected * + rpc__event__sta_connected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_connected__free_unpacked + (RpcEventStaConnected *message, + ProtobufCAllocator *allocator); +/* RpcEventStaDisconnected methods */ +void rpc__event__sta_disconnected__init + (RpcEventStaDisconnected *message); +size_t rpc__event__sta_disconnected__get_packed_size + (const RpcEventStaDisconnected *message); +size_t rpc__event__sta_disconnected__pack + (const RpcEventStaDisconnected *message, + uint8_t *out); +size_t rpc__event__sta_disconnected__pack_to_buffer + (const RpcEventStaDisconnected *message, + ProtobufCBuffer *buffer); +RpcEventStaDisconnected * + rpc__event__sta_disconnected__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_disconnected__free_unpacked + (RpcEventStaDisconnected *message, + ProtobufCAllocator *allocator); +/* RpcEventDhcpDnsStatus methods */ +void rpc__event__dhcp_dns_status__init + (RpcEventDhcpDnsStatus *message); +size_t rpc__event__dhcp_dns_status__get_packed_size + (const RpcEventDhcpDnsStatus *message); +size_t rpc__event__dhcp_dns_status__pack + (const RpcEventDhcpDnsStatus *message, + uint8_t *out); +size_t rpc__event__dhcp_dns_status__pack_to_buffer + (const RpcEventDhcpDnsStatus *message, + ProtobufCBuffer *buffer); +RpcEventDhcpDnsStatus * + rpc__event__dhcp_dns_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__dhcp_dns_status__free_unpacked + (RpcEventDhcpDnsStatus *message, + ProtobufCAllocator *allocator); +/* RpcEventStaItwtSetup methods */ +void rpc__event__sta_itwt_setup__init + (RpcEventStaItwtSetup *message); +size_t rpc__event__sta_itwt_setup__get_packed_size + (const RpcEventStaItwtSetup *message); +size_t rpc__event__sta_itwt_setup__pack + (const RpcEventStaItwtSetup *message, + uint8_t *out); +size_t rpc__event__sta_itwt_setup__pack_to_buffer + (const RpcEventStaItwtSetup *message, + ProtobufCBuffer *buffer); +RpcEventStaItwtSetup * + rpc__event__sta_itwt_setup__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_itwt_setup__free_unpacked + (RpcEventStaItwtSetup *message, + ProtobufCAllocator *allocator); +/* RpcEventStaItwtTeardown methods */ +void rpc__event__sta_itwt_teardown__init + (RpcEventStaItwtTeardown *message); +size_t rpc__event__sta_itwt_teardown__get_packed_size + (const RpcEventStaItwtTeardown *message); +size_t rpc__event__sta_itwt_teardown__pack + (const RpcEventStaItwtTeardown *message, + uint8_t *out); +size_t rpc__event__sta_itwt_teardown__pack_to_buffer + (const RpcEventStaItwtTeardown *message, + ProtobufCBuffer *buffer); +RpcEventStaItwtTeardown * + rpc__event__sta_itwt_teardown__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_itwt_teardown__free_unpacked + (RpcEventStaItwtTeardown *message, + ProtobufCAllocator *allocator); +/* RpcEventStaItwtSuspend methods */ +void rpc__event__sta_itwt_suspend__init + (RpcEventStaItwtSuspend *message); +size_t rpc__event__sta_itwt_suspend__get_packed_size + (const RpcEventStaItwtSuspend *message); +size_t rpc__event__sta_itwt_suspend__pack + (const RpcEventStaItwtSuspend *message, + uint8_t *out); +size_t rpc__event__sta_itwt_suspend__pack_to_buffer + (const RpcEventStaItwtSuspend *message, + ProtobufCBuffer *buffer); +RpcEventStaItwtSuspend * + rpc__event__sta_itwt_suspend__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_itwt_suspend__free_unpacked + (RpcEventStaItwtSuspend *message, + ProtobufCAllocator *allocator); +/* RpcEventStaItwtProbe methods */ +void rpc__event__sta_itwt_probe__init + (RpcEventStaItwtProbe *message); +size_t rpc__event__sta_itwt_probe__get_packed_size + (const RpcEventStaItwtProbe *message); +size_t rpc__event__sta_itwt_probe__pack + (const RpcEventStaItwtProbe *message, + uint8_t *out); +size_t rpc__event__sta_itwt_probe__pack_to_buffer + (const RpcEventStaItwtProbe *message, + ProtobufCBuffer *buffer); +RpcEventStaItwtProbe * + rpc__event__sta_itwt_probe__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__sta_itwt_probe__free_unpacked + (RpcEventStaItwtProbe *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaEnterpriseEnable methods */ +void rpc__req__wifi_sta_enterprise_enable__init + (RpcReqWifiStaEnterpriseEnable *message); +size_t rpc__req__wifi_sta_enterprise_enable__get_packed_size + (const RpcReqWifiStaEnterpriseEnable *message); +size_t rpc__req__wifi_sta_enterprise_enable__pack + (const RpcReqWifiStaEnterpriseEnable *message, + uint8_t *out); +size_t rpc__req__wifi_sta_enterprise_enable__pack_to_buffer + (const RpcReqWifiStaEnterpriseEnable *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaEnterpriseEnable * + rpc__req__wifi_sta_enterprise_enable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_enterprise_enable__free_unpacked + (RpcReqWifiStaEnterpriseEnable *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaEnterpriseEnable methods */ +void rpc__resp__wifi_sta_enterprise_enable__init + (RpcRespWifiStaEnterpriseEnable *message); +size_t rpc__resp__wifi_sta_enterprise_enable__get_packed_size + (const RpcRespWifiStaEnterpriseEnable *message); +size_t rpc__resp__wifi_sta_enterprise_enable__pack + (const RpcRespWifiStaEnterpriseEnable *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_enterprise_enable__pack_to_buffer + (const RpcRespWifiStaEnterpriseEnable *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaEnterpriseEnable * + rpc__resp__wifi_sta_enterprise_enable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_enterprise_enable__free_unpacked + (RpcRespWifiStaEnterpriseEnable *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiStaEnterpriseDisable methods */ +void rpc__req__wifi_sta_enterprise_disable__init + (RpcReqWifiStaEnterpriseDisable *message); +size_t rpc__req__wifi_sta_enterprise_disable__get_packed_size + (const RpcReqWifiStaEnterpriseDisable *message); +size_t rpc__req__wifi_sta_enterprise_disable__pack + (const RpcReqWifiStaEnterpriseDisable *message, + uint8_t *out); +size_t rpc__req__wifi_sta_enterprise_disable__pack_to_buffer + (const RpcReqWifiStaEnterpriseDisable *message, + ProtobufCBuffer *buffer); +RpcReqWifiStaEnterpriseDisable * + rpc__req__wifi_sta_enterprise_disable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_sta_enterprise_disable__free_unpacked + (RpcReqWifiStaEnterpriseDisable *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiStaEnterpriseDisable methods */ +void rpc__resp__wifi_sta_enterprise_disable__init + (RpcRespWifiStaEnterpriseDisable *message); +size_t rpc__resp__wifi_sta_enterprise_disable__get_packed_size + (const RpcRespWifiStaEnterpriseDisable *message); +size_t rpc__resp__wifi_sta_enterprise_disable__pack + (const RpcRespWifiStaEnterpriseDisable *message, + uint8_t *out); +size_t rpc__resp__wifi_sta_enterprise_disable__pack_to_buffer + (const RpcRespWifiStaEnterpriseDisable *message, + ProtobufCBuffer *buffer); +RpcRespWifiStaEnterpriseDisable * + rpc__resp__wifi_sta_enterprise_disable__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_sta_enterprise_disable__free_unpacked + (RpcRespWifiStaEnterpriseDisable *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetIdentity methods */ +void rpc__req__eap_set_identity__init + (RpcReqEapSetIdentity *message); +size_t rpc__req__eap_set_identity__get_packed_size + (const RpcReqEapSetIdentity *message); +size_t rpc__req__eap_set_identity__pack + (const RpcReqEapSetIdentity *message, + uint8_t *out); +size_t rpc__req__eap_set_identity__pack_to_buffer + (const RpcReqEapSetIdentity *message, + ProtobufCBuffer *buffer); +RpcReqEapSetIdentity * + rpc__req__eap_set_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_identity__free_unpacked + (RpcReqEapSetIdentity *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetIdentity methods */ +void rpc__resp__eap_set_identity__init + (RpcRespEapSetIdentity *message); +size_t rpc__resp__eap_set_identity__get_packed_size + (const RpcRespEapSetIdentity *message); +size_t rpc__resp__eap_set_identity__pack + (const RpcRespEapSetIdentity *message, + uint8_t *out); +size_t rpc__resp__eap_set_identity__pack_to_buffer + (const RpcRespEapSetIdentity *message, + ProtobufCBuffer *buffer); +RpcRespEapSetIdentity * + rpc__resp__eap_set_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_identity__free_unpacked + (RpcRespEapSetIdentity *message, + ProtobufCAllocator *allocator); +/* RpcReqEapClearIdentity methods */ +void rpc__req__eap_clear_identity__init + (RpcReqEapClearIdentity *message); +size_t rpc__req__eap_clear_identity__get_packed_size + (const RpcReqEapClearIdentity *message); +size_t rpc__req__eap_clear_identity__pack + (const RpcReqEapClearIdentity *message, + uint8_t *out); +size_t rpc__req__eap_clear_identity__pack_to_buffer + (const RpcReqEapClearIdentity *message, + ProtobufCBuffer *buffer); +RpcReqEapClearIdentity * + rpc__req__eap_clear_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_clear_identity__free_unpacked + (RpcReqEapClearIdentity *message, + ProtobufCAllocator *allocator); +/* RpcRespEapClearIdentity methods */ +void rpc__resp__eap_clear_identity__init + (RpcRespEapClearIdentity *message); +size_t rpc__resp__eap_clear_identity__get_packed_size + (const RpcRespEapClearIdentity *message); +size_t rpc__resp__eap_clear_identity__pack + (const RpcRespEapClearIdentity *message, + uint8_t *out); +size_t rpc__resp__eap_clear_identity__pack_to_buffer + (const RpcRespEapClearIdentity *message, + ProtobufCBuffer *buffer); +RpcRespEapClearIdentity * + rpc__resp__eap_clear_identity__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_clear_identity__free_unpacked + (RpcRespEapClearIdentity *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetUsername methods */ +void rpc__req__eap_set_username__init + (RpcReqEapSetUsername *message); +size_t rpc__req__eap_set_username__get_packed_size + (const RpcReqEapSetUsername *message); +size_t rpc__req__eap_set_username__pack + (const RpcReqEapSetUsername *message, + uint8_t *out); +size_t rpc__req__eap_set_username__pack_to_buffer + (const RpcReqEapSetUsername *message, + ProtobufCBuffer *buffer); +RpcReqEapSetUsername * + rpc__req__eap_set_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_username__free_unpacked + (RpcReqEapSetUsername *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetUsername methods */ +void rpc__resp__eap_set_username__init + (RpcRespEapSetUsername *message); +size_t rpc__resp__eap_set_username__get_packed_size + (const RpcRespEapSetUsername *message); +size_t rpc__resp__eap_set_username__pack + (const RpcRespEapSetUsername *message, + uint8_t *out); +size_t rpc__resp__eap_set_username__pack_to_buffer + (const RpcRespEapSetUsername *message, + ProtobufCBuffer *buffer); +RpcRespEapSetUsername * + rpc__resp__eap_set_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_username__free_unpacked + (RpcRespEapSetUsername *message, + ProtobufCAllocator *allocator); +/* RpcReqEapClearUsername methods */ +void rpc__req__eap_clear_username__init + (RpcReqEapClearUsername *message); +size_t rpc__req__eap_clear_username__get_packed_size + (const RpcReqEapClearUsername *message); +size_t rpc__req__eap_clear_username__pack + (const RpcReqEapClearUsername *message, + uint8_t *out); +size_t rpc__req__eap_clear_username__pack_to_buffer + (const RpcReqEapClearUsername *message, + ProtobufCBuffer *buffer); +RpcReqEapClearUsername * + rpc__req__eap_clear_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_clear_username__free_unpacked + (RpcReqEapClearUsername *message, + ProtobufCAllocator *allocator); +/* RpcRespEapClearUsername methods */ +void rpc__resp__eap_clear_username__init + (RpcRespEapClearUsername *message); +size_t rpc__resp__eap_clear_username__get_packed_size + (const RpcRespEapClearUsername *message); +size_t rpc__resp__eap_clear_username__pack + (const RpcRespEapClearUsername *message, + uint8_t *out); +size_t rpc__resp__eap_clear_username__pack_to_buffer + (const RpcRespEapClearUsername *message, + ProtobufCBuffer *buffer); +RpcRespEapClearUsername * + rpc__resp__eap_clear_username__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_clear_username__free_unpacked + (RpcRespEapClearUsername *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetPassword methods */ +void rpc__req__eap_set_password__init + (RpcReqEapSetPassword *message); +size_t rpc__req__eap_set_password__get_packed_size + (const RpcReqEapSetPassword *message); +size_t rpc__req__eap_set_password__pack + (const RpcReqEapSetPassword *message, + uint8_t *out); +size_t rpc__req__eap_set_password__pack_to_buffer + (const RpcReqEapSetPassword *message, + ProtobufCBuffer *buffer); +RpcReqEapSetPassword * + rpc__req__eap_set_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_password__free_unpacked + (RpcReqEapSetPassword *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetPassword methods */ +void rpc__resp__eap_set_password__init + (RpcRespEapSetPassword *message); +size_t rpc__resp__eap_set_password__get_packed_size + (const RpcRespEapSetPassword *message); +size_t rpc__resp__eap_set_password__pack + (const RpcRespEapSetPassword *message, + uint8_t *out); +size_t rpc__resp__eap_set_password__pack_to_buffer + (const RpcRespEapSetPassword *message, + ProtobufCBuffer *buffer); +RpcRespEapSetPassword * + rpc__resp__eap_set_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_password__free_unpacked + (RpcRespEapSetPassword *message, + ProtobufCAllocator *allocator); +/* RpcReqEapClearPassword methods */ +void rpc__req__eap_clear_password__init + (RpcReqEapClearPassword *message); +size_t rpc__req__eap_clear_password__get_packed_size + (const RpcReqEapClearPassword *message); +size_t rpc__req__eap_clear_password__pack + (const RpcReqEapClearPassword *message, + uint8_t *out); +size_t rpc__req__eap_clear_password__pack_to_buffer + (const RpcReqEapClearPassword *message, + ProtobufCBuffer *buffer); +RpcReqEapClearPassword * + rpc__req__eap_clear_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_clear_password__free_unpacked + (RpcReqEapClearPassword *message, + ProtobufCAllocator *allocator); +/* RpcRespEapClearPassword methods */ +void rpc__resp__eap_clear_password__init + (RpcRespEapClearPassword *message); +size_t rpc__resp__eap_clear_password__get_packed_size + (const RpcRespEapClearPassword *message); +size_t rpc__resp__eap_clear_password__pack + (const RpcRespEapClearPassword *message, + uint8_t *out); +size_t rpc__resp__eap_clear_password__pack_to_buffer + (const RpcRespEapClearPassword *message, + ProtobufCBuffer *buffer); +RpcRespEapClearPassword * + rpc__resp__eap_clear_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_clear_password__free_unpacked + (RpcRespEapClearPassword *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetNewPassword methods */ +void rpc__req__eap_set_new_password__init + (RpcReqEapSetNewPassword *message); +size_t rpc__req__eap_set_new_password__get_packed_size + (const RpcReqEapSetNewPassword *message); +size_t rpc__req__eap_set_new_password__pack + (const RpcReqEapSetNewPassword *message, + uint8_t *out); +size_t rpc__req__eap_set_new_password__pack_to_buffer + (const RpcReqEapSetNewPassword *message, + ProtobufCBuffer *buffer); +RpcReqEapSetNewPassword * + rpc__req__eap_set_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_new_password__free_unpacked + (RpcReqEapSetNewPassword *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetNewPassword methods */ +void rpc__resp__eap_set_new_password__init + (RpcRespEapSetNewPassword *message); +size_t rpc__resp__eap_set_new_password__get_packed_size + (const RpcRespEapSetNewPassword *message); +size_t rpc__resp__eap_set_new_password__pack + (const RpcRespEapSetNewPassword *message, + uint8_t *out); +size_t rpc__resp__eap_set_new_password__pack_to_buffer + (const RpcRespEapSetNewPassword *message, + ProtobufCBuffer *buffer); +RpcRespEapSetNewPassword * + rpc__resp__eap_set_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_new_password__free_unpacked + (RpcRespEapSetNewPassword *message, + ProtobufCAllocator *allocator); +/* RpcReqEapClearNewPassword methods */ +void rpc__req__eap_clear_new_password__init + (RpcReqEapClearNewPassword *message); +size_t rpc__req__eap_clear_new_password__get_packed_size + (const RpcReqEapClearNewPassword *message); +size_t rpc__req__eap_clear_new_password__pack + (const RpcReqEapClearNewPassword *message, + uint8_t *out); +size_t rpc__req__eap_clear_new_password__pack_to_buffer + (const RpcReqEapClearNewPassword *message, + ProtobufCBuffer *buffer); +RpcReqEapClearNewPassword * + rpc__req__eap_clear_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_clear_new_password__free_unpacked + (RpcReqEapClearNewPassword *message, + ProtobufCAllocator *allocator); +/* RpcRespEapClearNewPassword methods */ +void rpc__resp__eap_clear_new_password__init + (RpcRespEapClearNewPassword *message); +size_t rpc__resp__eap_clear_new_password__get_packed_size + (const RpcRespEapClearNewPassword *message); +size_t rpc__resp__eap_clear_new_password__pack + (const RpcRespEapClearNewPassword *message, + uint8_t *out); +size_t rpc__resp__eap_clear_new_password__pack_to_buffer + (const RpcRespEapClearNewPassword *message, + ProtobufCBuffer *buffer); +RpcRespEapClearNewPassword * + rpc__resp__eap_clear_new_password__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_clear_new_password__free_unpacked + (RpcRespEapClearNewPassword *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetCaCert methods */ +void rpc__req__eap_set_ca_cert__init + (RpcReqEapSetCaCert *message); +size_t rpc__req__eap_set_ca_cert__get_packed_size + (const RpcReqEapSetCaCert *message); +size_t rpc__req__eap_set_ca_cert__pack + (const RpcReqEapSetCaCert *message, + uint8_t *out); +size_t rpc__req__eap_set_ca_cert__pack_to_buffer + (const RpcReqEapSetCaCert *message, + ProtobufCBuffer *buffer); +RpcReqEapSetCaCert * + rpc__req__eap_set_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_ca_cert__free_unpacked + (RpcReqEapSetCaCert *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetCaCert methods */ +void rpc__resp__eap_set_ca_cert__init + (RpcRespEapSetCaCert *message); +size_t rpc__resp__eap_set_ca_cert__get_packed_size + (const RpcRespEapSetCaCert *message); +size_t rpc__resp__eap_set_ca_cert__pack + (const RpcRespEapSetCaCert *message, + uint8_t *out); +size_t rpc__resp__eap_set_ca_cert__pack_to_buffer + (const RpcRespEapSetCaCert *message, + ProtobufCBuffer *buffer); +RpcRespEapSetCaCert * + rpc__resp__eap_set_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_ca_cert__free_unpacked + (RpcRespEapSetCaCert *message, + ProtobufCAllocator *allocator); +/* RpcReqEapClearCaCert methods */ +void rpc__req__eap_clear_ca_cert__init + (RpcReqEapClearCaCert *message); +size_t rpc__req__eap_clear_ca_cert__get_packed_size + (const RpcReqEapClearCaCert *message); +size_t rpc__req__eap_clear_ca_cert__pack + (const RpcReqEapClearCaCert *message, + uint8_t *out); +size_t rpc__req__eap_clear_ca_cert__pack_to_buffer + (const RpcReqEapClearCaCert *message, + ProtobufCBuffer *buffer); +RpcReqEapClearCaCert * + rpc__req__eap_clear_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_clear_ca_cert__free_unpacked + (RpcReqEapClearCaCert *message, + ProtobufCAllocator *allocator); +/* RpcRespEapClearCaCert methods */ +void rpc__resp__eap_clear_ca_cert__init + (RpcRespEapClearCaCert *message); +size_t rpc__resp__eap_clear_ca_cert__get_packed_size + (const RpcRespEapClearCaCert *message); +size_t rpc__resp__eap_clear_ca_cert__pack + (const RpcRespEapClearCaCert *message, + uint8_t *out); +size_t rpc__resp__eap_clear_ca_cert__pack_to_buffer + (const RpcRespEapClearCaCert *message, + ProtobufCBuffer *buffer); +RpcRespEapClearCaCert * + rpc__resp__eap_clear_ca_cert__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_clear_ca_cert__free_unpacked + (RpcRespEapClearCaCert *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetCertificateAndKey methods */ +void rpc__req__eap_set_certificate_and_key__init + (RpcReqEapSetCertificateAndKey *message); +size_t rpc__req__eap_set_certificate_and_key__get_packed_size + (const RpcReqEapSetCertificateAndKey *message); +size_t rpc__req__eap_set_certificate_and_key__pack + (const RpcReqEapSetCertificateAndKey *message, + uint8_t *out); +size_t rpc__req__eap_set_certificate_and_key__pack_to_buffer + (const RpcReqEapSetCertificateAndKey *message, + ProtobufCBuffer *buffer); +RpcReqEapSetCertificateAndKey * + rpc__req__eap_set_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_certificate_and_key__free_unpacked + (RpcReqEapSetCertificateAndKey *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetCertificateAndKey methods */ +void rpc__resp__eap_set_certificate_and_key__init + (RpcRespEapSetCertificateAndKey *message); +size_t rpc__resp__eap_set_certificate_and_key__get_packed_size + (const RpcRespEapSetCertificateAndKey *message); +size_t rpc__resp__eap_set_certificate_and_key__pack + (const RpcRespEapSetCertificateAndKey *message, + uint8_t *out); +size_t rpc__resp__eap_set_certificate_and_key__pack_to_buffer + (const RpcRespEapSetCertificateAndKey *message, + ProtobufCBuffer *buffer); +RpcRespEapSetCertificateAndKey * + rpc__resp__eap_set_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_certificate_and_key__free_unpacked + (RpcRespEapSetCertificateAndKey *message, + ProtobufCAllocator *allocator); +/* RpcReqEapClearCertificateAndKey methods */ +void rpc__req__eap_clear_certificate_and_key__init + (RpcReqEapClearCertificateAndKey *message); +size_t rpc__req__eap_clear_certificate_and_key__get_packed_size + (const RpcReqEapClearCertificateAndKey *message); +size_t rpc__req__eap_clear_certificate_and_key__pack + (const RpcReqEapClearCertificateAndKey *message, + uint8_t *out); +size_t rpc__req__eap_clear_certificate_and_key__pack_to_buffer + (const RpcReqEapClearCertificateAndKey *message, + ProtobufCBuffer *buffer); +RpcReqEapClearCertificateAndKey * + rpc__req__eap_clear_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_clear_certificate_and_key__free_unpacked + (RpcReqEapClearCertificateAndKey *message, + ProtobufCAllocator *allocator); +/* RpcRespEapClearCertificateAndKey methods */ +void rpc__resp__eap_clear_certificate_and_key__init + (RpcRespEapClearCertificateAndKey *message); +size_t rpc__resp__eap_clear_certificate_and_key__get_packed_size + (const RpcRespEapClearCertificateAndKey *message); +size_t rpc__resp__eap_clear_certificate_and_key__pack + (const RpcRespEapClearCertificateAndKey *message, + uint8_t *out); +size_t rpc__resp__eap_clear_certificate_and_key__pack_to_buffer + (const RpcRespEapClearCertificateAndKey *message, + ProtobufCBuffer *buffer); +RpcRespEapClearCertificateAndKey * + rpc__resp__eap_clear_certificate_and_key__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_clear_certificate_and_key__free_unpacked + (RpcRespEapClearCertificateAndKey *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetDisableTimeCheck methods */ +void rpc__req__eap_set_disable_time_check__init + (RpcReqEapSetDisableTimeCheck *message); +size_t rpc__req__eap_set_disable_time_check__get_packed_size + (const RpcReqEapSetDisableTimeCheck *message); +size_t rpc__req__eap_set_disable_time_check__pack + (const RpcReqEapSetDisableTimeCheck *message, + uint8_t *out); +size_t rpc__req__eap_set_disable_time_check__pack_to_buffer + (const RpcReqEapSetDisableTimeCheck *message, + ProtobufCBuffer *buffer); +RpcReqEapSetDisableTimeCheck * + rpc__req__eap_set_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_disable_time_check__free_unpacked + (RpcReqEapSetDisableTimeCheck *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetDisableTimeCheck methods */ +void rpc__resp__eap_set_disable_time_check__init + (RpcRespEapSetDisableTimeCheck *message); +size_t rpc__resp__eap_set_disable_time_check__get_packed_size + (const RpcRespEapSetDisableTimeCheck *message); +size_t rpc__resp__eap_set_disable_time_check__pack + (const RpcRespEapSetDisableTimeCheck *message, + uint8_t *out); +size_t rpc__resp__eap_set_disable_time_check__pack_to_buffer + (const RpcRespEapSetDisableTimeCheck *message, + ProtobufCBuffer *buffer); +RpcRespEapSetDisableTimeCheck * + rpc__resp__eap_set_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_disable_time_check__free_unpacked + (RpcRespEapSetDisableTimeCheck *message, + ProtobufCAllocator *allocator); +/* RpcReqEapGetDisableTimeCheck methods */ +void rpc__req__eap_get_disable_time_check__init + (RpcReqEapGetDisableTimeCheck *message); +size_t rpc__req__eap_get_disable_time_check__get_packed_size + (const RpcReqEapGetDisableTimeCheck *message); +size_t rpc__req__eap_get_disable_time_check__pack + (const RpcReqEapGetDisableTimeCheck *message, + uint8_t *out); +size_t rpc__req__eap_get_disable_time_check__pack_to_buffer + (const RpcReqEapGetDisableTimeCheck *message, + ProtobufCBuffer *buffer); +RpcReqEapGetDisableTimeCheck * + rpc__req__eap_get_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_get_disable_time_check__free_unpacked + (RpcReqEapGetDisableTimeCheck *message, + ProtobufCAllocator *allocator); +/* RpcRespEapGetDisableTimeCheck methods */ +void rpc__resp__eap_get_disable_time_check__init + (RpcRespEapGetDisableTimeCheck *message); +size_t rpc__resp__eap_get_disable_time_check__get_packed_size + (const RpcRespEapGetDisableTimeCheck *message); +size_t rpc__resp__eap_get_disable_time_check__pack + (const RpcRespEapGetDisableTimeCheck *message, + uint8_t *out); +size_t rpc__resp__eap_get_disable_time_check__pack_to_buffer + (const RpcRespEapGetDisableTimeCheck *message, + ProtobufCBuffer *buffer); +RpcRespEapGetDisableTimeCheck * + rpc__resp__eap_get_disable_time_check__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_get_disable_time_check__free_unpacked + (RpcRespEapGetDisableTimeCheck *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetTtlsPhase2Method methods */ +void rpc__req__eap_set_ttls_phase2_method__init + (RpcReqEapSetTtlsPhase2Method *message); +size_t rpc__req__eap_set_ttls_phase2_method__get_packed_size + (const RpcReqEapSetTtlsPhase2Method *message); +size_t rpc__req__eap_set_ttls_phase2_method__pack + (const RpcReqEapSetTtlsPhase2Method *message, + uint8_t *out); +size_t rpc__req__eap_set_ttls_phase2_method__pack_to_buffer + (const RpcReqEapSetTtlsPhase2Method *message, + ProtobufCBuffer *buffer); +RpcReqEapSetTtlsPhase2Method * + rpc__req__eap_set_ttls_phase2_method__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_ttls_phase2_method__free_unpacked + (RpcReqEapSetTtlsPhase2Method *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetTtlsPhase2Method methods */ +void rpc__resp__eap_set_ttls_phase2_method__init + (RpcRespEapSetTtlsPhase2Method *message); +size_t rpc__resp__eap_set_ttls_phase2_method__get_packed_size + (const RpcRespEapSetTtlsPhase2Method *message); +size_t rpc__resp__eap_set_ttls_phase2_method__pack + (const RpcRespEapSetTtlsPhase2Method *message, + uint8_t *out); +size_t rpc__resp__eap_set_ttls_phase2_method__pack_to_buffer + (const RpcRespEapSetTtlsPhase2Method *message, + ProtobufCBuffer *buffer); +RpcRespEapSetTtlsPhase2Method * + rpc__resp__eap_set_ttls_phase2_method__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_ttls_phase2_method__free_unpacked + (RpcRespEapSetTtlsPhase2Method *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetSuiteb192bitCertification methods */ +void rpc__req__eap_set_suiteb192bit_certification__init + (RpcReqEapSetSuiteb192bitCertification *message); +size_t rpc__req__eap_set_suiteb192bit_certification__get_packed_size + (const RpcReqEapSetSuiteb192bitCertification *message); +size_t rpc__req__eap_set_suiteb192bit_certification__pack + (const RpcReqEapSetSuiteb192bitCertification *message, + uint8_t *out); +size_t rpc__req__eap_set_suiteb192bit_certification__pack_to_buffer + (const RpcReqEapSetSuiteb192bitCertification *message, + ProtobufCBuffer *buffer); +RpcReqEapSetSuiteb192bitCertification * + rpc__req__eap_set_suiteb192bit_certification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_suiteb192bit_certification__free_unpacked + (RpcReqEapSetSuiteb192bitCertification *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetSuiteb192bitCertification methods */ +void rpc__resp__eap_set_suiteb192bit_certification__init + (RpcRespEapSetSuiteb192bitCertification *message); +size_t rpc__resp__eap_set_suiteb192bit_certification__get_packed_size + (const RpcRespEapSetSuiteb192bitCertification *message); +size_t rpc__resp__eap_set_suiteb192bit_certification__pack + (const RpcRespEapSetSuiteb192bitCertification *message, + uint8_t *out); +size_t rpc__resp__eap_set_suiteb192bit_certification__pack_to_buffer + (const RpcRespEapSetSuiteb192bitCertification *message, + ProtobufCBuffer *buffer); +RpcRespEapSetSuiteb192bitCertification * + rpc__resp__eap_set_suiteb192bit_certification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_suiteb192bit_certification__free_unpacked + (RpcRespEapSetSuiteb192bitCertification *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetPacFile methods */ +void rpc__req__eap_set_pac_file__init + (RpcReqEapSetPacFile *message); +size_t rpc__req__eap_set_pac_file__get_packed_size + (const RpcReqEapSetPacFile *message); +size_t rpc__req__eap_set_pac_file__pack + (const RpcReqEapSetPacFile *message, + uint8_t *out); +size_t rpc__req__eap_set_pac_file__pack_to_buffer + (const RpcReqEapSetPacFile *message, + ProtobufCBuffer *buffer); +RpcReqEapSetPacFile * + rpc__req__eap_set_pac_file__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_pac_file__free_unpacked + (RpcReqEapSetPacFile *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetPacFile methods */ +void rpc__resp__eap_set_pac_file__init + (RpcRespEapSetPacFile *message); +size_t rpc__resp__eap_set_pac_file__get_packed_size + (const RpcRespEapSetPacFile *message); +size_t rpc__resp__eap_set_pac_file__pack + (const RpcRespEapSetPacFile *message, + uint8_t *out); +size_t rpc__resp__eap_set_pac_file__pack_to_buffer + (const RpcRespEapSetPacFile *message, + ProtobufCBuffer *buffer); +RpcRespEapSetPacFile * + rpc__resp__eap_set_pac_file__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_pac_file__free_unpacked + (RpcRespEapSetPacFile *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetFastParams methods */ +void rpc__req__eap_set_fast_params__init + (RpcReqEapSetFastParams *message); +size_t rpc__req__eap_set_fast_params__get_packed_size + (const RpcReqEapSetFastParams *message); +size_t rpc__req__eap_set_fast_params__pack + (const RpcReqEapSetFastParams *message, + uint8_t *out); +size_t rpc__req__eap_set_fast_params__pack_to_buffer + (const RpcReqEapSetFastParams *message, + ProtobufCBuffer *buffer); +RpcReqEapSetFastParams * + rpc__req__eap_set_fast_params__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_fast_params__free_unpacked + (RpcReqEapSetFastParams *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetFastParams methods */ +void rpc__resp__eap_set_fast_params__init + (RpcRespEapSetFastParams *message); +size_t rpc__resp__eap_set_fast_params__get_packed_size + (const RpcRespEapSetFastParams *message); +size_t rpc__resp__eap_set_fast_params__pack + (const RpcRespEapSetFastParams *message, + uint8_t *out); +size_t rpc__resp__eap_set_fast_params__pack_to_buffer + (const RpcRespEapSetFastParams *message, + ProtobufCBuffer *buffer); +RpcRespEapSetFastParams * + rpc__resp__eap_set_fast_params__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_fast_params__free_unpacked + (RpcRespEapSetFastParams *message, + ProtobufCAllocator *allocator); +/* RpcReqEapUseDefaultCertBundle methods */ +void rpc__req__eap_use_default_cert_bundle__init + (RpcReqEapUseDefaultCertBundle *message); +size_t rpc__req__eap_use_default_cert_bundle__get_packed_size + (const RpcReqEapUseDefaultCertBundle *message); +size_t rpc__req__eap_use_default_cert_bundle__pack + (const RpcReqEapUseDefaultCertBundle *message, + uint8_t *out); +size_t rpc__req__eap_use_default_cert_bundle__pack_to_buffer + (const RpcReqEapUseDefaultCertBundle *message, + ProtobufCBuffer *buffer); +RpcReqEapUseDefaultCertBundle * + rpc__req__eap_use_default_cert_bundle__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_use_default_cert_bundle__free_unpacked + (RpcReqEapUseDefaultCertBundle *message, + ProtobufCAllocator *allocator); +/* RpcRespEapUseDefaultCertBundle methods */ +void rpc__resp__eap_use_default_cert_bundle__init + (RpcRespEapUseDefaultCertBundle *message); +size_t rpc__resp__eap_use_default_cert_bundle__get_packed_size + (const RpcRespEapUseDefaultCertBundle *message); +size_t rpc__resp__eap_use_default_cert_bundle__pack + (const RpcRespEapUseDefaultCertBundle *message, + uint8_t *out); +size_t rpc__resp__eap_use_default_cert_bundle__pack_to_buffer + (const RpcRespEapUseDefaultCertBundle *message, + ProtobufCBuffer *buffer); +RpcRespEapUseDefaultCertBundle * + rpc__resp__eap_use_default_cert_bundle__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_use_default_cert_bundle__free_unpacked + (RpcRespEapUseDefaultCertBundle *message, + ProtobufCAllocator *allocator); +/* RpcReqWifiSetOkcSupport methods */ +void rpc__req__wifi_set_okc_support__init + (RpcReqWifiSetOkcSupport *message); +size_t rpc__req__wifi_set_okc_support__get_packed_size + (const RpcReqWifiSetOkcSupport *message); +size_t rpc__req__wifi_set_okc_support__pack + (const RpcReqWifiSetOkcSupport *message, + uint8_t *out); +size_t rpc__req__wifi_set_okc_support__pack_to_buffer + (const RpcReqWifiSetOkcSupport *message, + ProtobufCBuffer *buffer); +RpcReqWifiSetOkcSupport * + rpc__req__wifi_set_okc_support__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__wifi_set_okc_support__free_unpacked + (RpcReqWifiSetOkcSupport *message, + ProtobufCAllocator *allocator); +/* RpcRespWifiSetOkcSupport methods */ +void rpc__resp__wifi_set_okc_support__init + (RpcRespWifiSetOkcSupport *message); +size_t rpc__resp__wifi_set_okc_support__get_packed_size + (const RpcRespWifiSetOkcSupport *message); +size_t rpc__resp__wifi_set_okc_support__pack + (const RpcRespWifiSetOkcSupport *message, + uint8_t *out); +size_t rpc__resp__wifi_set_okc_support__pack_to_buffer + (const RpcRespWifiSetOkcSupport *message, + ProtobufCBuffer *buffer); +RpcRespWifiSetOkcSupport * + rpc__resp__wifi_set_okc_support__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__wifi_set_okc_support__free_unpacked + (RpcRespWifiSetOkcSupport *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetDomainName methods */ +void rpc__req__eap_set_domain_name__init + (RpcReqEapSetDomainName *message); +size_t rpc__req__eap_set_domain_name__get_packed_size + (const RpcReqEapSetDomainName *message); +size_t rpc__req__eap_set_domain_name__pack + (const RpcReqEapSetDomainName *message, + uint8_t *out); +size_t rpc__req__eap_set_domain_name__pack_to_buffer + (const RpcReqEapSetDomainName *message, + ProtobufCBuffer *buffer); +RpcReqEapSetDomainName * + rpc__req__eap_set_domain_name__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_domain_name__free_unpacked + (RpcReqEapSetDomainName *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetDomainName methods */ +void rpc__resp__eap_set_domain_name__init + (RpcRespEapSetDomainName *message); +size_t rpc__resp__eap_set_domain_name__get_packed_size + (const RpcRespEapSetDomainName *message); +size_t rpc__resp__eap_set_domain_name__pack + (const RpcRespEapSetDomainName *message, + uint8_t *out); +size_t rpc__resp__eap_set_domain_name__pack_to_buffer + (const RpcRespEapSetDomainName *message, + ProtobufCBuffer *buffer); +RpcRespEapSetDomainName * + rpc__resp__eap_set_domain_name__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_domain_name__free_unpacked + (RpcRespEapSetDomainName *message, + ProtobufCAllocator *allocator); +/* RpcReqEapSetEapMethods methods */ +void rpc__req__eap_set_eap_methods__init + (RpcReqEapSetEapMethods *message); +size_t rpc__req__eap_set_eap_methods__get_packed_size + (const RpcReqEapSetEapMethods *message); +size_t rpc__req__eap_set_eap_methods__pack + (const RpcReqEapSetEapMethods *message, + uint8_t *out); +size_t rpc__req__eap_set_eap_methods__pack_to_buffer + (const RpcReqEapSetEapMethods *message, + ProtobufCBuffer *buffer); +RpcReqEapSetEapMethods * + rpc__req__eap_set_eap_methods__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__req__eap_set_eap_methods__free_unpacked + (RpcReqEapSetEapMethods *message, + ProtobufCAllocator *allocator); +/* RpcRespEapSetEapMethods methods */ +void rpc__resp__eap_set_eap_methods__init + (RpcRespEapSetEapMethods *message); +size_t rpc__resp__eap_set_eap_methods__get_packed_size + (const RpcRespEapSetEapMethods *message); +size_t rpc__resp__eap_set_eap_methods__pack + (const RpcRespEapSetEapMethods *message, + uint8_t *out); +size_t rpc__resp__eap_set_eap_methods__pack_to_buffer + (const RpcRespEapSetEapMethods *message, + ProtobufCBuffer *buffer); +RpcRespEapSetEapMethods * + rpc__resp__eap_set_eap_methods__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__resp__eap_set_eap_methods__free_unpacked + (RpcRespEapSetEapMethods *message, + ProtobufCAllocator *allocator); +/* RpcEventSuppDppUriReady methods */ +void rpc__event__supp_dpp_uri_ready__init + (RpcEventSuppDppUriReady *message); +size_t rpc__event__supp_dpp_uri_ready__get_packed_size + (const RpcEventSuppDppUriReady *message); +size_t rpc__event__supp_dpp_uri_ready__pack + (const RpcEventSuppDppUriReady *message, + uint8_t *out); +size_t rpc__event__supp_dpp_uri_ready__pack_to_buffer + (const RpcEventSuppDppUriReady *message, + ProtobufCBuffer *buffer); +RpcEventSuppDppUriReady * + rpc__event__supp_dpp_uri_ready__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__supp_dpp_uri_ready__free_unpacked + (RpcEventSuppDppUriReady *message, + ProtobufCAllocator *allocator); +/* RpcEventSuppDppCfgRecvd methods */ +void rpc__event__supp_dpp_cfg_recvd__init + (RpcEventSuppDppCfgRecvd *message); +size_t rpc__event__supp_dpp_cfg_recvd__get_packed_size + (const RpcEventSuppDppCfgRecvd *message); +size_t rpc__event__supp_dpp_cfg_recvd__pack + (const RpcEventSuppDppCfgRecvd *message, + uint8_t *out); +size_t rpc__event__supp_dpp_cfg_recvd__pack_to_buffer + (const RpcEventSuppDppCfgRecvd *message, + ProtobufCBuffer *buffer); +RpcEventSuppDppCfgRecvd * + rpc__event__supp_dpp_cfg_recvd__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__supp_dpp_cfg_recvd__free_unpacked + (RpcEventSuppDppCfgRecvd *message, + ProtobufCAllocator *allocator); +/* RpcEventSuppDppFail methods */ +void rpc__event__supp_dpp_fail__init + (RpcEventSuppDppFail *message); +size_t rpc__event__supp_dpp_fail__get_packed_size + (const RpcEventSuppDppFail *message); +size_t rpc__event__supp_dpp_fail__pack + (const RpcEventSuppDppFail *message, + uint8_t *out); +size_t rpc__event__supp_dpp_fail__pack_to_buffer + (const RpcEventSuppDppFail *message, + ProtobufCBuffer *buffer); +RpcEventSuppDppFail * + rpc__event__supp_dpp_fail__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__supp_dpp_fail__free_unpacked + (RpcEventSuppDppFail *message, + ProtobufCAllocator *allocator); +/* RpcEventWifiDppUriReady methods */ +void rpc__event__wifi_dpp_uri_ready__init + (RpcEventWifiDppUriReady *message); +size_t rpc__event__wifi_dpp_uri_ready__get_packed_size + (const RpcEventWifiDppUriReady *message); +size_t rpc__event__wifi_dpp_uri_ready__pack + (const RpcEventWifiDppUriReady *message, + uint8_t *out); +size_t rpc__event__wifi_dpp_uri_ready__pack_to_buffer + (const RpcEventWifiDppUriReady *message, + ProtobufCBuffer *buffer); +RpcEventWifiDppUriReady * + rpc__event__wifi_dpp_uri_ready__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__wifi_dpp_uri_ready__free_unpacked + (RpcEventWifiDppUriReady *message, + ProtobufCAllocator *allocator); +/* RpcEventWifiDppCfgRecvd methods */ +void rpc__event__wifi_dpp_cfg_recvd__init + (RpcEventWifiDppCfgRecvd *message); +size_t rpc__event__wifi_dpp_cfg_recvd__get_packed_size + (const RpcEventWifiDppCfgRecvd *message); +size_t rpc__event__wifi_dpp_cfg_recvd__pack + (const RpcEventWifiDppCfgRecvd *message, + uint8_t *out); +size_t rpc__event__wifi_dpp_cfg_recvd__pack_to_buffer + (const RpcEventWifiDppCfgRecvd *message, + ProtobufCBuffer *buffer); +RpcEventWifiDppCfgRecvd * + rpc__event__wifi_dpp_cfg_recvd__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__wifi_dpp_cfg_recvd__free_unpacked + (RpcEventWifiDppCfgRecvd *message, + ProtobufCAllocator *allocator); +/* RpcEventWifiDppFail methods */ +void rpc__event__wifi_dpp_fail__init + (RpcEventWifiDppFail *message); +size_t rpc__event__wifi_dpp_fail__get_packed_size + (const RpcEventWifiDppFail *message); +size_t rpc__event__wifi_dpp_fail__pack + (const RpcEventWifiDppFail *message, + uint8_t *out); +size_t rpc__event__wifi_dpp_fail__pack_to_buffer + (const RpcEventWifiDppFail *message, + ProtobufCBuffer *buffer); +RpcEventWifiDppFail * + rpc__event__wifi_dpp_fail__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__event__wifi_dpp_fail__free_unpacked + (RpcEventWifiDppFail *message, + ProtobufCAllocator *allocator); +/* Rpc methods */ +void rpc__init + (Rpc *message); +size_t rpc__get_packed_size + (const Rpc *message); +size_t rpc__pack + (const Rpc *message, + uint8_t *out); +size_t rpc__pack_to_buffer + (const Rpc *message, + ProtobufCBuffer *buffer); +Rpc * + rpc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void rpc__free_unpacked + (Rpc *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*WifiInitConfig_Closure) + (const WifiInitConfig *message, + void *closure_data); +typedef void (*WifiCountry_Closure) + (const WifiCountry *message, + void *closure_data); +typedef void (*WifiActiveScanTime_Closure) + (const WifiActiveScanTime *message, + void *closure_data); +typedef void (*WifiScanTime_Closure) + (const WifiScanTime *message, + void *closure_data); +typedef void (*WifiScanChannelBitmap_Closure) + (const WifiScanChannelBitmap *message, + void *closure_data); +typedef void (*WifiScanConfig_Closure) + (const WifiScanConfig *message, + void *closure_data); +typedef void (*WifiHeApInfo_Closure) + (const WifiHeApInfo *message, + void *closure_data); +typedef void (*WifiApRecord_Closure) + (const WifiApRecord *message, + void *closure_data); +typedef void (*WifiScanThreshold_Closure) + (const WifiScanThreshold *message, + void *closure_data); +typedef void (*WifiPmfConfig_Closure) + (const WifiPmfConfig *message, + void *closure_data); +typedef void (*WifiBssMaxIdleConfig_Closure) + (const WifiBssMaxIdleConfig *message, + void *closure_data); +typedef void (*WifiApConfig_Closure) + (const WifiApConfig *message, + void *closure_data); +typedef void (*WifiStaConfig_Closure) + (const WifiStaConfig *message, + void *closure_data); +typedef void (*WifiConfig_Closure) + (const WifiConfig *message, + void *closure_data); +typedef void (*WifiStaInfo_Closure) + (const WifiStaInfo *message, + void *closure_data); +typedef void (*WifiStaList_Closure) + (const WifiStaList *message, + void *closure_data); +typedef void (*WifiPktRxCtrl_Closure) + (const WifiPktRxCtrl *message, + void *closure_data); +typedef void (*WifiPromiscuousPkt_Closure) + (const WifiPromiscuousPkt *message, + void *closure_data); +typedef void (*WifiPromiscuousFilter_Closure) + (const WifiPromiscuousFilter *message, + void *closure_data); +typedef void (*WifiCsiConfig_Closure) + (const WifiCsiConfig *message, + void *closure_data); +typedef void (*WifiCsiInfo_Closure) + (const WifiCsiInfo *message, + void *closure_data); +typedef void (*WifiAntGpio_Closure) + (const WifiAntGpio *message, + void *closure_data); +typedef void (*WifiAntGpioConfig_Closure) + (const WifiAntGpioConfig *message, + void *closure_data); +typedef void (*WifiAntConfig_Closure) + (const WifiAntConfig *message, + void *closure_data); +typedef void (*WifiActionTxReq_Closure) + (const WifiActionTxReq *message, + void *closure_data); +typedef void (*WifiFtmInitiatorCfg_Closure) + (const WifiFtmInitiatorCfg *message, + void *closure_data); +typedef void (*WifiEventStaScanDone_Closure) + (const WifiEventStaScanDone *message, + void *closure_data); +typedef void (*WifiEventStaConnected_Closure) + (const WifiEventStaConnected *message, + void *closure_data); +typedef void (*WifiEventStaDisconnected_Closure) + (const WifiEventStaDisconnected *message, + void *closure_data); +typedef void (*WifiEventStaAuthmodeChange_Closure) + (const WifiEventStaAuthmodeChange *message, + void *closure_data); +typedef void (*WifiEventStaWpsErPin_Closure) + (const WifiEventStaWpsErPin *message, + void *closure_data); +typedef void (*ApCred_Closure) + (const ApCred *message, + void *closure_data); +typedef void (*WifiEventStaWpsErSuccess_Closure) + (const WifiEventStaWpsErSuccess *message, + void *closure_data); +typedef void (*WifiEventApProbeReqRx_Closure) + (const WifiEventApProbeReqRx *message, + void *closure_data); +typedef void (*WifiEventBssRssiLow_Closure) + (const WifiEventBssRssiLow *message, + void *closure_data); +typedef void (*WifiFtmReportEntry_Closure) + (const WifiFtmReportEntry *message, + void *closure_data); +typedef void (*WifiEventFtmReport_Closure) + (const WifiEventFtmReport *message, + void *closure_data); +typedef void (*WifiEventActionTxStatus_Closure) + (const WifiEventActionTxStatus *message, + void *closure_data); +typedef void (*WifiEventRocDone_Closure) + (const WifiEventRocDone *message, + void *closure_data); +typedef void (*WifiEventApWpsRgPin_Closure) + (const WifiEventApWpsRgPin *message, + void *closure_data); +typedef void (*WifiEventApWpsRgFailReason_Closure) + (const WifiEventApWpsRgFailReason *message, + void *closure_data); +typedef void (*WifiEventApWpsRgSuccess_Closure) + (const WifiEventApWpsRgSuccess *message, + void *closure_data); +typedef void (*WifiProtocols_Closure) + (const WifiProtocols *message, + void *closure_data); +typedef void (*WifiBandwidths_Closure) + (const WifiBandwidths *message, + void *closure_data); +typedef void (*WifiItwtSetupConfig_Closure) + (const WifiItwtSetupConfig *message, + void *closure_data); +typedef void (*WifiTwtConfig_Closure) + (const WifiTwtConfig *message, + void *closure_data); +typedef void (*ConnectedSTAList_Closure) + (const ConnectedSTAList *message, + void *closure_data); +typedef void (*EapFastConfig_Closure) + (const EapFastConfig *message, + void *closure_data); +typedef void (*RpcReqGetMacAddress_Closure) + (const RpcReqGetMacAddress *message, + void *closure_data); +typedef void (*RpcRespGetMacAddress_Closure) + (const RpcRespGetMacAddress *message, + void *closure_data); +typedef void (*RpcReqGetMode_Closure) + (const RpcReqGetMode *message, + void *closure_data); +typedef void (*RpcRespGetMode_Closure) + (const RpcRespGetMode *message, + void *closure_data); +typedef void (*RpcReqSetMode_Closure) + (const RpcReqSetMode *message, + void *closure_data); +typedef void (*RpcRespSetMode_Closure) + (const RpcRespSetMode *message, + void *closure_data); +typedef void (*RpcReqGetPs_Closure) + (const RpcReqGetPs *message, + void *closure_data); +typedef void (*RpcRespGetPs_Closure) + (const RpcRespGetPs *message, + void *closure_data); +typedef void (*RpcReqSetPs_Closure) + (const RpcReqSetPs *message, + void *closure_data); +typedef void (*RpcRespSetPs_Closure) + (const RpcRespSetPs *message, + void *closure_data); +typedef void (*RpcReqSetMacAddress_Closure) + (const RpcReqSetMacAddress *message, + void *closure_data); +typedef void (*RpcRespSetMacAddress_Closure) + (const RpcRespSetMacAddress *message, + void *closure_data); +typedef void (*RpcReqOTABegin_Closure) + (const RpcReqOTABegin *message, + void *closure_data); +typedef void (*RpcRespOTABegin_Closure) + (const RpcRespOTABegin *message, + void *closure_data); +typedef void (*RpcReqOTAWrite_Closure) + (const RpcReqOTAWrite *message, + void *closure_data); +typedef void (*RpcRespOTAWrite_Closure) + (const RpcRespOTAWrite *message, + void *closure_data); +typedef void (*RpcReqOTAEnd_Closure) + (const RpcReqOTAEnd *message, + void *closure_data); +typedef void (*RpcRespOTAEnd_Closure) + (const RpcRespOTAEnd *message, + void *closure_data); +typedef void (*RpcReqWifiSetMaxTxPower_Closure) + (const RpcReqWifiSetMaxTxPower *message, + void *closure_data); +typedef void (*RpcRespWifiSetMaxTxPower_Closure) + (const RpcRespWifiSetMaxTxPower *message, + void *closure_data); +typedef void (*RpcReqWifiGetMaxTxPower_Closure) + (const RpcReqWifiGetMaxTxPower *message, + void *closure_data); +typedef void (*RpcRespWifiGetMaxTxPower_Closure) + (const RpcRespWifiGetMaxTxPower *message, + void *closure_data); +typedef void (*RpcReqConfigHeartbeat_Closure) + (const RpcReqConfigHeartbeat *message, + void *closure_data); +typedef void (*RpcRespConfigHeartbeat_Closure) + (const RpcRespConfigHeartbeat *message, + void *closure_data); +typedef void (*RpcReqWifiInit_Closure) + (const RpcReqWifiInit *message, + void *closure_data); +typedef void (*RpcRespWifiInit_Closure) + (const RpcRespWifiInit *message, + void *closure_data); +typedef void (*RpcReqWifiDeinit_Closure) + (const RpcReqWifiDeinit *message, + void *closure_data); +typedef void (*RpcRespWifiDeinit_Closure) + (const RpcRespWifiDeinit *message, + void *closure_data); +typedef void (*RpcReqWifiSetConfig_Closure) + (const RpcReqWifiSetConfig *message, + void *closure_data); +typedef void (*RpcRespWifiSetConfig_Closure) + (const RpcRespWifiSetConfig *message, + void *closure_data); +typedef void (*RpcReqWifiGetConfig_Closure) + (const RpcReqWifiGetConfig *message, + void *closure_data); +typedef void (*RpcRespWifiGetConfig_Closure) + (const RpcRespWifiGetConfig *message, + void *closure_data); +typedef void (*RpcReqWifiConnect_Closure) + (const RpcReqWifiConnect *message, + void *closure_data); +typedef void (*RpcRespWifiConnect_Closure) + (const RpcRespWifiConnect *message, + void *closure_data); +typedef void (*RpcReqWifiDisconnect_Closure) + (const RpcReqWifiDisconnect *message, + void *closure_data); +typedef void (*RpcRespWifiDisconnect_Closure) + (const RpcRespWifiDisconnect *message, + void *closure_data); +typedef void (*RpcReqWifiStart_Closure) + (const RpcReqWifiStart *message, + void *closure_data); +typedef void (*RpcRespWifiStart_Closure) + (const RpcRespWifiStart *message, + void *closure_data); +typedef void (*RpcReqWifiStop_Closure) + (const RpcReqWifiStop *message, + void *closure_data); +typedef void (*RpcRespWifiStop_Closure) + (const RpcRespWifiStop *message, + void *closure_data); +typedef void (*RpcReqWifiScanStart_Closure) + (const RpcReqWifiScanStart *message, + void *closure_data); +typedef void (*RpcRespWifiScanStart_Closure) + (const RpcRespWifiScanStart *message, + void *closure_data); +typedef void (*RpcReqWifiScanStop_Closure) + (const RpcReqWifiScanStop *message, + void *closure_data); +typedef void (*RpcRespWifiScanStop_Closure) + (const RpcRespWifiScanStop *message, + void *closure_data); +typedef void (*RpcReqWifiScanGetApNum_Closure) + (const RpcReqWifiScanGetApNum *message, + void *closure_data); +typedef void (*RpcRespWifiScanGetApNum_Closure) + (const RpcRespWifiScanGetApNum *message, + void *closure_data); +typedef void (*RpcReqWifiScanGetApRecords_Closure) + (const RpcReqWifiScanGetApRecords *message, + void *closure_data); +typedef void (*RpcRespWifiScanGetApRecords_Closure) + (const RpcRespWifiScanGetApRecords *message, + void *closure_data); +typedef void (*RpcReqWifiScanGetApRecord_Closure) + (const RpcReqWifiScanGetApRecord *message, + void *closure_data); +typedef void (*RpcRespWifiScanGetApRecord_Closure) + (const RpcRespWifiScanGetApRecord *message, + void *closure_data); +typedef void (*RpcReqWifiClearApList_Closure) + (const RpcReqWifiClearApList *message, + void *closure_data); +typedef void (*RpcRespWifiClearApList_Closure) + (const RpcRespWifiClearApList *message, + void *closure_data); +typedef void (*RpcReqWifiRestore_Closure) + (const RpcReqWifiRestore *message, + void *closure_data); +typedef void (*RpcRespWifiRestore_Closure) + (const RpcRespWifiRestore *message, + void *closure_data); +typedef void (*RpcReqWifiClearFastConnect_Closure) + (const RpcReqWifiClearFastConnect *message, + void *closure_data); +typedef void (*RpcRespWifiClearFastConnect_Closure) + (const RpcRespWifiClearFastConnect *message, + void *closure_data); +typedef void (*RpcReqWifiDeauthSta_Closure) + (const RpcReqWifiDeauthSta *message, + void *closure_data); +typedef void (*RpcRespWifiDeauthSta_Closure) + (const RpcRespWifiDeauthSta *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetApInfo_Closure) + (const RpcReqWifiStaGetApInfo *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetApInfo_Closure) + (const RpcRespWifiStaGetApInfo *message, + void *closure_data); +typedef void (*RpcReqWifiSetProtocol_Closure) + (const RpcReqWifiSetProtocol *message, + void *closure_data); +typedef void (*RpcRespWifiSetProtocol_Closure) + (const RpcRespWifiSetProtocol *message, + void *closure_data); +typedef void (*RpcReqWifiGetProtocol_Closure) + (const RpcReqWifiGetProtocol *message, + void *closure_data); +typedef void (*RpcRespWifiGetProtocol_Closure) + (const RpcRespWifiGetProtocol *message, + void *closure_data); +typedef void (*RpcReqWifiSetBandwidth_Closure) + (const RpcReqWifiSetBandwidth *message, + void *closure_data); +typedef void (*RpcRespWifiSetBandwidth_Closure) + (const RpcRespWifiSetBandwidth *message, + void *closure_data); +typedef void (*RpcReqWifiGetBandwidth_Closure) + (const RpcReqWifiGetBandwidth *message, + void *closure_data); +typedef void (*RpcRespWifiGetBandwidth_Closure) + (const RpcRespWifiGetBandwidth *message, + void *closure_data); +typedef void (*RpcReqWifiSetChannel_Closure) + (const RpcReqWifiSetChannel *message, + void *closure_data); +typedef void (*RpcRespWifiSetChannel_Closure) + (const RpcRespWifiSetChannel *message, + void *closure_data); +typedef void (*RpcReqWifiGetChannel_Closure) + (const RpcReqWifiGetChannel *message, + void *closure_data); +typedef void (*RpcRespWifiGetChannel_Closure) + (const RpcRespWifiGetChannel *message, + void *closure_data); +typedef void (*RpcReqWifiSetStorage_Closure) + (const RpcReqWifiSetStorage *message, + void *closure_data); +typedef void (*RpcRespWifiSetStorage_Closure) + (const RpcRespWifiSetStorage *message, + void *closure_data); +typedef void (*RpcReqWifiSetCountryCode_Closure) + (const RpcReqWifiSetCountryCode *message, + void *closure_data); +typedef void (*RpcRespWifiSetCountryCode_Closure) + (const RpcRespWifiSetCountryCode *message, + void *closure_data); +typedef void (*RpcReqWifiGetCountryCode_Closure) + (const RpcReqWifiGetCountryCode *message, + void *closure_data); +typedef void (*RpcRespWifiGetCountryCode_Closure) + (const RpcRespWifiGetCountryCode *message, + void *closure_data); +typedef void (*RpcReqWifiSetCountry_Closure) + (const RpcReqWifiSetCountry *message, + void *closure_data); +typedef void (*RpcRespWifiSetCountry_Closure) + (const RpcRespWifiSetCountry *message, + void *closure_data); +typedef void (*RpcReqWifiGetCountry_Closure) + (const RpcReqWifiGetCountry *message, + void *closure_data); +typedef void (*RpcRespWifiGetCountry_Closure) + (const RpcRespWifiGetCountry *message, + void *closure_data); +typedef void (*RpcReqWifiApGetStaList_Closure) + (const RpcReqWifiApGetStaList *message, + void *closure_data); +typedef void (*RpcRespWifiApGetStaList_Closure) + (const RpcRespWifiApGetStaList *message, + void *closure_data); +typedef void (*RpcReqWifiApGetStaAid_Closure) + (const RpcReqWifiApGetStaAid *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetNegotiatedPhymode_Closure) + (const RpcReqWifiStaGetNegotiatedPhymode *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetNegotiatedPhymode_Closure) + (const RpcRespWifiStaGetNegotiatedPhymode *message, + void *closure_data); +typedef void (*RpcRespWifiApGetStaAid_Closure) + (const RpcRespWifiApGetStaAid *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetRssi_Closure) + (const RpcReqWifiStaGetRssi *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetRssi_Closure) + (const RpcRespWifiStaGetRssi *message, + void *closure_data); +typedef void (*RpcReqWifiStaGetAid_Closure) + (const RpcReqWifiStaGetAid *message, + void *closure_data); +typedef void (*RpcRespWifiStaGetAid_Closure) + (const RpcRespWifiStaGetAid *message, + void *closure_data); +typedef void (*RpcReqWifiSetProtocols_Closure) + (const RpcReqWifiSetProtocols *message, + void *closure_data); +typedef void (*RpcRespWifiSetProtocols_Closure) + (const RpcRespWifiSetProtocols *message, + void *closure_data); +typedef void (*RpcReqWifiGetProtocols_Closure) + (const RpcReqWifiGetProtocols *message, + void *closure_data); +typedef void (*RpcRespWifiGetProtocols_Closure) + (const RpcRespWifiGetProtocols *message, + void *closure_data); +typedef void (*RpcReqWifiSetBandwidths_Closure) + (const RpcReqWifiSetBandwidths *message, + void *closure_data); +typedef void (*RpcRespWifiSetBandwidths_Closure) + (const RpcRespWifiSetBandwidths *message, + void *closure_data); +typedef void (*RpcReqWifiGetBandwidths_Closure) + (const RpcReqWifiGetBandwidths *message, + void *closure_data); +typedef void (*RpcRespWifiGetBandwidths_Closure) + (const RpcRespWifiGetBandwidths *message, + void *closure_data); +typedef void (*RpcReqWifiSetBand_Closure) + (const RpcReqWifiSetBand *message, + void *closure_data); +typedef void (*RpcRespWifiSetBand_Closure) + (const RpcRespWifiSetBand *message, + void *closure_data); +typedef void (*RpcReqWifiGetBand_Closure) + (const RpcReqWifiGetBand *message, + void *closure_data); +typedef void (*RpcRespWifiGetBand_Closure) + (const RpcRespWifiGetBand *message, + void *closure_data); +typedef void (*RpcReqWifiSetBandMode_Closure) + (const RpcReqWifiSetBandMode *message, + void *closure_data); +typedef void (*RpcRespWifiSetBandMode_Closure) + (const RpcRespWifiSetBandMode *message, + void *closure_data); +typedef void (*RpcReqWifiGetBandMode_Closure) + (const RpcReqWifiGetBandMode *message, + void *closure_data); +typedef void (*RpcRespWifiGetBandMode_Closure) + (const RpcRespWifiGetBandMode *message, + void *closure_data); +typedef void (*RpcReqWifiSetInactiveTime_Closure) + (const RpcReqWifiSetInactiveTime *message, + void *closure_data); +typedef void (*RpcRespWifiSetInactiveTime_Closure) + (const RpcRespWifiSetInactiveTime *message, + void *closure_data); +typedef void (*RpcReqWifiGetInactiveTime_Closure) + (const RpcReqWifiGetInactiveTime *message, + void *closure_data); +typedef void (*RpcRespWifiGetInactiveTime_Closure) + (const RpcRespWifiGetInactiveTime *message, + void *closure_data); +typedef void (*RpcReqWifiStaItwtSetup_Closure) + (const RpcReqWifiStaItwtSetup *message, + void *closure_data); +typedef void (*RpcRespWifiStaItwtSetup_Closure) + (const RpcRespWifiStaItwtSetup *message, + void *closure_data); +typedef void (*RpcReqWifiStaItwtTeardown_Closure) + (const RpcReqWifiStaItwtTeardown *message, + void *closure_data); +typedef void (*RpcRespWifiStaItwtTeardown_Closure) + (const RpcRespWifiStaItwtTeardown *message, + void *closure_data); +typedef void (*RpcReqWifiStaItwtSuspend_Closure) + (const RpcReqWifiStaItwtSuspend *message, + void *closure_data); +typedef void (*RpcRespWifiStaItwtSuspend_Closure) + (const RpcRespWifiStaItwtSuspend *message, + void *closure_data); +typedef void (*RpcReqWifiStaItwtGetFlowIdStatus_Closure) + (const RpcReqWifiStaItwtGetFlowIdStatus *message, + void *closure_data); +typedef void (*RpcRespWifiStaItwtGetFlowIdStatus_Closure) + (const RpcRespWifiStaItwtGetFlowIdStatus *message, + void *closure_data); +typedef void (*RpcReqWifiStaItwtSendProbeReq_Closure) + (const RpcReqWifiStaItwtSendProbeReq *message, + void *closure_data); +typedef void (*RpcRespWifiStaItwtSendProbeReq_Closure) + (const RpcRespWifiStaItwtSendProbeReq *message, + void *closure_data); +typedef void (*RpcReqWifiStaItwtSetTargetWakeTimeOffset_Closure) + (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message, + void *closure_data); +typedef void (*RpcRespWifiStaItwtSetTargetWakeTimeOffset_Closure) + (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message, + void *closure_data); +typedef void (*RpcReqWifiStaTwtConfig_Closure) + (const RpcReqWifiStaTwtConfig *message, + void *closure_data); +typedef void (*RpcRespWifiStaTwtConfig_Closure) + (const RpcRespWifiStaTwtConfig *message, + void *closure_data); +typedef void (*RpcReqGetCoprocessorFwVersion_Closure) + (const RpcReqGetCoprocessorFwVersion *message, + void *closure_data); +typedef void (*RpcRespGetCoprocessorFwVersion_Closure) + (const RpcRespGetCoprocessorFwVersion *message, + void *closure_data); +typedef void (*RpcReqSetDhcpDnsStatus_Closure) + (const RpcReqSetDhcpDnsStatus *message, + void *closure_data); +typedef void (*RpcRespSetDhcpDnsStatus_Closure) + (const RpcRespSetDhcpDnsStatus *message, + void *closure_data); +typedef void (*RpcReqGetDhcpDnsStatus_Closure) + (const RpcReqGetDhcpDnsStatus *message, + void *closure_data); +typedef void (*RpcRespGetDhcpDnsStatus_Closure) + (const RpcRespGetDhcpDnsStatus *message, + void *closure_data); +typedef void (*RpcReqSuppDppInit_Closure) + (const RpcReqSuppDppInit *message, + void *closure_data); +typedef void (*RpcRespSuppDppInit_Closure) + (const RpcRespSuppDppInit *message, + void *closure_data); +typedef void (*RpcReqSuppDppDeinit_Closure) + (const RpcReqSuppDppDeinit *message, + void *closure_data); +typedef void (*RpcRespSuppDppDeinit_Closure) + (const RpcRespSuppDppDeinit *message, + void *closure_data); +typedef void (*RpcReqSuppDppBootstrapGen_Closure) + (const RpcReqSuppDppBootstrapGen *message, + void *closure_data); +typedef void (*RpcRespSuppDppBootstrapGen_Closure) + (const RpcRespSuppDppBootstrapGen *message, + void *closure_data); +typedef void (*RpcReqSuppDppStartListen_Closure) + (const RpcReqSuppDppStartListen *message, + void *closure_data); +typedef void (*RpcRespSuppDppStartListen_Closure) + (const RpcRespSuppDppStartListen *message, + void *closure_data); +typedef void (*RpcReqSuppDppStopListen_Closure) + (const RpcReqSuppDppStopListen *message, + void *closure_data); +typedef void (*RpcRespSuppDppStopListen_Closure) + (const RpcRespSuppDppStopListen *message, + void *closure_data); +typedef void (*RpcReqIfaceMacAddrSetGet_Closure) + (const RpcReqIfaceMacAddrSetGet *message, + void *closure_data); +typedef void (*RpcRespIfaceMacAddrSetGet_Closure) + (const RpcRespIfaceMacAddrSetGet *message, + void *closure_data); +typedef void (*RpcReqIfaceMacAddrLenGet_Closure) + (const RpcReqIfaceMacAddrLenGet *message, + void *closure_data); +typedef void (*RpcRespIfaceMacAddrLenGet_Closure) + (const RpcRespIfaceMacAddrLenGet *message, + void *closure_data); +typedef void (*RpcReqFeatureControl_Closure) + (const RpcReqFeatureControl *message, + void *closure_data); +typedef void (*RpcRespFeatureControl_Closure) + (const RpcRespFeatureControl *message, + void *closure_data); +typedef void (*RpcEventWifiEventNoArgs_Closure) + (const RpcEventWifiEventNoArgs *message, + void *closure_data); +typedef void (*RpcEventESPInit_Closure) + (const RpcEventESPInit *message, + void *closure_data); +typedef void (*RpcEventHeartbeat_Closure) + (const RpcEventHeartbeat *message, + void *closure_data); +typedef void (*RpcEventAPStaDisconnected_Closure) + (const RpcEventAPStaDisconnected *message, + void *closure_data); +typedef void (*RpcEventAPStaConnected_Closure) + (const RpcEventAPStaConnected *message, + void *closure_data); +typedef void (*RpcEventStaScanDone_Closure) + (const RpcEventStaScanDone *message, + void *closure_data); +typedef void (*RpcEventStaConnected_Closure) + (const RpcEventStaConnected *message, + void *closure_data); +typedef void (*RpcEventStaDisconnected_Closure) + (const RpcEventStaDisconnected *message, + void *closure_data); +typedef void (*RpcEventDhcpDnsStatus_Closure) + (const RpcEventDhcpDnsStatus *message, + void *closure_data); +typedef void (*RpcEventStaItwtSetup_Closure) + (const RpcEventStaItwtSetup *message, + void *closure_data); +typedef void (*RpcEventStaItwtTeardown_Closure) + (const RpcEventStaItwtTeardown *message, + void *closure_data); +typedef void (*RpcEventStaItwtSuspend_Closure) + (const RpcEventStaItwtSuspend *message, + void *closure_data); +typedef void (*RpcEventStaItwtProbe_Closure) + (const RpcEventStaItwtProbe *message, + void *closure_data); +typedef void (*RpcReqWifiStaEnterpriseEnable_Closure) + (const RpcReqWifiStaEnterpriseEnable *message, + void *closure_data); +typedef void (*RpcRespWifiStaEnterpriseEnable_Closure) + (const RpcRespWifiStaEnterpriseEnable *message, + void *closure_data); +typedef void (*RpcReqWifiStaEnterpriseDisable_Closure) + (const RpcReqWifiStaEnterpriseDisable *message, + void *closure_data); +typedef void (*RpcRespWifiStaEnterpriseDisable_Closure) + (const RpcRespWifiStaEnterpriseDisable *message, + void *closure_data); +typedef void (*RpcReqEapSetIdentity_Closure) + (const RpcReqEapSetIdentity *message, + void *closure_data); +typedef void (*RpcRespEapSetIdentity_Closure) + (const RpcRespEapSetIdentity *message, + void *closure_data); +typedef void (*RpcReqEapClearIdentity_Closure) + (const RpcReqEapClearIdentity *message, + void *closure_data); +typedef void (*RpcRespEapClearIdentity_Closure) + (const RpcRespEapClearIdentity *message, + void *closure_data); +typedef void (*RpcReqEapSetUsername_Closure) + (const RpcReqEapSetUsername *message, + void *closure_data); +typedef void (*RpcRespEapSetUsername_Closure) + (const RpcRespEapSetUsername *message, + void *closure_data); +typedef void (*RpcReqEapClearUsername_Closure) + (const RpcReqEapClearUsername *message, + void *closure_data); +typedef void (*RpcRespEapClearUsername_Closure) + (const RpcRespEapClearUsername *message, + void *closure_data); +typedef void (*RpcReqEapSetPassword_Closure) + (const RpcReqEapSetPassword *message, + void *closure_data); +typedef void (*RpcRespEapSetPassword_Closure) + (const RpcRespEapSetPassword *message, + void *closure_data); +typedef void (*RpcReqEapClearPassword_Closure) + (const RpcReqEapClearPassword *message, + void *closure_data); +typedef void (*RpcRespEapClearPassword_Closure) + (const RpcRespEapClearPassword *message, + void *closure_data); +typedef void (*RpcReqEapSetNewPassword_Closure) + (const RpcReqEapSetNewPassword *message, + void *closure_data); +typedef void (*RpcRespEapSetNewPassword_Closure) + (const RpcRespEapSetNewPassword *message, + void *closure_data); +typedef void (*RpcReqEapClearNewPassword_Closure) + (const RpcReqEapClearNewPassword *message, + void *closure_data); +typedef void (*RpcRespEapClearNewPassword_Closure) + (const RpcRespEapClearNewPassword *message, + void *closure_data); +typedef void (*RpcReqEapSetCaCert_Closure) + (const RpcReqEapSetCaCert *message, + void *closure_data); +typedef void (*RpcRespEapSetCaCert_Closure) + (const RpcRespEapSetCaCert *message, + void *closure_data); +typedef void (*RpcReqEapClearCaCert_Closure) + (const RpcReqEapClearCaCert *message, + void *closure_data); +typedef void (*RpcRespEapClearCaCert_Closure) + (const RpcRespEapClearCaCert *message, + void *closure_data); +typedef void (*RpcReqEapSetCertificateAndKey_Closure) + (const RpcReqEapSetCertificateAndKey *message, + void *closure_data); +typedef void (*RpcRespEapSetCertificateAndKey_Closure) + (const RpcRespEapSetCertificateAndKey *message, + void *closure_data); +typedef void (*RpcReqEapClearCertificateAndKey_Closure) + (const RpcReqEapClearCertificateAndKey *message, + void *closure_data); +typedef void (*RpcRespEapClearCertificateAndKey_Closure) + (const RpcRespEapClearCertificateAndKey *message, + void *closure_data); +typedef void (*RpcReqEapSetDisableTimeCheck_Closure) + (const RpcReqEapSetDisableTimeCheck *message, + void *closure_data); +typedef void (*RpcRespEapSetDisableTimeCheck_Closure) + (const RpcRespEapSetDisableTimeCheck *message, + void *closure_data); +typedef void (*RpcReqEapGetDisableTimeCheck_Closure) + (const RpcReqEapGetDisableTimeCheck *message, + void *closure_data); +typedef void (*RpcRespEapGetDisableTimeCheck_Closure) + (const RpcRespEapGetDisableTimeCheck *message, + void *closure_data); +typedef void (*RpcReqEapSetTtlsPhase2Method_Closure) + (const RpcReqEapSetTtlsPhase2Method *message, + void *closure_data); +typedef void (*RpcRespEapSetTtlsPhase2Method_Closure) + (const RpcRespEapSetTtlsPhase2Method *message, + void *closure_data); +typedef void (*RpcReqEapSetSuiteb192bitCertification_Closure) + (const RpcReqEapSetSuiteb192bitCertification *message, + void *closure_data); +typedef void (*RpcRespEapSetSuiteb192bitCertification_Closure) + (const RpcRespEapSetSuiteb192bitCertification *message, + void *closure_data); +typedef void (*RpcReqEapSetPacFile_Closure) + (const RpcReqEapSetPacFile *message, + void *closure_data); +typedef void (*RpcRespEapSetPacFile_Closure) + (const RpcRespEapSetPacFile *message, + void *closure_data); +typedef void (*RpcReqEapSetFastParams_Closure) + (const RpcReqEapSetFastParams *message, + void *closure_data); +typedef void (*RpcRespEapSetFastParams_Closure) + (const RpcRespEapSetFastParams *message, + void *closure_data); +typedef void (*RpcReqEapUseDefaultCertBundle_Closure) + (const RpcReqEapUseDefaultCertBundle *message, + void *closure_data); +typedef void (*RpcRespEapUseDefaultCertBundle_Closure) + (const RpcRespEapUseDefaultCertBundle *message, + void *closure_data); +typedef void (*RpcReqWifiSetOkcSupport_Closure) + (const RpcReqWifiSetOkcSupport *message, + void *closure_data); +typedef void (*RpcRespWifiSetOkcSupport_Closure) + (const RpcRespWifiSetOkcSupport *message, + void *closure_data); +typedef void (*RpcReqEapSetDomainName_Closure) + (const RpcReqEapSetDomainName *message, + void *closure_data); +typedef void (*RpcRespEapSetDomainName_Closure) + (const RpcRespEapSetDomainName *message, + void *closure_data); +typedef void (*RpcReqEapSetEapMethods_Closure) + (const RpcReqEapSetEapMethods *message, + void *closure_data); +typedef void (*RpcRespEapSetEapMethods_Closure) + (const RpcRespEapSetEapMethods *message, + void *closure_data); +typedef void (*RpcEventSuppDppUriReady_Closure) + (const RpcEventSuppDppUriReady *message, + void *closure_data); +typedef void (*RpcEventSuppDppCfgRecvd_Closure) + (const RpcEventSuppDppCfgRecvd *message, + void *closure_data); +typedef void (*RpcEventSuppDppFail_Closure) + (const RpcEventSuppDppFail *message, + void *closure_data); +typedef void (*RpcEventWifiDppUriReady_Closure) + (const RpcEventWifiDppUriReady *message, + void *closure_data); +typedef void (*RpcEventWifiDppCfgRecvd_Closure) + (const RpcEventWifiDppCfgRecvd *message, + void *closure_data); +typedef void (*RpcEventWifiDppFail_Closure) + (const RpcEventWifiDppFail *message, + void *closure_data); +typedef void (*Rpc_Closure) + (const Rpc *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor rpc__wifi_bw__descriptor; +extern const ProtobufCEnumDescriptor rpc__wifi_power_save__descriptor; +extern const ProtobufCEnumDescriptor rpc__wifi_sec_prot__descriptor; +extern const ProtobufCEnumDescriptor rpc__status__descriptor; +extern const ProtobufCEnumDescriptor rpc_type__descriptor; +extern const ProtobufCEnumDescriptor rpc_feature__descriptor; +extern const ProtobufCEnumDescriptor rpc_feature_command__descriptor; +extern const ProtobufCEnumDescriptor rpc_feature_option__descriptor; +extern const ProtobufCEnumDescriptor rpc_id__descriptor; +extern const ProtobufCMessageDescriptor wifi_init_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_country__descriptor; +extern const ProtobufCMessageDescriptor wifi_active_scan_time__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_time__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_channel_bitmap__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_he_ap_info__descriptor; +extern const ProtobufCMessageDescriptor wifi_ap_record__descriptor; +extern const ProtobufCMessageDescriptor wifi_scan_threshold__descriptor; +extern const ProtobufCMessageDescriptor wifi_pmf_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_bss_max_idle_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_ap_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_sta_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_sta_info__descriptor; +extern const ProtobufCMessageDescriptor wifi_sta_list__descriptor; +extern const ProtobufCMessageDescriptor wifi_pkt_rx_ctrl__descriptor; +extern const ProtobufCMessageDescriptor wifi_promiscuous_pkt__descriptor; +extern const ProtobufCMessageDescriptor wifi_promiscuous_filter__descriptor; +extern const ProtobufCMessageDescriptor wifi_csi_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_csi_info__descriptor; +extern const ProtobufCMessageDescriptor wifi_ant_gpio__descriptor; +extern const ProtobufCMessageDescriptor wifi_ant_gpio_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_ant_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_action_tx_req__descriptor; +extern const ProtobufCMessageDescriptor wifi_ftm_initiator_cfg__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_scan_done__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_connected__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_disconnected__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_authmode_change__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_wps_er_pin__descriptor; +extern const ProtobufCMessageDescriptor ap_cred__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_sta_wps_er_success__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_probe_req_rx__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_bss_rssi_low__descriptor; +extern const ProtobufCMessageDescriptor wifi_ftm_report_entry__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ftm_report__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_action_tx_status__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_roc_done__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_pin__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_fail_reason__descriptor; +extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_success__descriptor; +extern const ProtobufCMessageDescriptor wifi_protocols__descriptor; +extern const ProtobufCMessageDescriptor wifi_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor wifi_itwt_setup_config__descriptor; +extern const ProtobufCMessageDescriptor wifi_twt_config__descriptor; +extern const ProtobufCMessageDescriptor connected_stalist__descriptor; +extern const ProtobufCMessageDescriptor eap_fast_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_ps__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_mac_address__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__otabegin__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__otabegin__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__otawrite__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__otawrite__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__otaend__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__otaend__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_max_tx_power__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__config_heartbeat__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__config_heartbeat__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_init__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_init__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_deinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_deinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_disconnect__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_disconnect__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_start__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_stop__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_num__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_num__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_records__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_records__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_record__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_record__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_clear_ap_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_clear_ap_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_restore__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_restore__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_clear_fast_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_clear_fast_connect__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_deauth_sta__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_deauth_sta__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_ap_info__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_ap_info__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocol__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidth__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_channel__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_storage__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_storage__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_country_code__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_country__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_list__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_negotiated_phymode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_rssi__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_rssi__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_aid__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocols__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidths__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_band__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_band_mode__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_inactive_time__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_inactive_time__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_get_inactive_time__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_inactive_time__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_setup__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_setup__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_teardown__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_teardown__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_suspend__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_suspend__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_send_probe_req__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_send_probe_req__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_twt_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_twt_config__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_coprocessor_fw_version__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_coprocessor_fw_version__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__set_dhcp_dns_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__set_dhcp_dns_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__get_dhcp_dns_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__get_dhcp_dns_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_init__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_init__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_deinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_deinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_bootstrap_gen__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_bootstrap_gen__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_start_listen__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_start_listen__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_stop_listen__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_stop_listen__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__iface_mac_addr_set_get__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__iface_mac_addr_set_get__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__iface_mac_addr_len_get__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__iface_mac_addr_len_get__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__feature_control__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__feature_control__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__wifi_event_no_args__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__espinit__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__heartbeat__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__ap__sta_disconnected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__ap__sta_connected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_scan_done__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_connected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_disconnected__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__dhcp_dns_status__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_setup__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_teardown__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_suspend__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_probe__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_enterprise_enable__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_enterprise_enable__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_enterprise_disable__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_enterprise_disable__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_identity__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_identity__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_clear_identity__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_identity__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_username__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_username__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_clear_username__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_username__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_clear_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_new_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_new_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_clear_new_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_new_password__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_ca_cert__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_ca_cert__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_clear_ca_cert__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_ca_cert__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_certificate_and_key__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_certificate_and_key__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_clear_certificate_and_key__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_certificate_and_key__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_disable_time_check__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_disable_time_check__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_get_disable_time_check__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_get_disable_time_check__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_ttls_phase2_method__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_ttls_phase2_method__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_suiteb192bit_certification__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_suiteb192bit_certification__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_pac_file__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_pac_file__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_fast_params__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_fast_params__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_use_default_cert_bundle__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_use_default_cert_bundle__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__wifi_set_okc_support__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_okc_support__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_domain_name__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_domain_name__descriptor; +extern const ProtobufCMessageDescriptor rpc__req__eap_set_eap_methods__descriptor; +extern const ProtobufCMessageDescriptor rpc__resp__eap_set_eap_methods__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__supp_dpp_uri_ready__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__supp_dpp_cfg_recvd__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__supp_dpp_fail__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__wifi_dpp_uri_ready__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__wifi_dpp_cfg_recvd__descriptor; +extern const ProtobufCMessageDescriptor rpc__event__wifi_dpp_fail__descriptor; +extern const ProtobufCMessageDescriptor rpc__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED */ diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.proto b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.proto new file mode 100644 index 0000000..0c2ec58 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/proto/esp_hosted_rpc.proto @@ -0,0 +1,2157 @@ +/* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD */ +/* SPDX-License-Identifier: Apache-2.0 */ + +syntax = "proto3"; + +enum Rpc_WifiBw { + BW_Invalid = 0; + HT20 = 1; + HT40 = 2; +} + +enum Rpc_WifiPowerSave { + PS_Invalid = 0; + MIN_MODEM = 1; + MAX_MODEM = 2; +} + +enum Rpc_WifiSecProt { + Open = 0; + WEP = 1; + WPA_PSK = 2; + WPA2_PSK = 3; + WPA_WPA2_PSK = 4; + WPA2_ENTERPRISE = 5; + WPA3_PSK = 6; + WPA2_WPA3_PSK = 7; +} + +/* enums for Control path */ +enum Rpc_Status { + Connected = 0; + Not_Connected = 1; + No_AP_Found = 2; + Connection_Fail = 3; + Invalid_Argument = 4; + Out_Of_Range = 5; +} + + +enum RpcType { +MsgType_Invalid = 0; + Req = 1; + Resp = 2; + Event = 3; + MsgType_Max = 4; +} + +enum RpcFeature { + Feature_None = 0; + // Bluetooth (BT) Feature + Feature_Bluetooth = 1; + // add additional features here +} + +enum RpcFeatureCommand { + Feature_Command_None = 0; + // Bluetooth (BT) Feature Commands + Feature_Command_BT_Init = 1; + Feature_Command_BT_Deinit = 2; + Feature_Command_BT_Enable = 3; + Feature_Command_BT_Disable = 4; + // add additional feature commands here +} + +enum RpcFeatureOption { + Feature_Option_None = 0; + // Bluetooth (BT) Feature Options + Feature_Option_BT_Deinit_Release_Memory = 1; // release memory when deinit BT + // add additional feature options here +} + +enum RpcId { + MsgId_Invalid = 0; + + /** Request Msgs **/ + Req_Base = 256; //0x100 + + Req_GetMACAddress = 257; //0x101 + Req_SetMacAddress = 258; //0x102 + Req_GetWifiMode = 259; //0x103 + Req_SetWifiMode = 260; //0x104 + + Req_SuppDppInit = 261; //0x105 + Req_SuppDppDeinit = 262; //0x106 + Req_SuppDppBootstrapGen = 263; //0x107 + Req_SuppDppStartListen = 264; //0x108 + Req_SuppDppStopListen = 265; //0x109 + + //Req_SetSoftAPVendorSpecificIE = 266; //0x10a + //Req_StartSoftAP = 267; //0x10b + //Req_GetSoftAPConnectedSTAList = 268; //0x10c + //Req_StopSoftAP = 269; //0x10d + + Req_WifiSetPs = 270; //0x10e + Req_WifiGetPs = 271; //0x10f + + Req_OTABegin = 272; //0x110 + Req_OTAWrite = 273; //0x111 + Req_OTAEnd = 274; //0x112 + + Req_WifiSetMaxTxPower = 275; //0x113 + Req_WifiGetMaxTxPower = 276; //0x114 + + Req_ConfigHeartbeat = 277; //0x115 + + Req_WifiInit = 278; //0x116 + Req_WifiDeinit = 279; //0x117 + Req_WifiStart = 280; //0x118 + Req_WifiStop = 281; //0x119 + Req_WifiConnect = 282; //0x11a + Req_WifiDisconnect = 283; //0x11b + Req_WifiSetConfig = 284; //0x11c + Req_WifiGetConfig = 285; //0x11d + + Req_WifiScanStart = 286; //0x11e + Req_WifiScanStop = 287; //0x11f + Req_WifiScanGetApNum = 288; //0x120 + Req_WifiScanGetApRecords = 289; //0x121 + Req_WifiClearApList = 290; //0x122 + + Req_WifiRestore = 291; //0x123 + Req_WifiClearFastConnect = 292; //0x124 + Req_WifiDeauthSta = 293; //0x125 + Req_WifiStaGetApInfo = 294; //0x126 + //Req_WifiSetPs = 295; //0x127 + //Req_WifiGetPs = 296; //0x128 + Req_WifiSetProtocol = 297; //0x129 + Req_WifiGetProtocol = 298; //0x12a + Req_WifiSetBandwidth = 299; //0x12b + Req_WifiGetBandwidth = 300; //0x12c + Req_WifiSetChannel = 301; //0x12d + Req_WifiGetChannel = 302; //0x12e + Req_WifiSetCountry = 303; //0x12f + Req_WifiGetCountry = 304; //0x130 + +// Req_WifiSetPromiscuousRxCb = 305; //0x131 + Req_WifiSetPromiscuous = 305; //0x131 + Req_WifiGetPromiscuous = 306; //0x132 + Req_WifiSetPromiscuousFilter = 307; //0x133 + Req_WifiGetPromiscuousFilter = 308; //0x134 + Req_WifiSetPromiscuousCtrlFilter = 309; //0x135 + Req_WifiGetPromiscuousCtrlFilter = 310; //0x136 + + Req_WifiApGetStaList = 311; //0x137 + Req_WifiApGetStaAid = 312; //0x138 + Req_WifiSetStorage = 313; //0x139 + Req_WifiSetVendorIe = 314; //0x13a +// Req_WifiSetVendorIeCb = 315; //0x13b + Req_WifiSetEventMask = 315; //0x13b + Req_WifiGetEventMask = 316; //0x13c + Req_Wifi80211Tx = 317; //0x13d + +// Req_WifiSetCsiRxCb = 318; //0x13e + Req_WifiSetCsiConfig = 318; //0x13e + Req_WifiSetCsi = 319; //0x13f + + Req_WifiSetAntGpio = 320; //0x140 + Req_WifiGetAntGpio = 321; //0x141 + Req_WifiSetAnt = 322; //0x142 + Req_WifiGetAnt = 323; //0x143 + + Req_WifiGetTsfTime = 324; //0x144 + Req_WifiSetInactiveTime = 325; //0x145 + Req_WifiGetInactiveTime = 326; //0x146 + Req_WifiStatisDump = 327; //0x147 + Req_WifiSetRssiThreshold = 328; //0x148 + + Req_WifiFtmInitiateSession = 329; //0x149 + Req_WifiFtmEndSession = 330; //0x14a + Req_WifiFtmRespSetOffset = 331; //0x14b + + Req_WifiConfig11bRate = 332; //0x14c + Req_WifiConnectionlessModuleSetWakeInterval = 333; //0x14d + Req_WifiSetCountryCode = 334; //0x14e + Req_WifiGetCountryCode = 335; //0x14f + Req_WifiConfig80211TxRate = 336; //0x150 + Req_WifiDisablePmfConfig = 337; //0x151 + Req_WifiStaGetAid = 338; //0x152 + Req_WifiStaGetNegotiatedPhymode = 339; //0x153 + Req_WifiSetDynamicCs = 340; //0x154 + Req_WifiStaGetRssi = 341; //0x155 + + Req_WifiSetProtocols = 342; //0x156 + Req_WifiGetProtocols = 343; //0x157 + Req_WifiSetBandwidths = 344; //0x158 + Req_WifiGetBandwidths = 345; //0x159 + + Req_WifiSetBand = 346; //0x15a + Req_WifiGetBand = 347; //0x15b + Req_WifiSetBandMode = 348; //0x15c + Req_WifiGetBandMode = 349; //0x15d + + Req_GetCoprocessorFwVersion = 350; //0x15e + + Req_WifiScanGetApRecord = 351; //0x15f + + Req_SetDhcpDnsStatus = 352; //0x160 + Req_GetDhcpDnsStatus = 353; //0x161 + + Req_WifiStaTwtConfig = 354; //0x162 + Req_WifiStaItwtSetup = 355; //0x163 + Req_WifiStaItwtTeardown = 356; //0x164 + Req_WifiStaItwtSuspend = 357; //0x165 + Req_WifiStaItwtGetFlowIdStatus = 358; //0x166 + Req_WifiStaItwtSendProbeReq = 359; //0x167 + Req_WifiStaItwtSetTargetWakeTimeOffset = 360; //0x168 + + Req_WifiStaEnterpriseEnable = 361; //0x169 + Req_WifiStaEnterpriseDisable = 362; //0x16A + Req_EapSetIdentity = 363; //0x16B + Req_EapClearIdentity = 364; //0x16C + Req_EapSetUsername = 365; //0x16D + Req_EapClearUsername = 366; //0x16E + Req_EapSetPassword = 367; //0x16F + Req_EapClearPassword = 368; //0x170 + Req_EapSetNewPassword = 369; //0x171 + Req_EapClearNewPassword = 370; //0x172 + Req_EapSetCaCert = 371; //0x173 + Req_EapClearCaCert = 372; //0x174 + Req_EapSetCertificateAndKey = 373; //0x175 + Req_EapClearCertificateAndKey = 374; //0x176 + Req_EapGetDisableTimeCheck = 375; //0x177 + Req_EapSetTtlsPhase2Method = 376; //0x178 + Req_EapSetSuitebCertification = 377; //0x179 + Req_EapSetPacFile = 378; //0x17A + Req_EapSetFastParams = 379; //0x17B + Req_EapUseDefaultCertBundle = 380; //0x17C + Req_WifiSetOkcSupport = 381; //0x17D + Req_EapSetDomainName = 382; //0x17E + Req_EapSetDisableTimeCheck = 383; //0x17F + Req_EapSetEapMethods = 384; //0x180 + + Req_IfaceMacAddrSetGet = 385; //0x181 + Req_IfaceMacAddrLenGet = 386; //0x182 + + /* Common RPC to handle simple feature control with one optional parameter + * Supported Features: + * - BT Init/Deinit/Enable/Disable + */ + Req_FeatureControl = 387; //0x183 + + /* Add new control path command response before Req_Max + * and update Req_Max */ + Req_Max = 388; //0x184 + + /** Response Msgs **/ + Resp_Base = 512; + + Resp_GetMACAddress = 513; + Resp_SetMacAddress = 514; + Resp_GetWifiMode = 515; + Resp_SetWifiMode = 516; + + Resp_SuppDppInit = 517; + Resp_SuppDppDeinit = 518; + Resp_SuppDppBootstrapGen = 519; + Resp_SuppDppStartListen = 520; + Resp_SuppDppStopListen = 521; + + //Resp_SetSoftAPVendorSpecificIE = 522; + //Resp_StartSoftAP = 523; + //Resp_GetSoftAPConnectedSTAList = 524; + //Resp_StopSoftAP = 525; + + Resp_WifiSetPs = 526; + Resp_WifiGetPs = 527; + + Resp_OTABegin = 528; + Resp_OTAWrite = 529; + Resp_OTAEnd = 530; + + Resp_WifiSetMaxTxPower = 531; + Resp_WifiGetMaxTxPower = 532; + + Resp_ConfigHeartbeat = 533; + + Resp_WifiInit = 534; + Resp_WifiDeinit = 535; + Resp_WifiStart = 536; + Resp_WifiStop = 537; + Resp_WifiConnect = 538; + Resp_WifiDisconnect = 539; + Resp_WifiSetConfig = 540; + Resp_WifiGetConfig = 541; + + Resp_WifiScanStart = 542; + Resp_WifiScanStop = 543; + Resp_WifiScanGetApNum = 544; + Resp_WifiScanGetApRecords = 545; + Resp_WifiClearApList = 546; + + Resp_WifiRestore = 547; + Resp_WifiClearFastConnect = 548; + Resp_WifiDeauthSta = 549; + Resp_WifiStaGetApInfo = 550; + //Resp_WifiSetPs = 551; + //Resp_WifiGetPs = 552; + Resp_WifiSetProtocol = 553; + Resp_WifiGetProtocol = 554; + Resp_WifiSetBandwidth = 555; + Resp_WifiGetBandwidth = 556; + Resp_WifiSetChannel = 557; + Resp_WifiGetChannel = 558; + Resp_WifiSetCountry = 559; + Resp_WifiGetCountry = 560; + +// Resp_WifiSetPromiscuousRxCb = 561; + Resp_WifiSetPromiscuous = 561; + Resp_WifiGetPromiscuous = 562; + Resp_WifiSetPromiscuousFilter = 563; + Resp_WifiGetPromiscuousFilter = 564; + Resp_WifiSetPromiscuousCtrlFilter = 565; + Resp_WifiGetPromiscuousCtrlFilter = 566; + + Resp_WifiApGetStaList = 567; + Resp_WifiApGetStaAid = 568; + Resp_WifiSetStorage = 569; + Resp_WifiSetVendorIe = 570; +// Resp_WifiSetVendorIeCb = 571; + Resp_WifiSetEventMask = 571; + Resp_WifiGetEventMask = 572; + Resp_Wifi80211Tx = 573; + +// Resp_WifiSetCsiRxCb = 573; + Resp_WifiSetCsiConfig = 574; + Resp_WifiSetCsi = 575; + + Resp_WifiSetAntGpio = 576; + Resp_WifiGetAntGpio = 577; + Resp_WifiSetAnt = 578; + Resp_WifiGetAnt = 579; + + Resp_WifiGetTsfTime = 580; + Resp_WifiSetInactiveTime = 581; + Resp_WifiGetInactiveTime = 582; + Resp_WifiStatisDump = 583; + Resp_WifiSetRssiThreshold = 584; + + Resp_WifiFtmInitiateSession = 585; + Resp_WifiFtmEndSession = 586; + Resp_WifiFtmRespSetOffset = 587; + + Resp_WifiConfig11bRate = 588; + Resp_WifiConnectionlessModuleSetWakeInterval = 589; + Resp_WifiSetCountryCode = 590; + Resp_WifiGetCountryCode = 591; + Resp_WifiConfig80211TxRate = 592; + Resp_WifiDisablePmfConfig = 593; + Resp_WifiStaGetAid = 594; + Resp_WifiStaGetNegotiatedPhymode = 595; + Resp_WifiSetDynamicCs = 596; + Resp_WifiStaGetRssi = 597; + + Resp_WifiSetProtocols = 598; + Resp_WifiGetProtocols = 599; + Resp_WifiSetBandwidths = 600; + Resp_WifiGetBandwidths = 601; + + Resp_WifiSetBand = 602; + Resp_WifiGetBand = 603; + Resp_WifiSetBandMode = 604; + Resp_WifiGetBandMode = 605; + + Resp_GetCoprocessorFwVersion = 606; + + Resp_WifiScanGetApRecord = 607; + + Resp_SetDhcpDnsStatus = 608; + Resp_GetDhcpDnsStatus = 609; + + Resp_WifiStaTwtConfig = 610; + Resp_WifiStaItwtSetup = 611; + Resp_WifiStaItwtTeardown = 612; + Resp_WifiStaItwtSuspend = 613; + Resp_WifiStaItwtGetFlowIdStatus = 614; + Resp_WifiStaItwtSendProbeReq = 615; + Resp_WifiStaItwtSetTargetWakeTimeOffset = 616; + + Resp_WifiStaEnterpriseEnable = 617; + Resp_WifiStaEnterpriseDisable = 618; + Resp_EapSetIdentity = 619; + Resp_EapClearIdentity = 620; + Resp_EapSetUsername = 621; + Resp_EapClearUsername = 622; + Resp_EapSetPassword = 623; + Resp_EapClearPassword = 624; + Resp_EapSetNewPassword = 625; + Resp_EapClearNewPassword = 626; + Resp_EapSetCaCert = 627; + Resp_EapClearCaCert = 628; + Resp_EapSetCertificateAndKey = 629; + Resp_EapClearCertificateAndKey = 630; + Resp_EapGetDisableTimeCheck = 631; + Resp_EapSetTtlsPhase2Method = 632; + Resp_EapSetSuitebCertification = 633; + Resp_EapSetPacFile = 634; + Resp_EapSetFastParams = 635; + Resp_EapUseDefaultCertBundle = 636; + Resp_WifiSetOkcSupport = 637; + Resp_EapSetDomainName = 638; + Resp_EapSetDisableTimeCheck = 639; + Resp_EapSetEapMethods = 640; + + Resp_IfaceMacAddrSetGet = 641; + Resp_IfaceMacAddrLenGet = 642; + Resp_FeatureControl = 643; + + /* Add new control path command response before Resp_Max + * and update Resp_Max */ + Resp_Max = 644; + + /** Event Msgs **/ + Event_Base = 768; + Event_ESPInit = 769; + Event_Heartbeat = 770; + Event_AP_StaConnected = 771; + Event_AP_StaDisconnected = 772; + Event_WifiEventNoArgs = 773; + Event_StaScanDone = 774; + Event_StaConnected = 775; + Event_StaDisconnected = 776; + Event_DhcpDnsStatus = 777; + + Event_StaItwtSetup = 778; + Event_StaItwtTeardown = 779; + Event_StaItwtSuspend = 780; + Event_StaItwtProbe = 781; + + // Supplicant DPP Events received by dpp callback on host + Event_SuppDppUriReady = 782; + Event_SuppDppCfgRecvd = 783; + Event_SuppDppFail = 784; + // Wifi DPP Events + Event_WifiDppUriReady = 785; + Event_WifiDppCfgRecvd = 786; + Event_WifiDppFail = 787; + + /* Add new control path command notification before Event_Max + * and update Event_Max */ + Event_Max = 788; +} + +message wifi_init_config { + int32 static_rx_buf_num = 1; /**< WiFi static RX buffer number */ + int32 dynamic_rx_buf_num = 2; /**< WiFi dynamic RX buffer number */ + int32 tx_buf_type = 3; /**< WiFi TX buffer type */ + int32 static_tx_buf_num = 4; /**< WiFi static TX buffer number */ + int32 dynamic_tx_buf_num = 5; /**< WiFi dynamic TX buffer number */ + int32 cache_tx_buf_num = 6; /**< WiFi TX cache buffer number */ + int32 csi_enable = 7; /**< WiFi channel state information enable flag */ + int32 ampdu_rx_enable = 8; /**< WiFi AMPDU RX feature enable flag */ + int32 ampdu_tx_enable = 9; /**< WiFi AMPDU TX feature enable flag */ + int32 amsdu_tx_enable = 10; /**< WiFi AMSDU TX feature enable flag */ + int32 nvs_enable = 11; /**< WiFi NVS flash enable flag */ + int32 nano_enable = 12; /**< Nano option for printf/scan family enable flag */ + int32 rx_ba_win = 13; /**< WiFi Block Ack RX window size */ + int32 wifi_task_core_id = 14; /**< WiFi Task Core ID */ + int32 beacon_max_len = 15; /**< WiFi softAP maximum length of the beacon */ + int32 mgmt_sbuf_num = 16; /**< WiFi management short buffer number, the minimum value is 6, the maximum value is 32 */ + uint64 feature_caps = 17; /**< Enables additional WiFi features and capabilities */ + bool sta_disconnected_pm = 18; /**< WiFi Power Management for station at disconnected status */ + int32 espnow_max_encrypt_num = 19; /**< Maximum encrypt number of peers supported by espnow */ + int32 magic = 20; /**< WiFi init magic number, it should be the last field */ + int32 rx_mgmt_buf_type = 21; /**< WiFi RX MGMT buffer type */ + int32 rx_mgmt_buf_num = 22; /**< WiFi RX MGMT buffer number */ + int32 tx_hetb_queue_num = 23; /**< WiFi TX HE TB QUEUE number for STA HE TB PPDU transmission */ + int32 dump_hesigb_enable = 24; /**< enable dump sigb field */ +} + +message wifi_country { + bytes cc = 1; /**< country code string of 3 chars*/ + uint32 schan = 2; /**< start channel */ + uint32 nchan = 3; /**< total channel number */ + int32 max_tx_power = 4; /**< This field is used for getting WiFi maximum transmitting power, + call esp_wifi_set_max_tx_power to set the maximum transmitting power. */ + int32 policy = 5; /**< country policy */ +} + + +message wifi_active_scan_time { + uint32 min = 1; /**< minimum active scan time per channel, units: millisecond */ + uint32 max = 2; /**< maximum active scan time per channel, units: millisecond, values above 1500ms may + cause station to disconnect from AP and are not recommended. */ +} ; + +message wifi_scan_time { + wifi_active_scan_time active = 1; /**< active scan time per channel, units: millisecond. */ + uint32 passive = 2; /**< passive scan time per channel, units: millisecond, values above 1500ms may + cause station to disconnect from AP and are not recommended. */ +} + +message wifi_scan_channel_bitmap { + uint32 ghz_2_channels = 1; /**< Represents 2.4 GHz channels, that bits can be set as wifi_2g_channel_bit_t shown. */ + uint32 ghz_5_channels = 2; /**< Represents 5 GHz channels, that bits can be set as wifi_5g_channel_bit_t shown. */ +} + +message wifi_scan_config { + bytes ssid = 1; /**< SSID of AP 33char*/ + bytes bssid = 2; /**< MAC address of AP 6char */ + uint32 channel = 3; /**< channel, scan the specific channel */ + bool show_hidden = 4; /**< enable to scan AP whose SSID is hidden */ + int32 scan_type = 5; /**< scan type, active or passive */ + wifi_scan_time scan_time = 6; /**< scan time per channel */ + uint32 home_chan_dwell_time = 7; /**< time spent at home channel between scanning consecutive channels.*/ + wifi_scan_channel_bitmap channel_bitmap = 8; /**< Channel bitmap for setting specific channels to be scanned. + Please note that the 'channel' parameter above needs to be set to 0 to allow scanning by bitmap. + Also, note that only allowed channels configured by wifi_country_t can be scanned. */ +} + +message wifi_he_ap_info { + //uint8_t bss_color:6; /**< an unsigned integer whose value is the BSS Color of the BSS corresponding to the AP */ + //uint8_t partial_bss_color:1; /**< indicate if an AID assignment rule based on the BSS color */ + //uint8_t bss_color_disabled:1; /**< indicate if the use of BSS color is disabled */ + uint32 bitmask = 1; /* Manually have to parse for above bits */ + uint32 bssid_index = 2; /**< in M-BSSID set, identifies the nontransmitted BSSID */ +} + +message wifi_ap_record { + bytes bssid = 1; /**< MAC address of AP 6char */ + bytes ssid = 2; /**< SSID of AP 33char */ + uint32 primary = 3; /**< channel of AP */ + int32 second = 4; /**< secondary channel of AP */ + int32 rssi = 5; /**< signal strength of AP */ + int32 authmode = 6; /**< authmode of AP */ + int32 pairwise_cipher = 7; /**< pairwise cipher of AP */ + int32 group_cipher = 8; /**< group cipher of AP */ + int32 ant = 9; /**< antenna used to receive beacon from AP */ + //uint32_t phy_11b:1; /**< bit: 0 flag to identify if 11b mode is enabled or not */ + //uint32_t phy_11g:1; /**< bit: 1 flag to identify if 11g mode is enabled or not */ + //uint32_t phy_11n:1; /**< bit: 2 flag to identify if 11n mode is enabled or not */ + //uint32_t phy_lr:1; /**< bit: 3 flag to identify if low rate is enabled or not */ + //uint32_t wps:1; /**< bit: 4 flag to identify if WPS is supported or not */ + //uint32_t ftm_responder:1; /**< bit: 5 flag to identify if FTM is supported in responder mode */ + //uint32_t ftm_initiator:1; /**< bit: 6 flag to identify if FTM is supported in initiator mode */ + //uint32_t reserved:25; /**< bit: 7..31 reserved */ + uint32 bitmask = 10; /* Manually have to parse for above bits */ + + wifi_country country = 11; /**< country information of AP */ + wifi_he_ap_info he_ap = 12; + uint32 bandwidth = 13; /**< For AP 20 MHz this value is set to 1. For AP 40 MHz this value is set to 2. + For AP 80 MHz this value is set to 3. For AP 160MHz this value is set to 4. + For AP 80+80MHz this value is set to 5*/ + uint32 vht_ch_freq1 = 14; /**< This fields are used only AP bandwidth is 80 and 160 MHz, to transmit the center channel + frequency of the BSS. For AP bandwidth is 80 + 80 MHz, it is the center channel frequency + of the lower frequency segment.*/ + uint32 vht_ch_freq2 = 15; /**< This fields are used only AP bandwidth is 80 + 80 MHz, and is used to transmit the center + channel frequency of the second segment. */ +} + +message wifi_scan_threshold { + int32 rssi = 1; /**< The minimum rssi to accept in the fast scan mode */ + int32 authmode = 2; /**< The weakest authmode to accept in the fast scan mode +Note: Incase this value is not set and password is set as per WPA2 standards(password len >= 8), +it will be defaulted to WPA2 and device won't connect to deprecated WEP/WPA networks. +Please set authmode threshold as WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK to connect to WEP/WPA networks */ + uint32 rssi_5g_adjustment = 3; /**< The RSSI value of the 5G AP is within the rssi_5g_adjustment range compared to the 2G AP, the 5G AP will be given priority for connection. */ +} + +message wifi_pmf_config { + bool capable = 1; /**< Deprecated variable. Device will always connect in PMF mode if other device also advertizes PMF capability. */ + bool required = 2; /**< Advertizes that Protected Management Frame is required. Device will not associate to non-PMF capable devices. */ +} + +message wifi_bss_max_idle_config { + uint32 period = 1; /**< Sets BSS Max idle period (1 Unit = 1000TUs OR 1.024 Seconds). If there are no frames for this period from a STA, SoftAP will disassociate due to inactivity. Setting it to 0 disables the feature */ + bool protected_keep_alive = 2; /**< Requires clients to use protected keep alive frames for BSS Max Idle period */ +} + +message wifi_ap_config { + bytes ssid = 1; /**< SSID of ESP32 soft-AP. If ssid_len field is 0, this must be a Null terminated string. Otherwise, length is set according to ssid_len. 32 char*/ + bytes password = 2; /**< Password of ESP32 soft-AP. 64 char*/ + uint32 ssid_len = 3; /**< Optional length of SSID field. */ + uint32 channel = 4; /**< Channel of ESP32 soft-AP */ + int32 authmode = 5; /**< Auth mode of ESP32 soft-AP. Do not support AUTH_WEP in soft-AP mode */ + uint32 ssid_hidden = 6; /**< Broadcast SSID or not, default 0, broadcast the SSID */ + uint32 max_connection = 7; /**< Max number of stations allowed to connect in */ + uint32 beacon_interval = 8; /**< Beacon interval which should be multiples of 100. Unit: TU(time unit, 1 TU = 1024 us). Range: 100 ~ 60000. Default value: 100 */ + int32 pairwise_cipher = 9; /**< pairwise cipher of SoftAP, group cipher will be derived using this. + cipher values are valid starting from WIFI_CIPHER_TYPE_TKIP, enum values before that will be considered as invalid and default cipher suites(TKIP+CCMP) will be used. + Valid cipher suites in softAP mode are WIFI_CIPHER_TYPE_TKIP, WIFI_CIPHER_TYPE_CCMP and WIFI_CIPHER_TYPE_TKIP_CCMP. */ + bool ftm_responder = 10; /**< Enable FTM Responder mode */ + wifi_pmf_config pmf_cfg = 11; /**< Configuration for Protected Management Frame */ + int32 sae_pwe_h2e = 12; /**< Configuration for SAE PWE derivation method */ + uint32 csa_count = 13; /**< Channel Switch Announcement Count. Notify the station that the channel will switch after the csa_count beacon intervals. Default value: 3 */ + uint32 dtim_period = 14; /**< Dtim period of soft-AP. Range: 1 ~ 10. Default value: 1 */ + uint32 transition_disable = 15; /**< Whether to enable transition disable feature */ + uint32 sae_ext = 16; /**< Enable SAE EXT feature. SOC_GCMP_SUPPORT is required for this feature. */ + wifi_bss_max_idle_config bss_max_idle_cfg = 17; /**< Configuration for bss max idle, effective if CONFIG_WIFI_BSS_MAX_IDLE_SUPPORT is enabled */ + uint32 gtk_rekey_interval = 18; /**< GTK rekeying interval in seconds. If set to 0, GTK rekeying is disabled. Range: 60 ~ 65535 including 0. */ +} + +message wifi_sta_config { + bytes ssid = 1; /**< SSID of target AP. 32char */ + bytes password = 2; /**< Password of target AP. 64char */ + int32 scan_method = 3; /**< do all channel scan or fast scan */ + bool bssid_set = 4; /**< whether set MAC address of target AP or not. Generally, station_config.bssid_set needs to be 0, + and it needs to be 1 only when users need to check the MAC address of the AP.*/ + bytes bssid = 5; /**< MAC address of target AP 6char */ + uint32 channel = 6; /**< channel of target AP. Set to 1~13 to scan starting from the specified channel + before connecting to AP. If the channel of AP is unknown, set it to 0.*/ + uint32 listen_interval = 7; /**< Listen interval for ESP32 station to receive beacon when WIFI_PS_MAX_MODEM is set. +Units: AP beacon intervals. Defaults to 3 if set to 0. */ + int32 sort_method = 8; /**< sort the connect AP in the list by rssi or security mode */ + wifi_scan_threshold threshold = 9; /**< When sort_method is set, only APs which have an auth mode that is more secure + than the selected auth mode and a signal stronger than the minimum RSSI will be used. */ + wifi_pmf_config pmf_cfg = 10; /**< Configuration for Protected Management Frame. Will be advertized in RSN Capabilities in RSN IE. */ + //uint32_t rm_enabled:1; /**< Whether Radio Measurements are enabled for the connection */ + //uint32_t btm_enabled:1; /**< Whether BSS Transition Management is enabled for the connection */ + //uint32_t mbo_enabled:1; /**< Whether MBO is enabled for the connection */ + //uint32_t ft_enabled:1; /**< Whether FT is enabled for the connection */ + //uint32_t owe_enabled:1; /**< Whether OWE is enabled for the connection */ + //uint32_t transition_disable:1; /**< Whether to enable transition disable feature */ + //uint32_t reserved:26; /**< Reserved for future feature set */ + uint32 bitmask = 11; + int32 sae_pwe_h2e = 12; /**< Whether SAE hash to element is enabled */ + uint32 failure_retry_cnt = 13; /**< Number of connection retries station will do before moving to next AP. + scan_method should be set as WIFI_ALL_CHANNEL_SCAN to use this config. + Note: Enabling this may cause connection time to increase incase best AP doesn't behave properly. */ + //uint32_t he_dcm_set:1; /**< Whether DCM max.constellation for transmission and reception is set. */ + //uint32_t he_dcm_max_constellation_tx:2; /**< Indicate the max.constellation for DCM in TB PPDU the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. */ + //uint32_t he_dcm_max_constellation_rx:2; /**< Indicate the max.constellation for DCM in both Data field and HE-SIG-B field the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. */ + //uint32_t he_mcs9_enabled:1; /**< Whether to support HE-MCS 0 to 9. The default value is 0. */ + //uint32_t he_su_beamformee_disabled:1; /**< Whether to disable support for operation as an SU beamformee. */ + //uint32_t he_trig_su_bmforming_feedback_disabled:1; /**< Whether to disable support the transmission of SU feedback in an HE TB sounding sequence. */ + //uint32_t he_trig_mu_bmforming_partial_feedback_disabled:1; /**< Whether to disable support the transmission of partial-bandwidth MU feedback in an HE TB sounding sequence. */ + // uint32_t he_trig_cqi_feedback_disabled:1; /**< Whether to disable support the transmission of CQI feedback in an HE TB sounding sequence. */ + // uint32_t vht_su_beamformee_disabled: 1; /**< Whether to disable support for operation as an VHT SU beamformee. */ + // uint32_t vht_mu_beamformee_disabled: 1; /**< Whether to disable support for operation as an VHT MU beamformee. */ + // uint32_t vht_mcs8_enabled: 1; /**< Whether to support VHT-MCS8. The default value is 0. */ + // uint32_t he_reserved:19; /**< Reserved for future feature set */ + uint32 he_bitmask = 14; + bytes sae_h2e_identifier = 15; /**< Password identifier for H2E. this needs to be null terminated string. SAE_H2E_IDENTIFIER_LEN chars */ + uint32 sae_pk_mode = 16; /**< Configuration for SAE-PK (Public Key) Authentication method */ +} + +message wifi_config { + oneof u { + wifi_ap_config ap = 1; /**< configuration of AP */ + wifi_sta_config sta = 2; /**< configuration of STA */ + } +} + +message wifi_sta_info { + bytes mac = 1; /**< mac address 6 char */ + int32 rssi = 2; /**< current average rssi of sta connected */ + //uint32_t phy_11b:1; /**< bit: 0 flag to identify if 11b mode is enabled or not */ + //uint32_t phy_11g:1; /**< bit: 1 flag to identify if 11g mode is enabled or not */ + //uint32_t phy_11n:1; /**< bit: 2 flag to identify if 11n mode is enabled or not */ + //uint32_t phy_lr:1; /**< bit: 3 flag to identify if low rate is enabled or not */ + //uint32_t phy_11x:1; /**< bit: 4 flag to identify identify if 11ax mode is enabled or not */ + //uint32_t is_mesh_child:1; /**< bit: 5 flag to identify mesh child */ + //uint32_t reserved:26; /**< bit: 6..31 reserved */ + uint32 bitmask = 3; +} + +message wifi_sta_list { + repeated wifi_sta_info sta = 1; /**< station list */ + int32 num = 2; /**< number of stations in the list (other entries are invalid) */ +} + +//message vendor_ie_data { +// uint32 element_id = 1; /**< Should be set to WIFI_VENDOR_IE_ELEMENT_ID (0xDD) */ +// uint32 length = 2; /**< Length of all bytes in the element data following this field. Minimum 4. */ +// bytes vendor_oui = 3; /**< Vendor identifier (OUI). 3 chars */ +// uint32 vendor_oui_type = 4; /**< Vendor-specific OUI type. */ +// bytes payload = 5; /**< Payload. Length is equal to value in 'length' field, minus 4. Note: Variable size */ +//} + +message wifi_pkt_rx_ctrl { + int32 rssi = 1; /**< 8bits Received Signal Strength Indicator(RSSI) of packet. unit: dBm */ + uint32 rate = 2; /**< 5bits PHY rate encoding of the packet. Only valid for non HT(11bg) packet */ + //uint32 :1; /**< reserved */ + uint32 sig_mode = 3; /**< 2bits 0: non HT(11bg) packet; 1: HT(11n) packet; 3: VHT(11ac) packet */ + //uint32 :16; /**< reserved */ + uint32 mcs = 4; /**< 7bits Modulation Coding Scheme. If is HT(11n) packet, shows the modulation, range from 0 to 76(MSC0 ~ MCS76) */ + uint32 cwb = 5; /**< 1bit Channel Bandwidth of the packet. 0: 20MHz; 1: 40MHz */ + //uint32 :16; /**< reserved */ + uint32 smoothing = 6; /**< 1bit reserved */ + uint32 not_sounding = 7; /**< 1bit reserved */ + //uint32 :1; /**< reserved */ + uint32 aggregation = 8; /**< 1bit Aggregation. 0: MPDU packet; 1: AMPDU packet */ + uint32 stbc = 9; /**< 2bits Space Time Block Code(STBC). 0: non STBC packet; 1: STBC packet */ + uint32 fec_coding = 10; /**< 1bit Flag is set for 11n packets which are LDPC */ + uint32 sgi = 11; /**< 1bit Short Guide Interval(SGI). 0: Long GI; 1: Short GI */ + int32 noise_floor = 12; /**< 8bits noise floor of Radio Frequency Module(RF). unit: dBm*/ + uint32 ampdu_cnt = 13; /**< 8bits ampdu cnt */ + uint32 channel = 14; /**< 4bits primary channel on which this packet is received */ + uint32 secondary_channel = 15; /**< 4bits secondary channel on which this packet is received. 0: none; 1: above; 2: below */ + //uint32 :8; /**< reserved */ + uint32 timestamp = 16; /**< 32bit timestamp. The local time when this packet is received. It is precise only if modem sleep or light sleep is not enabled. unit: microsecond */ + //uint32 :32; /**< reserved */ + //unsigned :32; /**< reserved */ + //unsigned :31; /**< reserved */ + uint32 ant = 17; /**< 1bit antenna number from which this packet is received. 0: WiFi antenna 0; 1: WiFi antenna 1 */ + uint32 sig_len = 18; /**< 12bits length of packet including Frame Check Sequence(FCS) */ + //unsigned :12; /**< reserved */ + uint32 rx_state = 19; /**< 8bits state of the packet. 0: no error; others: error numbers which are not public */ +} + +message wifi_promiscuous_pkt { + wifi_pkt_rx_ctrl rx_ctrl = 1; /**< metadata header */ + bytes payload = 2; /**< Note: variable length. Data or management payload. Length of payload is described by rx_ctrl.sig_len. Type of content determined by packet type argument of callback. */ +} + +message wifi_promiscuous_filter { + uint32 filter_mask = 1; /**< OR of one or more filter values WIFI_PROMIS_FILTER_* */ +} + +message wifi_csi_config { + bool lltf_en = 1; /**< enable to receive legacy long training field(lltf) data. Default enabled */ + bool htltf_en = 2; /**< enable to receive HT long training field(htltf) data. Default enabled */ + bool stbc_htltf2_en = 3; /**< enable to receive space time block code HT long training field(stbc-htltf2) data. Default enabled */ + bool ltf_merge_en = 4; /**< enable to generate htlft data by averaging lltf and ht_ltf data when receiving HT packet. Otherwise, use ht_ltf data directly. Default enabled */ + bool channel_filter_en = 5; /**< enable to turn on channel filter to smooth adjacent sub-carrier. Disable it to keep independence of adjacent sub-carrier. Default enabled */ + bool manu_scale = 6; /**< manually scale the CSI data by left shifting or automatically scale the CSI data. + If set true, please set the shift bits. false: automatically. true: manually. Default false */ + uint32 shift = 7; /**< manually left shift bits of the scale of the CSI data. The range of the left shift bits is 0~15 */ +} + +message wifi_csi_info { + wifi_pkt_rx_ctrl rx_ctrl = 1; /**< received packet radio metadata header of the CSI data */ + bytes mac = 2; /**< 6bits source MAC address of the CSI data */ + bytes dmac = 3; /**< 6bits destination MAC address of the CSI data */ + bool first_word_invalid = 4; /**< first four bytes of the CSI data is invalid or not */ + bytes buf = 5; /**< Note: variable length. buffer of CSI data */ + uint32 len = 6; /**< length of CSI data */ +} + +message wifi_ant_gpio { + uint32 gpio_select = 1; /**< 1bit Whether this GPIO is connected to external antenna switch */ + uint32 gpio_num = 2; /**< 7bits The GPIO number that connects to external antenna switch */ +} + +message wifi_ant_gpio_config { + repeated wifi_ant_gpio gpio_cfgs = 1; /**< The configurations of GPIOs that connect to external antenna switch */ +} + +message wifi_ant_config { + int32 rx_ant_mode = 1; /**< WiFi antenna mode for receiving */ + int32 rx_ant_default = 2; /**< Default antenna mode for receiving, it's ignored if rx_ant_mode is not WIFI_ANT_MODE_AUTO */ + int32 tx_ant_mode = 3; /**< WiFi antenna mode for transmission, it can be set to WIFI_ANT_MODE_AUTO only if rx_ant_mode is set to WIFI_ANT_MODE_AUTO */ + uint32 enabled_ant0 = 4; /**< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT0 */ + uint32 enabled_ant1 = 5; /**< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT1 */ +} + +message wifi_action_tx_req { + int32 ifx = 1; /**< WiFi interface to send request to */ + bytes dest_mac = 2; /**< 6bits Destination MAC address */ + bool no_ack = 3; /**< Indicates no ack required */ + //TODO + //wifi_action_rx_cb_t rx_cb; /**< Rx Callback to receive any response */ + uint32 data_len = 4; /**< Length of the appended Data */ + bytes data = 5; /**< note: variable length. Appended Data payload */ +} + +message wifi_ftm_initiator_cfg { + bytes resp_mac = 1; /**< 6bits MAC address of the FTM Responder */ + uint32 channel = 2; /**< Primary channel of the FTM Responder */ + uint32 frm_count = 3; /**< No. of FTM frames requested in terms of 4 or 8 bursts (allowed values - 0(No pref), 16, 24, 32, 64) */ + uint32 burst_period = 4; /**< Requested time period between consecutive FTM bursts in 100's of milliseconds (0 - No pref) */ +} + +message wifi_event_sta_scan_done { + uint32 status = 1; /**< status of scanning APs: 0 — success, 1 - failure */ + uint32 number = 2; /**< number of scan results */ + uint32 scan_id = 3; /**< scan sequence number, used for block scan */ +} + +message wifi_event_sta_connected { + bytes ssid = 1; /**< 32bytes SSID of connected AP */ + uint32 ssid_len = 2; /**< SSID length of connected AP */ + bytes bssid = 3; /**< 6bytes BSSID of connected AP*/ + uint32 channel = 4; /**< channel of connected AP*/ + int32 authmode = 5; /**< authentication mode used by AP*/ + int32 aid = 6; /**< authentication id assigned by the connected AP*/ +} + +message wifi_event_sta_disconnected { + bytes ssid = 1; /**< SSID of disconnected AP */ + uint32 ssid_len = 2; /**< SSID length of disconnected AP */ + bytes bssid = 3; /**< BSSID of disconnected AP */ + uint32 reason = 4; /**< reason of disconnection */ + int32 rssi = 5; /**< rssi of disconnection */ +} + +message wifi_event_sta_authmode_change { + int32 old_mode = 1; /**< the old auth mode of AP */ + int32 new_mode = 2; /**< the new auth mode of AP */ +} + +message wifi_event_sta_wps_er_pin { + bytes pin_code = 1; /**< 8bytes PIN code of station in enrollee mode */ +} + +message ap_cred { + bytes ssid = 1; /**< 32bytes SSID of AP */ + bytes passphrase = 2; /**< 64bytes Passphrase for the AP */ +} + +message wifi_event_sta_wps_er_success { + uint32 ap_cred_cnt = 1; /**< Number of AP credentials received */ + repeated ap_cred ap_creds = 2; /**< All AP credentials received from WPS handshake */ +} + +/** Argument structure for WIFI_EVENT_AP_PROBEREQRECVED event */ +message wifi_event_ap_probe_req_rx { + int32 rssi = 1; /**< Received probe request signal strength */ + uint32 mac = 2; /**< MAC address of the station which send probe request */ +} + +/** Argument structure for WIFI_EVENT_STA_BSS_RSSI_LOW event */ +message wifi_event_bss_rssi_low { + int32 rssi = 1; /**< RSSI value of bss */ +} + +message wifi_ftm_report_entry { + uint32 dlog_token = 1; /* *< Dialog Token of the FTM frame */ + int32 rssi = 2; /* *< RSSI of the FTM frame received */ + uint32 rtt = 3; /* *< Round Trip Time in pSec with a peer */ + /* TODO: uint32 is supported by proto? */ + uint64 t1 = 4; /* *< Time of departure of FTM frame from FTM Responder in pSec */ + uint64 t2 = 5; /* *< Time of arrival of FTM frame at FTM Initiator in pSec */ + uint64 t3 = 6; /* *< Time of departure of ACK from FTM Initiator in pSec */ + uint64 t4 = 7; /* *< Time of arrival of ACK at FTM Responder in pSec */ +} + +message wifi_event_ftm_report { + bytes peer_mac = 1; /* *< 6bytes MAC address of the FTM Peer */ + int32 status = 2; /* *< Status of the FTM operation */ + uint32 rtt_raw = 3; /* *< Raw average Round-Trip-Time with peer in Nano-Seconds */ + uint32 rtt_est = 4; /* *< Estimated Round-Trip-Time with peer in Nano-Seconds */ + uint32 dist_est = 5; /* *< Estimated one-way distance in Centi-Meters */ + repeated wifi_ftm_report_entry ftm_report_data = 6; /* *< Note var len Pointer to FTM Report with multiple entries, should be freed after use */ + uint32 ftm_report_num_entries = 7; /* *< Number of entries in the FTM Report data */ +} + +message wifi_event_action_tx_status { + int32 ifx = 1; /**< WiFi interface to send request to */ + uint32 context = 2; /**< Context to identify the request */ + bytes da = 3; /**< 6bytes Destination MAC address */ + uint32 status = 4; /**< Status of the operation */ +} + +message wifi_event_roc_done { + uint32 context = 1; /**< Context to identify the request */ +} + +message wifi_event_ap_wps_rg_pin { + bytes pin_code = 1; /**< 8bytes PIN code of station in enrollee mode */ +} + +message wifi_event_ap_wps_rg_fail_reason { + int32 reason = 1; /**< WPS failure reason wps_fail_reason_t */ + bytes peer_macaddr = 2; /**< 6bytes Enrollee mac address */ +} + +message wifi_event_ap_wps_rg_success { + bytes peer_macaddr = 1; /**< 6bytes Enrollee mac address */ +} + +message wifi_protocols { + uint32 ghz_2g = 1; /**< Represents 2.4 GHz protocol, support 802.11b or 802.11g or 802.11n or 802.11ax or LR mode */ + uint32 ghz_5g = 2; /**< Represents 5 GHz protocol, support 802.11a or 802.11n or 802.11ac or 802.11ax */ +} + +message wifi_bandwidths { + uint32 ghz_2g = 1; /* Represents 2.4 GHz bandwidth */ + uint32 ghz_5g = 2; /* Represents 5 GHz bandwidth */ +} + +message wifi_itwt_setup_config { + uint32 setup_cmd = 1; + // uint16_t trigger : 1; /**< 1: a trigger-enabled individual TWT, 0: a non-trigger-enabled individual TWT */ + // uint16_t flow_type : 1; /**< 0: an announced individual TWT, 1: an unannounced individual TWT */ + // uint16_t flow_id : 3; /**< When set up an individual TWT agreement, the flow id will be assigned by AP after a successful agreement setup. + // flow_id could be specified to a value in the range of [0, 7], but it might be changed by AP in the response. + // When change TWT parameters of the existing TWT agreement, flow_id should be an existing one. The value range is [0, 7]. */ + // uint16_t wake_invl_expn : 5; /**< Individual TWT Wake Interval Exponent. The value range is [0, 31]. */ + // uint16_t wake_duration_unit : 1; /**< Individual TWT Wake duration unit, 0: 256us 1: TU (TU = 1024us)*/ + // uint16_t reserved : 5; /**< bit: 11.15 reserved */ + uint32 bitmask_1 = 2; + uint32 min_wake_dura = 3; + uint32 wake_invl_mant = 4; + uint32 twt_id = 5; + uint32 timeout_time_ms = 6; +} + +message wifi_twt_config { + bool post_wakeup_event = 1; /**< post twt wakeup event */ + bool twt_enable_keep_alive = 2; /**< twt enable send qos null to keep alive */ +} + +/* internal supporting structures for Rpc */ +//message ScanResult { +// bytes bssid = 1; +// bytes ssid = 2; +// uint32 chnl = 3; +// int32 rssi = 4; +// int32 sec_prot = 5; +//} + +message ConnectedSTAList { + bytes mac = 1; + int32 rssi = 2; +} + +message eap_fast_config { + int32 fast_provisioning = 1; // Enable or disable Fast Provisioning in EAP-FAST (0 = disabled, 1 = enabled) + int32 fast_max_pac_list_len = 2; // Maximum length of the PAC (Protected Access Credential) list + bool fast_pac_format_binary = 3; // Set to true for binary format PAC, false for ASCII format PAC +} + +/* Control path structures */ +/** Req/Resp structure **/ +message Rpc_Req_GetMacAddress { + int32 mode = 1; +} + +message Rpc_Resp_GetMacAddress { + bytes mac = 1; + int32 resp = 2; +} + +message Rpc_Req_GetMode { +} + +message Rpc_Resp_GetMode { + int32 mode = 1; + int32 resp = 2; +} + +message Rpc_Req_SetMode { + int32 mode = 1; +} + +message Rpc_Resp_SetMode { + int32 resp = 1; +} + +message Rpc_Req_GetPs { +} + +message Rpc_Resp_GetPs { + int32 resp = 1; + int32 type = 2; +} + +message Rpc_Req_SetPs { + int32 type = 1; +} + +message Rpc_Resp_SetPs { + int32 resp = 1; +} + +message Rpc_Req_SetMacAddress { + bytes mac = 1; + int32 mode = 2; +} + +message Rpc_Resp_SetMacAddress { + int32 resp = 1; +} + +message Rpc_Req_OTABegin { +} + +message Rpc_Resp_OTABegin { + int32 resp = 1; +} + +message Rpc_Req_OTAWrite { + bytes ota_data = 1; +} + +message Rpc_Resp_OTAWrite { + int32 resp = 1; +} + +message Rpc_Req_OTAEnd { +} + +message Rpc_Resp_OTAEnd { + int32 resp = 1; +} + +message Rpc_Req_WifiSetMaxTxPower { + int32 power = 1; +} + +message Rpc_Resp_WifiSetMaxTxPower { + int32 resp = 1; +} + +message Rpc_Req_WifiGetMaxTxPower { +} + +message Rpc_Resp_WifiGetMaxTxPower { + int32 power = 1; + int32 resp = 2; +} + +message Rpc_Req_ConfigHeartbeat { + bool enable = 1; + int32 duration = 2; +} + +message Rpc_Resp_ConfigHeartbeat { + int32 resp = 1; +} + +message Rpc_Req_WifiInit { + wifi_init_config cfg = 1; +} + +message Rpc_Resp_WifiInit { + int32 resp = 1; +} + +message Rpc_Req_WifiDeinit { +} + +message Rpc_Resp_WifiDeinit { + int32 resp = 1; +} + +message Rpc_Req_WifiSetConfig { + int32 iface = 1; + wifi_config cfg = 2; +} + +message Rpc_Resp_WifiSetConfig { + int32 resp = 1; +} + +message Rpc_Req_WifiGetConfig { + int32 iface = 1; +} + +message Rpc_Resp_WifiGetConfig { + int32 resp = 1; + int32 iface = 2; + wifi_config cfg = 3; +} + +message Rpc_Req_WifiConnect { +} + +message Rpc_Resp_WifiConnect { + int32 resp = 1; +} + +message Rpc_Req_WifiDisconnect { +} + +message Rpc_Resp_WifiDisconnect { + int32 resp = 1; +} + +message Rpc_Req_WifiStart { +} + +message Rpc_Resp_WifiStart { + int32 resp = 1; +} + +message Rpc_Req_WifiStop { +} + +message Rpc_Resp_WifiStop { + int32 resp = 1; +} + +message Rpc_Req_WifiScanStart { + wifi_scan_config config = 1; + bool block = 2; + int32 config_set = 3; +} + +message Rpc_Resp_WifiScanStart { + int32 resp = 1; +} + +message Rpc_Req_WifiScanStop { +} + +message Rpc_Resp_WifiScanStop { + int32 resp = 1; +} + +message Rpc_Req_WifiScanGetApNum { +} + +message Rpc_Resp_WifiScanGetApNum { + int32 resp = 1; + int32 number = 2; +} + +message Rpc_Req_WifiScanGetApRecords { + int32 number = 1; +} + +message Rpc_Resp_WifiScanGetApRecords { + int32 resp = 1; + int32 number = 2; + repeated wifi_ap_record ap_records = 3; +} + +message Rpc_Req_WifiScanGetApRecord { +} + +message Rpc_Resp_WifiScanGetApRecord { + int32 resp = 1; + wifi_ap_record ap_record = 2; +} + +message Rpc_Req_WifiClearApList { +} + +message Rpc_Resp_WifiClearApList { + int32 resp = 1; +} + +message Rpc_Req_WifiRestore { +} + +message Rpc_Resp_WifiRestore { + int32 resp = 1; +} + +message Rpc_Req_WifiClearFastConnect{ +} + +message Rpc_Resp_WifiClearFastConnect { + int32 resp = 1; +} + +message Rpc_Req_WifiDeauthSta { + int32 aid = 1; +} + +message Rpc_Resp_WifiDeauthSta { + int32 resp = 1; + int32 aid = 2; +} + +message Rpc_Req_WifiStaGetApInfo { +} + +message Rpc_Resp_WifiStaGetApInfo { + int32 resp = 1; + wifi_ap_record ap_record = 2; +} + +message Rpc_Req_WifiSetProtocol { + int32 ifx = 1; + int32 protocol_bitmap = 2; +} + +message Rpc_Resp_WifiSetProtocol { + int32 resp = 1; +} + +message Rpc_Req_WifiGetProtocol { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetProtocol { + int32 resp = 1; + int32 protocol_bitmap = 2; +} + +message Rpc_Req_WifiSetBandwidth { + int32 ifx = 1; + int32 bw = 2; +} + +message Rpc_Resp_WifiSetBandwidth { + int32 resp = 1; +} + +message Rpc_Req_WifiGetBandwidth { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetBandwidth { + int32 resp = 1; + int32 bw = 2; +} + +message Rpc_Req_WifiSetChannel { + int32 primary = 1; + int32 second = 2; +} + +message Rpc_Resp_WifiSetChannel { + int32 resp = 1; +} + +message Rpc_Req_WifiGetChannel { +} + +message Rpc_Resp_WifiGetChannel { + int32 resp = 1; + int32 primary = 2; + int32 second = 3; +} + +message Rpc_Req_WifiSetStorage { + int32 storage = 1; +} + +message Rpc_Resp_WifiSetStorage { + int32 resp = 1; +} + +message Rpc_Req_WifiSetCountryCode { + bytes country = 1; + bool ieee80211d_enabled = 2; +} + +message Rpc_Resp_WifiSetCountryCode { + int32 resp = 1; +} + +message Rpc_Req_WifiGetCountryCode { +} + +message Rpc_Resp_WifiGetCountryCode { + int32 resp = 1; + bytes country = 2; +} + +message Rpc_Req_WifiSetCountry { + wifi_country country = 1; +} + +message Rpc_Resp_WifiSetCountry { + int32 resp = 1; +} + +message Rpc_Req_WifiGetCountry { +} + +message Rpc_Resp_WifiGetCountry { + int32 resp = 1; + wifi_country country = 2; +} + +message Rpc_Req_WifiApGetStaList { +} + +message Rpc_Resp_WifiApGetStaList { + int32 resp = 1; + wifi_sta_list sta_list = 2; +} + +message Rpc_Req_WifiApGetStaAid { + bytes mac = 1; +} + +message Rpc_Req_WifiStaGetNegotiatedPhymode { +} + +message Rpc_Resp_WifiStaGetNegotiatedPhymode { + int32 resp = 1; + uint32 phymode = 2; +} + +message Rpc_Resp_WifiApGetStaAid { + int32 resp = 1; + uint32 aid = 2; +} + +message Rpc_Req_WifiStaGetRssi { +} + +message Rpc_Resp_WifiStaGetRssi { + int32 resp = 1; + int32 rssi = 2; +} + +message Rpc_Req_WifiStaGetAid { +} + +message Rpc_Resp_WifiStaGetAid { + int32 resp = 1; + uint32 aid = 2; +} + +message Rpc_Req_WifiSetProtocols { + int32 ifx = 1; + wifi_protocols protocols = 2; +} + +message Rpc_Resp_WifiSetProtocols { + int32 resp = 1; + uint32 ifx = 2; +} + +message Rpc_Req_WifiGetProtocols { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetProtocols { + int32 resp = 1; + int32 ifx = 2; + wifi_protocols protocols = 3; +} + +message Rpc_Req_WifiSetBandwidths { + int32 ifx = 1; + wifi_bandwidths bandwidths = 2; +} + +message Rpc_Resp_WifiSetBandwidths { + int32 resp = 1; + int32 ifx = 2; +} + +message Rpc_Req_WifiGetBandwidths { + int32 ifx = 1; +} + +message Rpc_Resp_WifiGetBandwidths { + int32 resp = 1; + int32 ifx = 2; + wifi_bandwidths bandwidths = 3; +} + +message Rpc_Req_WifiSetBand { + uint32 band = 1; +} + +message Rpc_Resp_WifiSetBand { + int32 resp = 1; +} + +message Rpc_Req_WifiGetBand { +} + +message Rpc_Resp_WifiGetBand { + int32 resp = 1; + uint32 band = 2; +} + +message Rpc_Req_WifiSetBandMode { + uint32 bandmode = 1; +} + +message Rpc_Resp_WifiSetBandMode { + int32 resp = 1; +} + +message Rpc_Req_WifiGetBandMode { +} + +message Rpc_Resp_WifiGetBandMode { + int32 resp = 1; + uint32 bandmode = 2; +} + +message Rpc_Req_WifiSetInactiveTime { + uint32 ifx = 1; + uint32 sec = 2; +} + +message Rpc_Resp_WifiSetInactiveTime { + int32 resp = 1; +} + +message Rpc_Req_WifiGetInactiveTime { + uint32 ifx = 1; +} + +message Rpc_Resp_WifiGetInactiveTime { + int32 resp = 1; + uint32 sec = 2; +} + +message Rpc_Req_WifiStaItwtSetup { + wifi_itwt_setup_config setup_config = 1; +} + +message Rpc_Resp_WifiStaItwtSetup { + int32 resp = 1; +} + +message Rpc_Req_WifiStaItwtTeardown { + int32 flow_id = 1; +} + +message Rpc_Resp_WifiStaItwtTeardown { + int32 resp = 1; +} + +message Rpc_Req_WifiStaItwtSuspend { + int32 flow_id = 1; + int32 suspend_time_ms = 2; +} + +message Rpc_Resp_WifiStaItwtSuspend { + int32 resp = 1; +} + +message Rpc_Req_WifiStaItwtGetFlowIdStatus { +} + +message Rpc_Resp_WifiStaItwtGetFlowIdStatus { + int32 resp = 1; + int32 flow_id_bitmap = 2; +} + +message Rpc_Req_WifiStaItwtSendProbeReq { + int32 timeout_ms = 1; +} + +message Rpc_Resp_WifiStaItwtSendProbeReq { + int32 resp = 1; +} + +message Rpc_Req_WifiStaItwtSetTargetWakeTimeOffset { + int32 offset_us = 1; +} + +message Rpc_Resp_WifiStaItwtSetTargetWakeTimeOffset { + int32 resp = 1; +} + +message Rpc_Req_WifiStaTwtConfig { + wifi_twt_config config = 1; +} + +message Rpc_Resp_WifiStaTwtConfig { + int32 resp = 1; +} + +message Rpc_Req_GetCoprocessorFwVersion { +} + +message Rpc_Resp_GetCoprocessorFwVersion { + int32 resp = 1; + uint32 major1 = 2; + uint32 minor1 = 3; + uint32 patch1 = 4; +} + +message Rpc_Req_SetDhcpDnsStatus { + int32 iface = 1; + int32 net_link_up = 2; + + int32 dhcp_up = 3; + bytes dhcp_ip = 4; + bytes dhcp_nm = 5; + bytes dhcp_gw = 6; + + int32 dns_up = 7; + bytes dns_ip = 8; + int32 dns_type = 9; +} + +message Rpc_Resp_SetDhcpDnsStatus { + int32 resp = 1; +} + +message Rpc_Req_GetDhcpDnsStatus { + int32 iface = 1; +} + +message Rpc_Resp_GetDhcpDnsStatus { + int32 iface = 1; + int32 net_link_up = 2; + + int32 dhcp_up = 3; + bytes dhcp_ip = 4; + bytes dhcp_nm = 5; + bytes dhcp_gw = 6; + + int32 dns_up = 7; + bytes dns_ip = 8; + int32 dns_type = 9; + int32 resp = 10; +} + +message Rpc_Req_SuppDppInit { + bool cb = 1; // enables sending of Event_SuppDpp to host via callback +} + +message Rpc_Resp_SuppDppInit { + int32 resp = 1; +} + +message Rpc_Req_SuppDppDeinit { +} + +message Rpc_Resp_SuppDppDeinit { + int32 resp = 1; +} + +message Rpc_Req_SuppDppBootstrapGen { + bytes chan_list = 1; // DPP Bootstrapping listen channels separated by commas + int32 type = 2; // Bootstrap method type, only QR Code method is supported for now. + bytes key = 3; // (Optional) 32 byte Raw Private Key for generating a Bootstrapping Public Key + bytes info = 4; // (Optional) Ancillary Device Information like Serial Number +} + +message Rpc_Resp_SuppDppBootstrapGen { + int32 resp = 1; +} + +message Rpc_Req_SuppDppStartListen { +} + +message Rpc_Resp_SuppDppStartListen { + int32 resp = 1; +} + +message Rpc_Req_SuppDppStopListen { +} + +message Rpc_Resp_SuppDppStopListen { + int32 resp = 1; +} + +message Rpc_Req_IfaceMacAddrSetGet { + bool set = 1; + uint32 type = 2; + bytes mac = 3; // only valid for set +}; + +message Rpc_Resp_IfaceMacAddrSetGet { + int32 resp = 1; + bool set = 2; + uint32 type = 3; + bytes mac = 4; +}; + +message Rpc_Req_IfaceMacAddrLenGet { + uint32 type = 1; +}; + +message Rpc_Resp_IfaceMacAddrLenGet { + int32 resp = 1; + uint32 type = 2; + uint32 len = 3; +}; + +message Rpc_Req_FeatureControl { + RpcFeature feature = 1; + RpcFeatureCommand command = 2; + RpcFeatureOption option = 3; +}; + +message Rpc_Resp_FeatureControl { + int32 resp = 1; + RpcFeature feature = 2; + RpcFeatureCommand command = 3; + RpcFeatureOption option = 4; +}; + +/** Event structure **/ + +message Rpc_Event_WifiEventNoArgs { + int32 resp = 1; + int32 event_id = 2; +} + +message Rpc_Event_ESPInit { + bytes init_data = 1; +} + +message Rpc_Event_Heartbeat { + int32 hb_num = 1; +} + +message Rpc_Event_AP_StaDisconnected { + int32 resp = 1; + bytes mac = 2; + uint32 aid = 3; + bool is_mesh_child = 4; + uint32 reason = 5; +} + +message Rpc_Event_AP_StaConnected { + int32 resp = 1; + bytes mac = 2; + uint32 aid = 3; + bool is_mesh_child = 4; +} + +message Rpc_Event_StaScanDone { + int32 resp = 1; + wifi_event_sta_scan_done scan_done = 2; +} + +message Rpc_Event_StaConnected { + int32 resp = 1; + wifi_event_sta_connected sta_connected = 2; +} + +message Rpc_Event_StaDisconnected { + int32 resp = 1; + wifi_event_sta_disconnected sta_disconnected = 2; +} + +message Rpc_Event_DhcpDnsStatus { + int32 iface = 1; + int32 net_link_up = 2; + + int32 dhcp_up = 3; + bytes dhcp_ip = 4; + bytes dhcp_nm = 5; + bytes dhcp_gw = 6; + + int32 dns_up = 7; + bytes dns_ip = 8; + int32 dns_type = 9; + int32 resp = 10; +} + +message Rpc_Event_StaItwtSetup { + int32 resp = 1; + wifi_itwt_setup_config config = 2; + int32 status = 3; + uint32 reason = 4; + uint64 target_wake_time = 5; +} + +message Rpc_Event_StaItwtTeardown { + int32 resp = 1; + uint32 flow_id = 2; + uint32 status = 3; +} + +message Rpc_Event_StaItwtSuspend { + int32 resp = 1; + int32 status = 2; + uint32 flow_id_bitmap = 3; + repeated uint32 actual_suspend_time_ms = 4; // represents uint32_t actual_suspend_time_ms[] +} + +message Rpc_Event_StaItwtProbe { + int32 resp = 1; + int32 status = 2; + uint32 reason = 3; +} + +message Rpc_Req_WifiStaEnterpriseEnable { +} + +message Rpc_Resp_WifiStaEnterpriseEnable { + int32 resp = 1; +} + +message Rpc_Req_WifiStaEnterpriseDisable { +} + +message Rpc_Resp_WifiStaEnterpriseDisable { + int32 resp = 1; +} + +message Rpc_Req_EapSetIdentity { + bytes identity = 1; + int32 len = 2; +} + +message Rpc_Resp_EapSetIdentity { + int32 resp = 1; +} + +message Rpc_Req_EapClearIdentity { +} + +message Rpc_Resp_EapClearIdentity { + int32 resp = 1; +} + +message Rpc_Req_EapSetUsername { + bytes username = 1; + int32 len = 2; +} + +message Rpc_Resp_EapSetUsername { + int32 resp = 1; +} + +message Rpc_Req_EapClearUsername { +} + +message Rpc_Resp_EapClearUsername { + int32 resp = 1; +} + +message Rpc_Req_EapSetPassword { + bytes password = 1; + int32 len = 2; +} + +message Rpc_Resp_EapSetPassword { + int32 resp = 1; +} + +message Rpc_Req_EapClearPassword { +} + +message Rpc_Resp_EapClearPassword { + int32 resp = 1; +} + +message Rpc_Req_EapSetNewPassword { + bytes new_password = 1; + int32 len = 2; +} + +message Rpc_Resp_EapSetNewPassword { + int32 resp = 1; +} + +message Rpc_Req_EapClearNewPassword { +} + +message Rpc_Resp_EapClearNewPassword { + int32 resp = 1; +} + +message Rpc_Req_EapSetCaCert { + bytes ca_cert = 1; + int32 ca_cert_len = 2; +} + +message Rpc_Resp_EapSetCaCert { + int32 resp = 1; +} + +message Rpc_Req_EapClearCaCert { +} + +message Rpc_Resp_EapClearCaCert { + int32 resp = 1; +} + +message Rpc_Req_EapSetCertificateAndKey { + bytes client_cert = 1; + int32 client_cert_len = 2; + bytes private_key = 3; + int32 private_key_len = 4; + bytes private_key_password = 5; + int32 private_key_passwd_len = 6; +} + +message Rpc_Resp_EapSetCertificateAndKey { + int32 resp = 1; +} + +message Rpc_Req_EapClearCertificateAndKey { +} + +message Rpc_Resp_EapClearCertificateAndKey { + int32 resp = 1; +} + +message Rpc_Req_EapSetDisableTimeCheck { + bool disable = 1; +} + +message Rpc_Resp_EapSetDisableTimeCheck { + int32 resp = 1; +} + +message Rpc_Req_EapGetDisableTimeCheck { +} + +message Rpc_Resp_EapGetDisableTimeCheck { + int32 resp = 1; + bool disable = 2; +} + +message Rpc_Req_EapSetTtlsPhase2Method { + int32 type = 1; +} + +message Rpc_Resp_EapSetTtlsPhase2Method { + int32 resp = 1; +} + +message Rpc_Req_EapSetSuiteb192bitCertification { + bool enable = 1; +} + +message Rpc_Resp_EapSetSuiteb192bitCertification { + int32 resp = 1; +} + +message Rpc_Req_EapSetPacFile { + bytes pac_file = 1; + int32 pac_file_len = 2; +} + +message Rpc_Resp_EapSetPacFile { + int32 resp = 1; +} + +message Rpc_Req_EapSetFastParams { + eap_fast_config eap_fast_config = 1; +} + +message Rpc_Resp_EapSetFastParams { + int32 resp = 1; +} + +message Rpc_Req_EapUseDefaultCertBundle { + bool use_default_bundle = 1; +} + +message Rpc_Resp_EapUseDefaultCertBundle { + int32 resp = 1; +} + +message Rpc_Req_WifiSetOkcSupport { + bool enable = 1; +} + +message Rpc_Resp_WifiSetOkcSupport { + int32 resp = 1; +} + +message Rpc_Req_EapSetDomainName { + bytes domain_name = 1; +} + +message Rpc_Resp_EapSetDomainName { + int32 resp = 1; +} + +message Rpc_Req_EapSetEapMethods { + int32 methods = 1; +} + +message Rpc_Resp_EapSetEapMethods { + int32 resp = 1; +} + +message Rpc_Event_SuppDppUriReady { + int32 resp = 1; + bytes qrcode = 2; // QR Code to configure the enrollee +} + +message Rpc_Event_SuppDppCfgRecvd { + int32 resp = 1; + wifi_config cfg = 2; +} + +message Rpc_Event_SuppDppFail { + int32 resp = 1; + int32 reason = 2; // failure reason +} + +message Rpc_Event_WifiDppUriReady { + int32 resp = 1; + bytes qrcode = 2; // QR Code to configure the enrollee +} + +message Rpc_Event_WifiDppCfgRecvd { + int32 resp = 1; + wifi_config cfg = 2; +} + +message Rpc_Event_WifiDppFail { + int32 resp = 1; + int32 reason = 2; // failure reason +} + +message Rpc { + /* msg_type could be req, resp or Event */ + RpcType msg_type = 1; + + /* msg id */ + RpcId msg_id = 2; + + /* UID of message */ + uint32 uid = 3; + + /* union of all msg ids */ + oneof payload { + /** Requests **/ + Rpc_Req_GetMacAddress req_get_mac_address = 257; + Rpc_Req_SetMacAddress req_set_mac_address = 258; + Rpc_Req_GetMode req_get_wifi_mode = 259; + Rpc_Req_SetMode req_set_wifi_mode = 260; + + Rpc_Req_SuppDppInit req_supp_dpp_init = 261; + Rpc_Req_SuppDppDeinit req_supp_dpp_deinit = 262; + Rpc_Req_SuppDppBootstrapGen req_supp_dpp_bootstrap_gen = 263; + Rpc_Req_SuppDppStartListen req_supp_dpp_start_listen = 264; + Rpc_Req_SuppDppStopListen req_supp_dpp_stop_listen = 265; + + //Rpc_Req_SetSoftAPVendorSpecificIE req_set_softap_vendor_specific_ie = 266; + //Rpc_Req_StartSoftAP req_start_softap = 267; + //Rpc_Req_SoftAPConnectedSTA req_softap_connected_stas_list = 268; + //Rpc_Req_GetStatus req_stop_softap = 269; + + Rpc_Req_SetPs req_wifi_set_ps = 270; + Rpc_Req_GetPs req_wifi_get_ps = 271; + + Rpc_Req_OTABegin req_ota_begin = 272; + Rpc_Req_OTAWrite req_ota_write = 273; + Rpc_Req_OTAEnd req_ota_end = 274; + + Rpc_Req_WifiSetMaxTxPower req_set_wifi_max_tx_power = 275; + Rpc_Req_WifiGetMaxTxPower req_get_wifi_max_tx_power = 276; + Rpc_Req_ConfigHeartbeat req_config_heartbeat = 277; + + Rpc_Req_WifiInit req_wifi_init = 278; + Rpc_Req_WifiDeinit req_wifi_deinit = 279; + Rpc_Req_WifiStart req_wifi_start = 280; + Rpc_Req_WifiStop req_wifi_stop = 281; + Rpc_Req_WifiConnect req_wifi_connect = 282; + Rpc_Req_WifiDisconnect req_wifi_disconnect = 283; + Rpc_Req_WifiSetConfig req_wifi_set_config = 284; + Rpc_Req_WifiGetConfig req_wifi_get_config = 285; + + Rpc_Req_WifiScanStart req_wifi_scan_start = 286; + Rpc_Req_WifiScanStop req_wifi_scan_stop = 287; + Rpc_Req_WifiScanGetApNum req_wifi_scan_get_ap_num = 288; + Rpc_Req_WifiScanGetApRecords req_wifi_scan_get_ap_records = 289; + Rpc_Req_WifiClearApList req_wifi_clear_ap_list = 290; + + Rpc_Req_WifiRestore req_wifi_restore = 291; + Rpc_Req_WifiClearFastConnect req_wifi_clear_fast_connect = 292; + Rpc_Req_WifiDeauthSta req_wifi_deauth_sta = 293; + Rpc_Req_WifiStaGetApInfo req_wifi_sta_get_ap_info = 294; + + Rpc_Req_WifiSetProtocol req_wifi_set_protocol = 297; + Rpc_Req_WifiGetProtocol req_wifi_get_protocol = 298; + Rpc_Req_WifiSetBandwidth req_wifi_set_bandwidth = 299; + Rpc_Req_WifiGetBandwidth req_wifi_get_bandwidth = 300; + Rpc_Req_WifiSetChannel req_wifi_set_channel = 301; + Rpc_Req_WifiGetChannel req_wifi_get_channel = 302; + Rpc_Req_WifiSetCountry req_wifi_set_country = 303; + Rpc_Req_WifiGetCountry req_wifi_get_country = 304; + + Rpc_Req_WifiApGetStaList req_wifi_ap_get_sta_list = 311; + Rpc_Req_WifiApGetStaAid req_wifi_ap_get_sta_aid = 312; + Rpc_Req_WifiSetStorage req_wifi_set_storage = 313; + + Rpc_Req_WifiSetInactiveTime req_wifi_set_inactive_time = 325; + Rpc_Req_WifiGetInactiveTime req_wifi_get_inactive_time = 326; + + Rpc_Req_WifiSetCountryCode req_wifi_set_country_code = 334; + Rpc_Req_WifiGetCountryCode req_wifi_get_country_code = 335; + Rpc_Req_WifiStaGetAid req_wifi_sta_get_aid = 338; + Rpc_Req_WifiStaGetNegotiatedPhymode req_wifi_sta_get_negotiated_phymode = 339; + + Rpc_Req_WifiStaGetRssi req_wifi_sta_get_rssi = 341; + + Rpc_Req_WifiSetProtocols req_wifi_set_protocols = 342; + Rpc_Req_WifiGetProtocols req_wifi_get_protocols = 343; + Rpc_Req_WifiSetBandwidths req_wifi_set_bandwidths = 344; + Rpc_Req_WifiGetBandwidths req_wifi_get_bandwidths = 345; + + Rpc_Req_WifiSetBand req_wifi_set_band = 346; + Rpc_Req_WifiGetBand req_wifi_get_band = 347; + Rpc_Req_WifiSetBandMode req_wifi_set_bandmode = 348; + Rpc_Req_WifiGetBandMode req_wifi_get_bandmode = 349; + + Rpc_Req_GetCoprocessorFwVersion req_get_coprocessor_fwversion = 350; + + Rpc_Req_WifiScanGetApRecord req_wifi_scan_get_ap_record = 351; + + Rpc_Req_SetDhcpDnsStatus req_set_dhcp_dns = 352; + Rpc_Req_GetDhcpDnsStatus req_get_dhcp_dns = 353; + + Rpc_Req_WifiStaTwtConfig req_wifi_sta_twt_config = 354; + Rpc_Req_WifiStaItwtSetup req_wifi_sta_itwt_setup = 355; + Rpc_Req_WifiStaItwtTeardown req_wifi_sta_itwt_teardown = 356; + Rpc_Req_WifiStaItwtSuspend req_wifi_sta_itwt_suspend = 357; + Rpc_Req_WifiStaItwtGetFlowIdStatus req_wifi_sta_itwt_get_flow_id_status = 358; + Rpc_Req_WifiStaItwtSendProbeReq req_wifi_sta_itwt_send_probe_req = 359; + Rpc_Req_WifiStaItwtSetTargetWakeTimeOffset req_wifi_sta_itwt_set_target_wake_time_offset = 360; + + Rpc_Req_WifiStaEnterpriseEnable req_wifi_sta_enterprise_enable = 361; + Rpc_Req_WifiStaEnterpriseDisable req_wifi_sta_enterprise_disable = 362; + Rpc_Req_EapSetIdentity req_eap_set_identity = 363; + Rpc_Req_EapClearIdentity req_eap_clear_identity = 364; + Rpc_Req_EapSetUsername req_eap_set_username = 365; + Rpc_Req_EapClearUsername req_eap_clear_username = 366; + Rpc_Req_EapSetPassword req_eap_set_password = 367; + Rpc_Req_EapClearPassword req_eap_clear_password = 368; + Rpc_Req_EapSetNewPassword req_eap_set_new_password = 369; + Rpc_Req_EapClearNewPassword req_eap_clear_new_password = 370; + Rpc_Req_EapSetCaCert req_eap_set_ca_cert = 371; + Rpc_Req_EapClearCaCert req_eap_clear_ca_cert = 372; + Rpc_Req_EapSetCertificateAndKey req_eap_set_certificate_and_key = 373; + Rpc_Req_EapClearCertificateAndKey req_eap_clear_certificate_and_key = 374; + Rpc_Req_EapGetDisableTimeCheck req_eap_get_disable_time_check = 375; + Rpc_Req_EapSetTtlsPhase2Method req_eap_set_ttls_phase2_method = 376; + Rpc_Req_EapSetSuiteb192bitCertification req_eap_set_suiteb_certification = 377; + Rpc_Req_EapSetPacFile req_eap_set_pac_file = 378; + Rpc_Req_EapSetFastParams req_eap_set_fast_params = 379; + Rpc_Req_EapUseDefaultCertBundle req_eap_use_default_cert_bundle = 380; + Rpc_Req_WifiSetOkcSupport req_wifi_set_okc_support = 381; + Rpc_Req_EapSetDomainName req_eap_set_domain_name = 382; + Rpc_Req_EapSetDisableTimeCheck req_eap_set_disable_time_check = 383; + Rpc_Req_EapSetEapMethods req_eap_set_eap_methods = 384; + + Rpc_Req_IfaceMacAddrSetGet req_iface_mac_addr_set_get = 385; + Rpc_Req_IfaceMacAddrLenGet req_iface_mac_addr_len_get = 386; + + Rpc_Req_FeatureControl req_feature_control = 387; + + /** Responses **/ + Rpc_Resp_GetMacAddress resp_get_mac_address = 513; + Rpc_Resp_SetMacAddress resp_set_mac_address = 514; + Rpc_Resp_GetMode resp_get_wifi_mode = 515; + Rpc_Resp_SetMode resp_set_wifi_mode = 516; + + Rpc_Resp_SuppDppInit resp_supp_dpp_init = 517; + Rpc_Resp_SuppDppDeinit resp_supp_dpp_deinit = 518; + Rpc_Resp_SuppDppBootstrapGen resp_supp_dpp_bootstrap_gen = 519; + Rpc_Resp_SuppDppStartListen resp_supp_dpp_start_listen = 520; + Rpc_Resp_SuppDppStopListen resp_supp_dpp_stop_listen = 521; + + //Rpc_Resp_SetSoftAPVendorSpecificIE resp_set_softap_vendor_specific_ie = 522; + //Rpc_Resp_StartSoftAP resp_start_softap = 523; + //Rpc_Resp_SoftAPConnectedSTA resp_softap_connected_stas_list = 524; + //Rpc_Resp_GetStatus resp_stop_softap = 525; + + Rpc_Resp_SetPs resp_wifi_set_ps = 526; + Rpc_Resp_GetPs resp_wifi_get_ps = 527; + + Rpc_Resp_OTABegin resp_ota_begin = 528; + Rpc_Resp_OTAWrite resp_ota_write = 529; + Rpc_Resp_OTAEnd resp_ota_end = 530; + Rpc_Resp_WifiSetMaxTxPower resp_set_wifi_max_tx_power = 531; + Rpc_Resp_WifiGetMaxTxPower resp_get_wifi_max_tx_power = 532; + Rpc_Resp_ConfigHeartbeat resp_config_heartbeat = 533; + + Rpc_Resp_WifiInit resp_wifi_init = 534; + Rpc_Resp_WifiDeinit resp_wifi_deinit = 535; + Rpc_Resp_WifiStart resp_wifi_start = 536; + Rpc_Resp_WifiStop resp_wifi_stop = 537; + Rpc_Resp_WifiConnect resp_wifi_connect = 538; + Rpc_Resp_WifiDisconnect resp_wifi_disconnect = 539; + Rpc_Resp_WifiSetConfig resp_wifi_set_config = 540; + Rpc_Resp_WifiGetConfig resp_wifi_get_config = 541; + + Rpc_Resp_WifiScanStart resp_wifi_scan_start = 542; + Rpc_Resp_WifiScanStop resp_wifi_scan_stop = 543; + Rpc_Resp_WifiScanGetApNum resp_wifi_scan_get_ap_num = 544; + Rpc_Resp_WifiScanGetApRecords resp_wifi_scan_get_ap_records = 545; + Rpc_Resp_WifiClearApList resp_wifi_clear_ap_list = 546; + + Rpc_Resp_WifiRestore resp_wifi_restore = 547; + Rpc_Resp_WifiClearFastConnect resp_wifi_clear_fast_connect = 548; + Rpc_Resp_WifiDeauthSta resp_wifi_deauth_sta = 549; + Rpc_Resp_WifiStaGetApInfo resp_wifi_sta_get_ap_info = 550; + + Rpc_Resp_WifiSetProtocol resp_wifi_set_protocol = 553; + Rpc_Resp_WifiGetProtocol resp_wifi_get_protocol = 554; + Rpc_Resp_WifiSetBandwidth resp_wifi_set_bandwidth = 555; + Rpc_Resp_WifiGetBandwidth resp_wifi_get_bandwidth = 556; + Rpc_Resp_WifiSetChannel resp_wifi_set_channel = 557; + Rpc_Resp_WifiGetChannel resp_wifi_get_channel = 558; + Rpc_Resp_WifiSetCountry resp_wifi_set_country = 559; + Rpc_Resp_WifiGetCountry resp_wifi_get_country = 560; + + Rpc_Resp_WifiApGetStaList resp_wifi_ap_get_sta_list = 567; + Rpc_Resp_WifiApGetStaAid resp_wifi_ap_get_sta_aid = 568; + Rpc_Resp_WifiSetStorage resp_wifi_set_storage = 569; + + Rpc_Resp_WifiSetInactiveTime resp_wifi_set_inactive_time = 581; + Rpc_Resp_WifiGetInactiveTime resp_wifi_get_inactive_time = 582; + + Rpc_Resp_WifiSetCountryCode resp_wifi_set_country_code = 590; + Rpc_Resp_WifiGetCountryCode resp_wifi_get_country_code = 591; + Rpc_Resp_WifiStaGetAid resp_wifi_sta_get_aid = 594; + Rpc_Resp_WifiStaGetNegotiatedPhymode resp_wifi_sta_get_negotiated_phymode = 595; + + Rpc_Resp_WifiStaGetRssi resp_wifi_sta_get_rssi = 597; + + Rpc_Resp_WifiSetProtocols resp_wifi_set_protocols = 598; + Rpc_Resp_WifiGetProtocols resp_wifi_get_protocols = 599; + Rpc_Resp_WifiSetBandwidths resp_wifi_set_bandwidths = 600; + Rpc_Resp_WifiGetBandwidths resp_wifi_get_bandwidths = 601; + + Rpc_Resp_WifiSetBand resp_wifi_set_band = 602; + Rpc_Resp_WifiGetBand resp_wifi_get_band = 603; + Rpc_Resp_WifiSetBandMode resp_wifi_set_bandmode = 604; + Rpc_Resp_WifiGetBandMode resp_wifi_get_bandmode = 605; + + Rpc_Resp_GetCoprocessorFwVersion resp_get_coprocessor_fwversion = 606; + + Rpc_Resp_WifiScanGetApRecord resp_wifi_scan_get_ap_record = 607; + + Rpc_Resp_SetDhcpDnsStatus resp_set_dhcp_dns = 608; + Rpc_Resp_GetDhcpDnsStatus resp_get_dhcp_dns = 609; + + Rpc_Resp_WifiStaTwtConfig resp_wifi_sta_twt_config = 610; + Rpc_Resp_WifiStaItwtSetup resp_wifi_sta_itwt_setup = 611; + Rpc_Resp_WifiStaItwtTeardown resp_wifi_sta_itwt_teardown = 612; + Rpc_Resp_WifiStaItwtSuspend resp_wifi_sta_itwt_suspend = 613; + Rpc_Resp_WifiStaItwtGetFlowIdStatus resp_wifi_sta_itwt_get_flow_id_status = 614; + Rpc_Resp_WifiStaItwtSendProbeReq resp_wifi_sta_itwt_send_probe_req = 615; + Rpc_Resp_WifiStaItwtSetTargetWakeTimeOffset resp_wifi_sta_itwt_set_target_wake_time_offset = 616; + + Rpc_Resp_WifiStaEnterpriseEnable resp_wifi_sta_enterprise_enable = 617; + Rpc_Resp_WifiStaEnterpriseDisable resp_wifi_sta_enterprise_disable = 618; + Rpc_Resp_EapSetIdentity resp_eap_set_identity = 619; + Rpc_Resp_EapClearIdentity resp_eap_clear_identity = 620; + Rpc_Resp_EapSetUsername resp_eap_set_username = 621; + Rpc_Resp_EapClearUsername resp_eap_clear_username = 622; + Rpc_Resp_EapSetPassword resp_eap_set_password = 623; + Rpc_Resp_EapClearPassword resp_eap_clear_password = 624; + Rpc_Resp_EapSetNewPassword resp_eap_set_new_password = 625; + Rpc_Resp_EapClearNewPassword resp_eap_clear_new_password = 626; + Rpc_Resp_EapSetCaCert resp_eap_set_ca_cert = 627; + Rpc_Resp_EapClearCaCert resp_eap_clear_ca_cert = 628; + Rpc_Resp_EapSetCertificateAndKey resp_eap_set_certificate_and_key = 629; + Rpc_Resp_EapClearCertificateAndKey resp_eap_clear_certificate_and_key = 630; + Rpc_Resp_EapGetDisableTimeCheck resp_eap_get_disable_time_check = 631; + Rpc_Resp_EapSetTtlsPhase2Method resp_eap_set_ttls_phase2_method = 632; + Rpc_Resp_EapSetSuiteb192bitCertification resp_eap_set_suiteb_certification = 633; + Rpc_Resp_EapSetPacFile resp_eap_set_pac_file = 634; + Rpc_Resp_EapSetFastParams resp_eap_set_fast_params = 635; + Rpc_Resp_EapUseDefaultCertBundle resp_eap_use_default_cert_bundle = 636; + Rpc_Resp_WifiSetOkcSupport resp_wifi_set_okc_support = 637; + Rpc_Resp_EapSetDomainName resp_eap_set_domain_name = 638; + Rpc_Resp_EapSetDisableTimeCheck resp_eap_set_disable_time_check = 639; + Rpc_Resp_EapSetEapMethods resp_eap_set_eap_methods = 640; + + Rpc_Resp_IfaceMacAddrSetGet resp_iface_mac_addr_set_get = 641; + Rpc_Resp_IfaceMacAddrLenGet resp_iface_mac_addr_len_get = 642; + + Rpc_Resp_FeatureControl resp_feature_control = 643; + + /** Notifications **/ + Rpc_Event_ESPInit event_esp_init = 769; + Rpc_Event_Heartbeat event_heartbeat = 770; + Rpc_Event_AP_StaConnected event_ap_sta_connected = 771; + Rpc_Event_AP_StaDisconnected event_ap_sta_disconnected = 772; + Rpc_Event_WifiEventNoArgs event_wifi_event_no_args = 773; + Rpc_Event_StaScanDone event_sta_scan_done = 774; + Rpc_Event_StaConnected event_sta_connected = 775; + Rpc_Event_StaDisconnected event_sta_disconnected = 776; + Rpc_Event_DhcpDnsStatus event_dhcp_dns = 777; + Rpc_Event_StaItwtSetup event_sta_itwt_setup = 778; + Rpc_Event_StaItwtTeardown event_sta_itwt_teardown = 779; + Rpc_Event_StaItwtSuspend event_sta_itwt_suspend = 780; + Rpc_Event_StaItwtProbe event_sta_itwt_probe = 781; + Rpc_Event_SuppDppUriReady event_supp_dpp_uri_ready = 782; + Rpc_Event_SuppDppCfgRecvd event_supp_dpp_cfg_recvd = 783; + Rpc_Event_SuppDppFail event_supp_dpp_fail = 784; + Rpc_Event_WifiDppUriReady event_wifi_dpp_uri_ready = 785; + Rpc_Event_WifiDppCfgRecvd event_wifi_dpp_cfg_recvd = 786; + Rpc_Event_WifiDppFail event_wifi_dpp_fail = 787; + } +} diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/.commit_docs.sh b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/.commit_docs.sh new file mode 100644 index 0000000..048a81b --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/.commit_docs.sh @@ -0,0 +1,75 @@ +#!/bin/bash -e + +# from git-sh-setup.sh +require_clean_work_tree () { + git rev-parse --verify HEAD >/dev/null || exit 1 + git update-index -q --ignore-submodules --refresh + err=0 + + if ! git diff-files --quiet --ignore-submodules + then + echo >&2 "Cannot $0: You have unstaged changes." + err=1 + fi + + if ! git diff-index --cached --quiet --ignore-submodules HEAD -- + then + if [ $err = 0 ] + then + echo >&2 "Cannot $0: Your index contains uncommitted changes." + else + echo >&2 "Additionally, your index contains uncommitted changes." + fi + err=1 + fi + + if [ $err = 1 ] + then + test -n "$2" && echo >&2 "$2" + exit 1 + fi +} + +require_clean_work_tree + +if ! which doxygen >/dev/null; then + echo "Error: doxygen is required" + exit 1 +fi + +DOXYGEN_VERSION="$(doxygen --version)" + +DOC_BRANCH="gh-pages" +ORIG_BRANCH="$(git rev-parse --abbrev-ref HEAD)" +ORIG_COMMIT="$(git describe --match=NeVeRmAtCh --always --abbrev=40 --dirty)" + +TOP="$(pwd)" +export GIT_DIR="$TOP/.git" + +TMPDIR="$(mktemp --tmpdir=$TOP -d)" +HTMLDIR="$TMPDIR/_build/html" +INDEX_FILE="$GIT_DIR/index.${DOC_BRANCH}" + +rm -f "$INDEX_FILE" + +trap "{ cd $TOP; git checkout --force ${ORIG_BRANCH}; rm -f $INDEX_FILE; rm -rf $TMPDIR; }" EXIT + +cd "$TMPDIR" +git reset --hard HEAD + +./autogen.sh +mkdir _build +cd _build +../configure +make html + +if ! git checkout "${DOC_BRANCH}"; then + git checkout --orphan "${DOC_BRANCH}" +fi + +touch "$HTMLDIR/.nojekyll" + +GIT_INDEX_FILE="$INDEX_FILE" GIT_WORK_TREE="$HTMLDIR" \ + git add --no-ignore-removal . +GIT_INDEX_FILE="$INDEX_FILE" GIT_WORK_TREE="$HTMLDIR" \ + git commit -m "Rebuild html documentation from commit ${ORIG_COMMIT} using Doxygen ${DOXYGEN_VERSION}" diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/.gitignore b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/.gitignore new file mode 100644 index 0000000..9733625 --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/.gitignore @@ -0,0 +1,43 @@ +*~ +.*swp +*.la +*.gcda +*.gcno +*.lo +*.log +*.o +*.tar.gz +*.trs +.deps/ +.dirstamp +.libs/ +/Doxyfile +/Makefile +/Makefile.in +/aclocal.m4 +/autom4te.cache +/build-aux +/config.* +/configure +/doxygen-doc +/html +/libtool +/protobuf-c-*-coverage.info +/protobuf-c-*-coverage/ +/stamp-h1 +/stamp-html +/test-suite.log +TAGS +protobuf-c/libprotobuf-c.pc +protoc-c/protoc-c +protoc-c/protoc-gen-c +t/generated-code/test-generated-code +t/generated-code2/cxx-generate-packed-data +t/generated-code2/test-full-cxx-output.inc +t/generated-code2/test-generated-code2 +t/generated-code3/test-generated-code3 +t/version/version +*.pb-c.c +*.pb-c.h +*.pb.cc +*.pb.h diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/CONTRIBUTING.md b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/CONTRIBUTING.md new file mode 100644 index 0000000..ceaba8f --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/CONTRIBUTING.md @@ -0,0 +1,5 @@ +## Contributing + +The most recently released `protobuf-c` version is kept on the `master` branch, while the `next` branch is used for commits targeted at the next release. Please base patches and pull requests against the `next` branch. __Do not open pull requests against master!__ + +Copyright to all contributions are retained by the original author, but must be licensed under the terms of the [BSD-2-Clause](http://opensource.org/licenses/BSD-2-Clause) license. diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/ChangeLog b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/ChangeLog new file mode 100644 index 0000000..91164dd --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/ChangeLog @@ -0,0 +1,564 @@ +protobuf-c (1.4.1) + + [ Robert Edmonds ] + * Release 1.4.1 + + [ Todd C. Miller ] + * Only shift unsigned values to avoid implementation-specific behavior + (#506, #508). + * Fix regression with zero-length messages introduced in protobuf-c PR 500. + * Fix a clang analyzer 14 warning about a possible NULL deref (#512, #514). + + [ steed717 ] + * Fix unsigned integer overflow (#499, #513). + +protobuf-c (1.4.0) + + [ Robert Edmonds ] + * Release 1.4.0. + + [ Ilya Lipnitsky ] + * c_message.cc: Resolve name conflict between certain enums and oneofs + (#427). + * protobuf-c.h: Fix Windows DLL export issue with the + protobuf_c_empty_string symbol (#428). + * Standardize pkg-config for use by autotools and cmake, fix cmake tests + (#425). + * protobuf-c.c: Cast %lu args to unsigned long int (#429). + * protoc-c: Remove leading underscores from structs (#430). + * protoc-c: Fix shared lib build on windows, migrate from Travis CI to + GitHub Actions (#459). + * protobuf-c: Don't use ProtobufCWireType internally (#463). + * protoc-c: Add custom options support (#466). + * protobuf-c.c: Fix packed repeated bool parsing (#467). + + [ Markus Engel ] + * Pack nested messages inline (#431). + + [ Daniel Axtens ] + * Travis CI: Test on other platforms (#438). + + [ Adam Cozzette ] + * Update the generator to fully qualify std::string (#443). + + [ Piotr Pietraszkiewicz ] + * Install MSVC debug symbols alongside the protobuf-c.lib file (#456). + + [ ihsinme ] + * Fix invalid unsigned arithmetic (#455). + + [ Wolfram Rösler ] + * Avoid "unused function parameter" compiler warning (#453). + +protobuf-c (1.3.3) + + [ Robert Edmonds ] + * Release 1.3.3. + + * Fix build failure on protobuf 2.x (#398). + + [ msshapira ] + * CMake: Fix support for MSVC static build (#350). + + [ Adam Cozzette ] + * Fix some test assertions in test-generated-code2.c (#392). + + [ Ilya Lipnitskiy ] + * protobuf-c.c: Make zigzag encoding more compact (#400). + + [ Markus Engel ] + * CMake: Fix endianness check. + +protobuf-c (1.3.2) + + [ Robert Edmonds ] + * Release 1.3.2. + + * Use protobuf 3.7.1 in the Travis-CI environment (#368). + + * Fix test suite build failure on newer versions of protobuf (#369). + + [ Ilya Lipnitskiy ] + * Fix proto3 repeated scalar field default packing behavior (#330, #377). + + [ Adam Cozzette ] + * Fix out-of-bounds read in scan_length_prefixed_data() (#375, #376). + + [ Jurriaan Bremer ] + * Fix -Wdeclaration-after-statement warning in parse_oneof_member() (#360). + + [ Hayri Ugur Koltuk ] + * Fix SIGSEGV in protobuf_c_message_check() on messages with unpopulated + oneof members (#358). + + [ Italo Guerrieri ] + * Do not allow tag values of 0 in protobuf messages, as these are not + allowed by proto2 or proto3 (#299). + +protobuf-c (1.3.1) + + [ Robert Edmonds ] + * Release 1.3.1. + + * Restore protobuf-2.x compatibility (#284, #285). + + * Use xenial and protobuf 3.6.1 in the Travis-CI environment (#332). + + * Convert uses of protobuf's scoped_ptr.h to C++11 std::unique_ptr, needed + to compile against protobuf 3.6.1 (#320, #333). + + * Use AX_CXX_COMPILE_STDCXX macro to enable C++11 support in old compilers + (#312, #317, #327, #334). + + [ Fredrik Gustafsson ] + * Add std:: to some types (#294, #305, #309). + + [ Sam Collinson ] + * Check the return value of int_range_lookup before using as an array index; + it can return -1 (#315). + + [ Matthias Dittrich ] + * Fix compilation on mingw by using explicit protoc --plugin=NAME=PATH syntax + in Makefile.am (#289, #290). + +protobuf-c (1.3.0) + + [ Robert Edmonds ] + * Release 1.3.0. + + * Add test case for the issue in #220 (#254). + + * Fix issue #251, "Bad enums with multiple oneofs" (#256). + + * Add warning flags to my_CFLAGS (#257). + + * Fix namespace errors when compiled with latest protobuf (#280). + + * Bump minimum required header version for proto3 syntax (#282). + + [ Paolo Borelli ] + * Turn the compiler into a protoc plugin (#206). This allows the protobuf-c + compiler to be invoked as "protoc --c_out=...". For backwards + compatibility, we still ship a protoc-c command, but it's a symlink to the + protoc-gen-c binary. + + * proto3 support (#228). + + * Remove leftover FIXME comment (#258). + + * Fix proto3 "is zeroish" evaluation (#264). + + * Small cleanup in oneof handling (#265). + + * Rework is_zeroish one more time (#267). + + * proto3: make strings default to "" instead of NULL (#274). + + [ Tomek Wasilczyk ] + * Fix -Wsign-compare warnings (#213). + + * Fix ISO C90 -Wdeclaration-after-statement warnings (#214). + + * Fix bigendian -Wunused-label warning (#215). + + [ Ilya Lipnitsky ] + * protoc-c/c_message.cc: Force int size on oneof enums (#221). Fixes wrong + enum generation and handling for onceof cases (#220). + + [ Adnan ] + * Fix cmake build if built as part of an external project (#231). + + [ Gregory Detal ] + * Remove .pb.{cc,h} in distdir instead of top_distdir in order to prevent + removing files from other projects when protobuf-c is included as an + autotools subproject (#232). + + [ Ben Farnham ] + * Relax autoconf constraint from v2.64 to v2.63 so that it works on older + Linux distros (#233). + + [ Thomas Köckerbauer ] + * rm argument fix for Solaris (#234). + + * Add 'const' qualifier to 'init_value' variable in generated files (#236). + + [ Richard Kettlewell ] + * Document and extend the effect of passing NULL to ..._free_unpacked + functions (#255). + + [ Alex Milich ] + * CMake: Workaround for static builds that use MSVC (#243). + + [ Josh Junon ] + * CMake: Allow protobuf-c to be included via include_subdirectory (#245). + + [ Alexei Kasatkin ] + * CMake: Windows fixes (#266). + +protobuf-c (1.2.1) + + [ Robert Edmonds ] + * Release 1.2.1. + + [ Paolo Borelli ] + * protoc-c: Generate code that uses the universal zero initializer {0} when + initializing a oneof union (#187, #205). + +protobuf-c (1.2.0) + + [ Robert Edmonds ] + * Release 1.2.0. + + [ Ilya Lipnitsky ] + * Implement the "optimize_for = CODE_SIZE" option (#183). + + * Eliminate undefined behavior in zigzag functions (#198). + + * Pack negative enum values correctly (#199). + + [ Peter Leschev ] + * Fix protobuf_c_message_get_packed_size() on 16-bit systems (#196, #197). + + [ Diego Elio Pettenò ] + * Update link to Autotools Mythbuster to canonical site (#201). + + [ Zex Li ] + * Skip test suite when cross-compiling (#184). + +protobuf-c (1.1.1) + + [ Robert Edmonds ] + * Release 1.1.1. + + * Use protobuf 2.6.1 in the Travis-CI environment. + + [ Ilya Lipnitskiy ] + * Munge C block comment delimiters in protobuf comments, preventing syntax + errors in generated header files (Issue #180, #185). + + * Add static qualifier to ProtobufCEnumValue and ProtobufCEnumValueIndex + variables in generated output. + + [ Oleg Efimov ] + * Fix -Wpointer-sign compiler diagnostics in the test suite. + + * Check for NULL pointers in protobuf_c_message_free_unpacked() + (Issue #177). + + * Exclude protoc-c and downloaded protobuf sources from Coveralls report. + + [ Andrey Myznikov ] + * Fix incorrect 'short_name' field values in ProtobufCServiceDescriptor + variables in generated output. + +protobuf-c (1.1.0) + + [ Robert Edmonds ] + * Release 1.1.0. + + [ Ilya Lipnitskiy ] + * Fix a bug when merging optional byte fields. + + * Documentation updates. + + * Implement oneof support (Issue #174). Protobuf 2.6.0 or newer is now + required to build protobuf-c. + + * Print leading comments for enum, message, and field definitions into + generated header files (Issue #175). + +protobuf-c (1.0.2) + + [ Robert Edmonds ] + * Release 1.0.2. + + [ Ilya Lipnitskiy ] + * Fix a build failure with Protobuf 2.6.0 related to aliased enum constants + (Issue #163). + + * Protobuf 2.5.0 or newer is now required to build protobuf-c (Issue #166). + This is due to the fix for #163. + + [ Alexei Kasatkin ] + * Eliminate void pointer arithmetic (Issue #167). + + * Always define PROTOBUF_C__DEPRECATED, even on compilers that are not GCC + (Issue #167). + + * Work around the lack of the 'inline' keyword in Microsoft compilers + (Issue #167). + + * Add a CMakeLists.txt file as a fallback build system for Windows + (Issue #168). + + [ Natanael Copa ] + * Fix a build failure in the test suite that occurred with a parallel make + running on a system with a large number of CPUs (Issue #156, #169). + +protobuf-c (1.0.1) + + [ Robert Edmonds ] + * Explicitly set the .data field of ProtobufCBinaryData's to NULL when + unpacking a zero length byte string (Issue #157). + +protobuf-c (1.0.0) + + [ Andrei Nigmatulin ] + * Append "u", "ull", and "ll" integer literal suffixes for uint32, uint64, + and int64 default values in generated code, in order to avoid "integer + constant is so large that it is unsigned" compiler warnings. + (Issue #136.) + + * Revert the problematic hash-based required field detection. + (Related to Issue #60, #79, #137.) + + * Replace the 'packed' member of ProtobufCFieldDescriptor with a 'flags' + word. Define flags for packed and deprecated fields. (Issue #138.) + + [ Dave Benson ] + * Treat a "length-prefixed" wire-type message for a repeated field as + packed-repeated whenever it makes sense (for all types other than + messages, strings, and bytes). + + * Switch to New BSD license. + + * Add protobuf_c_message_check(). + + * Compile error in packing 64-bit versions on some platforms + (srobbins99: Issue #68 Comment 1). + + * Fix for memory error if the required-field check fails. See Issue #63 + for demo (w/ nice test case by dror.harari). + + * Add PROTOBUF_C_{MAJOR,MINOR} for compile-time checks and + protobuf_c_{major,minor} for checks about the running library + (Issue #53). + + * Use a small constant-size hash-table instead of alloca() for detecting + required fields, and it also prevents us from using too much stack, etc. + (Related to Issue #60, #79). + + * Add a macro to ensure enums are the size of ints (Issue #69). + + [ Ilya Lipnitskiy ] + * Travis-CI integration. + + * Add source .proto filename to generated files. + + * Add protobuf-c version to protoc-c --version output (Issue #52). + + * For embedded submessage fields, merge multiple instances of the same + field, per the protobuf documentation (Issue #91). + + * Don't print unpack errors by default. + + * Optionally allow running the test suite under valgrind with ./configure + --enable-valgrind-tests. (Based on valgrind-tests.m4 from gnulib.) + + [ Kevin Lyda ] + * Autoconf portability fixes. + + * Add doxygen detection and make targets to the build system. + + * Doxygen documentation for the libprotobuf-c public API (Issue #132). + + [ Nick Galbreath ] + * Prevent possible overflow on 64-bit systems (Issue #106). + + [ Robert Edmonds ] + * Remove CMake (Issue #87). + + * Modernize the build system. + - Don't generate any diagnostics when building the build system with + modern autotools (Issue #89). + + - Use the PKG_CHECK_MODULES macro to locate protobuf. + + - Use the AC_C_BIGENDIAN macro to detect endianness, rather than custom + code. + + - Use the automake silent-rules option so the build output is actually + readable. + + - Generate our own pkg-config .pc files. + + * Reorganize the source tree. This affects the public protobuf-c header + path, which is now . A compatibility symlink from + to has been installed so that existing + code will continue to compile. New code should at some point begin using + the new include path, i.e., "#include " rather + than "#include ". + + * The RPC code has been split out into a separate project, protobuf-c-rpc. + + * Fix a potential use of an unitialized value in protobuf_c_message_unpack() + and several memory leaks in protoc-c, discovered by a commercial static code + analysis tool. + + * Bump the libprotobuf-c SONAME. + + * Begin versioning the library's symbols. (Based on ld-version-script.m4 + from gnulib.) + + * Preserve case in enum value names generated by protoc-c (Issue #129). + Reported by Oleg Efimov. + + * Add library functions protobuf_c_version() and protobuf_c_version_string() + for retrieving the version of the compiled library, and header macros + PROTOBUF_C_VERSION and PROTOBUF_C_VERSION_STRING for retrieving the + version of the header file. This replaces the interfaces for retrieving + the protobuf-c version numbers in Issue #53. + + * Add a version guard that ensures that the output of protoc-c is only + compiled against a protobuf-c header file from the exact same protobuf-c + release. + + * Add a --enable-code-coverage option to configure, which enables a + "make check-code-coverage" build target. This generates a code coverage + report and requires the lcov tool to be installed. + + * Remove the old DocBook documentation in doc/c-code-generator.{html,xml}. + Relevant material has been updated and incorporated into the Doxygen + documentation in the protobuf-c header file. + + * Remove the protobuf_c_default_allocator and protobuf_c_system_allocator + global variables from the exported library interface. All exported library + functions that need to perform dynamic memory allocation receive a + user-provided ProtobufCAllocator* parameter. If this parameter is NULL, + the system's default memory allocator will be used. + + Client code that previously passed "&protobuf_c_system_allocator" to + protobuf-c library functions taking a ProtobufCAllocator* argument should + be updated to pass "NULL" instead. + + Client code that previously overrode protobuf_c_default_allocator with + custom allocation functions and passed NULL as the ProtobufCAllocator* + argument to protobuf-c library functions should be updated to instead + enclose the custom allocation functions in a ProtobufCAllocator struct and + pass this object to protobuf-c library functions taking a + ProtobufCAllocator* parameter. + + * Update copyright and license statements throughout. The original + protobuf code released by Google was relicensed from Apache-2.0 to + BSD-3-Clause. Dave Benson also converted his license from BSD-3-Clause + to BSD-2-Clause. + + [ Tomasz Wasilczyk ] + * Don't export protobuf_c_message_init_generic() as an external symbol. + + * Don't use C++ style comments in C code. + + * Fix -Wcast-align warnings when compiled with clang. + +protobuf-c (0.15) + - make protobuf_c_message_init() into a function (Issue #49, daveb) + - Fix for freeing memory after unpacking bytes w/o a default-value. + (Andrei Nigmatulin) + - minor windows portability issues (use ProtobufC_FD) (Pop Stelian) + - --with-endianness={little,big} (Pop Stelian) + - bug setting up values of has_idle in public dispatch, + make protobuf_c_dispatch_run() use only public members (daveb) + - provide cmake support and some Windows compatibility (Nikita Manovich) + +protobuf-c (0.14) + - build fix (missing dependency in test directory) + - add generation / installation of pkg-config files. (Bobby Powers) + - support for packed repeated fields (Dave Benson) + - bug in protobuf_c_dispatch_close_fd(), which usually only + showed up in later function calls. + - support for deprecated fields -- enable a GCC warning + if a field has the "deprecated" option enabled. (Andrei Nigmatulin) + - hackery to try to avoid touching inttypes.h on windows (Issue #41) + - fix for protobuf_c_message_unpack() to issue error if any + "required" field is missing in input stream. (Andrei Nigmatulin) + +protobuf-c (0.13) + - Fix for when the number of connections gets too great in RPC. + (Leszek Swirski) (issue #32) + - Add --disable-protoc to only build libprotobuf-c (daveb) + - Bug fixes for protobuf_c_enum_descriptor_get_value_by_name() + and protobuf_c_service_descriptor_get_method_by_name() + - if descriptor->message_init != NULL, use it from unpack() + as an optimization (daveb) + - implement protobuf_c_{client,server}_set_error_handler() + +protobuf-c (0.12) + - for field names which are reserved words, use the real name + given in the protobuf-c file, not the mangled name which + is the name of the member in the C structure. (Andrei Nigmatulin) + - add protobuf_c_message_init() function; add virtual function + that implements it efficiently. (Andrei Nigmatulin) + - bug fix for sfixed32, fixed32, float wire-types on + big-endian platforms (Robert Edmonds) + - compile with the latest protobuf (the header file wire_format_inl.h + is now wire_format.h) (Robert Edmonds) + +protobuf-c (0.11) + - allow CFLAGS=-DPRINT_UNPACK_ERRORS=0 to suppress + unpack warnings from being printed at compile time (Andrei Nigmatulin) + - give error if an unknown wire-type is encountered (Andrei Nigmatulin) + - fix technically possible overflows during unpack of very + large messages (Andrei Nigmatulin) + - [UNFINISHED] windows RPC work + - use automake's "foreign" mode from within configure.ac + and add version information to the library (Robert Edmonds) + - ProtobufCServiceDescriptor::method_indices_by_name: missing + const. (Issue 21) + - Update to support new UnknownFields API. (fix by dcreager) (Issue 20) + +protobuf-c (0.10) + - build issue on platforms which don't compute library dependencies + automatically. + - fix for certain types of corrupt messages (Landon Fuller) (issue 16) + +protobuf-c (0.9) + - build issue: needed $(EXEEXT) in dependency lists for cygwin + - bug fix: protobuf_c_service_get_method_by_name() was not correct b/c + the service's methods were not sorted by name (the header file + used to incorrectly state that they were). + Now we correctly implement protobuf_c_service_get_method_by_name() + (using a bsearch indexed by separate array). + - generated source incompatibility: we added a new + member to ProtobufCServiceDescriptor (method_indices_by_name). + You will have to run the latest protobuf + to generate those structures. + - rename rpc-client's "autoretry" mechanism to "autoreconnect". + - bug fixes using TCP clients with the RPC system. + - handle allocation failures more gracefully (Jason Lunz) (issue 15) + +protobuf-c (0.8) + - Destroy function typedef for Services was omitting a "*" + - service_machgen_invoke was broken. (issue 12) + - add RPC system (BETA) + - don't segfault when packing NULL strings and messages. (issue 13) + +protobuf-c (0.7) + - memory leak: unknown fields were not being freed by free_unpacked() + - lowercase field names consistently when composing + default_value names. (issue 11) + - remove spurious semicolon (issue 10) + +protobuf-c (0.6) + - Warning suppression for -Wcast-qual and -Wshadow. + - Support for default values of all types allowed by core protobuf. + - Generate message__init functions, for when the static initializer + isn't convenient. + - add some reserved fields at the end of the various descriptors + +protobuf-c (0.5) + - License now included in major files. + - Use little-endian optimizations; fix a bug therein. + - Include 'make deb' target. + +protobuf-c (0.4) + - Update to work with protobuf 2.0.1. + +protobuf-c (0.2) +protobuf-c (0.3) + - Minor pedantic concerns about generated code. + +protobuf-c (0.1) + - Lots of test code (and bug fixes). + +protobuf-c (0.0) + - Initial release. diff --git a/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/Doxyfile.in b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/Doxyfile.in new file mode 100644 index 0000000..7d556ec --- /dev/null +++ b/SillyFilly-Hardware-Attack-Tool/slave_c5/main/common/protobuf-c/Doxyfile.in @@ -0,0 +1,2312 @@ +# Doxyfile 1.8.7 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "@PACKAGE@" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = @PACKAGE_VERSION@ + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = "@PACKAGE_DESCRIPTION@" + +# With the PROJECT_LOGO tag one can specify an logo or icon that is included in +# the documentation. The maximum height of the logo should not exceed 55 pixels +# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo +# to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = YES + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = NO + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = @top_srcdir@ + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a +# new page for each member. If set to NO, the documentation of a member will be +# part of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = YES + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, Javascript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: +# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: +# Fortran. In the later case the parser tries to guess whether the code is fixed +# or free formatted code, this is the default for Fortran type files), VHDL. For +# instance to make doxygen treat .inc files as Fortran files (default is PHP), +# and .f files as C (default is Fortran), use: inc=Fortran f=C. +# +# Note For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by by putting a % sign in front of the word +# or globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = YES + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO these classes will be included in the various overviews. This option has +# no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = NO + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = NO + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the +# todo list. This list is created by putting \todo commands in the +# documentation. +# The default value is: YES. + +GENERATE_TODOLIST = NO + +# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the +# test list. This list is created by putting \test commands in the +# documentation. +# The default value is: YES. + +GENERATE_TESTLIST = NO + +# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = NO + +# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES the list +# will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = NO + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = NO + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = @top_srcdir@/DoxygenLayout.xml + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. Do not use file names with spaces, bibtex cannot handle them. See +# also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = YES + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO doxygen will only warn about wrong or incomplete parameter +# documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = YES + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. +# Note: If this tag is empty the current directory is searched. + +INPUT = @DOXYGEN_INPUT@ + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank the +# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, +# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, +# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, +# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, +# *.qsf, *.as and *.js. + +FILE_PATTERNS = *.h + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = *private* + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER ) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES, then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = NO + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = NO + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- +# defined cascading style sheet that is included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefor more robust against future updates. +# Doxygen will copy the style sheet file to the output directory. For an example +# see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the stylesheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler ( hhc.exe). If non-empty +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated ( +# YES) or that it should be included in the master .chm file ( NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated ( +# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = YES + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = YES + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 0 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side Javascript for the rendering +# instead of using prerendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /