|
|
@@ -0,0 +1,939 @@
|
|
|
+/*
|
|
|
+ * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
|
|
|
+ *
|
|
|
+ * Permission to use, copy, modify, and/or distribute this software for
|
|
|
+ * any purpose with or without fee is hereby granted, provided that the
|
|
|
+ * above copyright notice and this permission notice appear in all
|
|
|
+ * copies.
|
|
|
+ *
|
|
|
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
|
|
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
|
|
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
|
|
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
|
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
|
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
+ * PERFORMANCE OF THIS SOFTWARE.
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * DOC: Implement parsing logic for action_oui strings, extract
|
|
|
+ * extensions and store them using linked list. Functions defined in
|
|
|
+ * this file can be accessed internally in action_oui component only.
|
|
|
+ */
|
|
|
+
|
|
|
+#include "wlan_action_oui_main.h"
|
|
|
+#include "wlan_action_oui_public_struct.h"
|
|
|
+#include "wlan_action_oui_tgt_api.h"
|
|
|
+#include "target_if_action_oui.h"
|
|
|
+#include <qdf_str.h>
|
|
|
+#include <wlan_utility.h>
|
|
|
+
|
|
|
+/**
|
|
|
+ * action_oui_string_to_hex() - convert string to uint8_t hex array
|
|
|
+ * @token - string to be converted
|
|
|
+ * @hex - output string to hold converted string
|
|
|
+ * @no_of_lengths - count of possible lengths for input string
|
|
|
+ * @possible_lengths - array holding possible lengths
|
|
|
+ *
|
|
|
+ * This function converts the continuous input string of even length and
|
|
|
+ * containing hexa decimal characters into hexa decimal array of uint8_t type.
|
|
|
+ * Input string needs to be NULL terminated and the length should match with
|
|
|
+ * one of entries in @possible_lengths
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool action_oui_string_to_hex(uint8_t *token, uint8_t *hex,
|
|
|
+ uint32_t no_of_lengths,
|
|
|
+ uint32_t *possible_lengths)
|
|
|
+{
|
|
|
+ uint32_t token_len = qdf_str_len(token);
|
|
|
+ uint32_t hex_str_len;
|
|
|
+ uint32_t i;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ if (!token_len || (token_len & 0x01)) {
|
|
|
+ action_oui_err("Token len is not multiple of 2");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (i = 0; i < no_of_lengths; i++)
|
|
|
+ if (token_len == possible_lengths[i])
|
|
|
+ break;
|
|
|
+
|
|
|
+ if (i == no_of_lengths) {
|
|
|
+ action_oui_err("Token len doesn't match with expected len");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ hex_str_len = token_len / 2;
|
|
|
+
|
|
|
+ ret = qdf_hex_str_to_binary(hex, token, hex_str_len);
|
|
|
+ if (ret) {
|
|
|
+ action_oui_err("Token doesn't contain hex digits");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * action_oui_token_string() - converts enum value to string
|
|
|
+ * token_id: enum value to be converted to string
|
|
|
+ *
|
|
|
+ * This function converts the enum value of type action_oui_token_type
|
|
|
+ * to string
|
|
|
+ *
|
|
|
+ * Return: converted string
|
|
|
+ */
|
|
|
+static
|
|
|
+uint8_t *action_oui_token_string(enum action_oui_token_type token_id)
|
|
|
+{
|
|
|
+ switch (token_id) {
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_DATA_LENGTH_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_DATA_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_DATA_MASK_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_INFO_MASK_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_MAC_ADDR_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_MAC_MASK_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_CAPABILITY_TOKEN);
|
|
|
+ CASE_RETURN_STRING(ACTION_OUI_END_TOKEN);
|
|
|
+ }
|
|
|
+
|
|
|
+ return (uint8_t *) "UNKNOWN";
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_oui() - validate and convert OUI str to hex array
|
|
|
+ * @token: OUI string
|
|
|
+ * @ext: pointer to container which holds converted hex array
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the OUI string for action OUI inis, convert them to hex array and store it
|
|
|
+ * in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static
|
|
|
+bool validate_and_convert_oui(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ bool valid;
|
|
|
+ uint32_t expected_token_len[2] = {6, 10};
|
|
|
+
|
|
|
+ valid = action_oui_string_to_hex(token, ext->oui, 2,
|
|
|
+ expected_token_len);
|
|
|
+ if (!valid)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ ext->oui_length = qdf_str_len(token) / 2;
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_DATA_LENGTH_TOKEN;
|
|
|
+
|
|
|
+ return valid;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_data_length() - validate data len str
|
|
|
+ * @token: data length string
|
|
|
+ * @ext: pointer to container which holds hex value formed from input str
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the data length string for action OUI inis, convert it to hex value and
|
|
|
+ * store it in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_data_length(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ uint32_t token_len = qdf_str_len(token);
|
|
|
+ int ret;
|
|
|
+ uint8_t len = 0;
|
|
|
+
|
|
|
+ if (token_len != 1 && token_len != 2) {
|
|
|
+ action_oui_err("Invalid str token len for action OUI data len");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ ret = kstrtou8(token, 16, &len);
|
|
|
+ if (ret) {
|
|
|
+ action_oui_err("Invalid char in action OUI data len str token");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((uint32_t)len > ACTION_OUI_MAX_DATA_LENGTH) {
|
|
|
+ action_oui_err("action OUI data len is more than %u",
|
|
|
+ ACTION_OUI_MAX_DATA_LENGTH);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ ext->data_length = len;
|
|
|
+
|
|
|
+ if (!ext->data_length)
|
|
|
+ *action_token = ACTION_OUI_INFO_MASK_TOKEN;
|
|
|
+ else
|
|
|
+ *action_token = ACTION_OUI_DATA_TOKEN;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_data() - validate and convert data str to hex array
|
|
|
+ * @token: data string
|
|
|
+ * @ext: pointer to container which holds converted hex array
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the data string for action OUI inis, convert it to hex array and store in
|
|
|
+ * action_oui extension. After successful parsing update the @action_token
|
|
|
+ * to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_data(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ bool valid;
|
|
|
+ uint32_t expected_token_len[1] = {2 * ext->data_length};
|
|
|
+
|
|
|
+ valid = action_oui_string_to_hex(token, ext->data, 1,
|
|
|
+ expected_token_len);
|
|
|
+ if (!valid)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_DATA_MASK_TOKEN;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_data_mask() - validate and convert data mask str
|
|
|
+ * @token: data mask string
|
|
|
+ * @ext: pointer to container which holds converted hex array
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the data mask string for action OUI inis, convert it to hex array and store
|
|
|
+ * in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_data_mask(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ bool valid;
|
|
|
+ uint32_t expected_token_len[1];
|
|
|
+ uint32_t data_mask_length;
|
|
|
+ uint32_t data_length = ext->data_length;
|
|
|
+
|
|
|
+ if (data_length % 8 == 0)
|
|
|
+ data_mask_length = data_length / 8;
|
|
|
+ else
|
|
|
+ data_mask_length = ((data_length / 8) + 1);
|
|
|
+
|
|
|
+ if (data_mask_length > ACTION_OUI_MAX_DATA_MASK_LENGTH)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ expected_token_len[0] = 2 * data_mask_length;
|
|
|
+
|
|
|
+ valid = action_oui_string_to_hex(token, ext->data_mask, 1,
|
|
|
+ expected_token_len);
|
|
|
+ if (!valid)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ ext->data_mask_length = data_mask_length;
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_INFO_MASK_TOKEN;
|
|
|
+
|
|
|
+ return valid;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_info_mask() - validate and convert info mask str
|
|
|
+ * @token: info mask string
|
|
|
+ * @ext: pointer to container which holds converted hex array
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the info mask string for action OUI inis, convert it to hex array and store
|
|
|
+ * in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_info_mask(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ uint32_t token_len = qdf_str_len(token);
|
|
|
+ uint8_t hex_value = 0;
|
|
|
+ uint32_t info_mask;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ if (token_len != 2) {
|
|
|
+ action_oui_err("action OUI info mask str token len is not of 2 chars");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ ret = kstrtou8(token, 16, &hex_value);
|
|
|
+ if (ret) {
|
|
|
+ action_oui_err("Invalid char in action OUI info mask str token");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ info_mask = hex_value;
|
|
|
+
|
|
|
+ info_mask |= ACTION_OUI_INFO_OUI;
|
|
|
+ ext->info_mask = info_mask;
|
|
|
+
|
|
|
+ if (!info_mask || !(info_mask & ~ACTION_OUI_INFO_OUI)) {
|
|
|
+ *action_token = ACTION_OUI_END_TOKEN;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (info_mask & ~ACTION_OUI_INFO_MASK) {
|
|
|
+ action_oui_err("Invalid bits are set in action OUI info mask");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (info_mask & ACTION_OUI_INFO_MAC_ADDRESS) {
|
|
|
+ *action_token = ACTION_OUI_MAC_ADDR_TOKEN;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_CAPABILITY_TOKEN;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_mac_addr() - validate and convert mac addr str
|
|
|
+ * @token: mac address string
|
|
|
+ * @ext: pointer to container which holds converted hex array
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the mac address string for action OUI inis, convert it to hex array and store
|
|
|
+ * in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_mac_addr(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ uint32_t expected_token_len[1] = {2 * QDF_MAC_ADDR_SIZE};
|
|
|
+ bool valid;
|
|
|
+
|
|
|
+ valid = action_oui_string_to_hex(token, ext->mac_addr, 1,
|
|
|
+ expected_token_len);
|
|
|
+ if (!valid)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ ext->mac_addr_length = QDF_MAC_ADDR_SIZE;
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_MAC_MASK_TOKEN;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_mac_mask() - validate and convert mac mask
|
|
|
+ * @token: mac mask string
|
|
|
+ * @ext: pointer to container which holds converted hex value
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the mac mask string for action OUI inis, convert it to hex value and store
|
|
|
+ * in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_mac_mask(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ uint32_t expected_token_len[1] = {2};
|
|
|
+ uint32_t info_mask = ext->info_mask;
|
|
|
+ bool valid;
|
|
|
+ uint32_t mac_mask_length;
|
|
|
+
|
|
|
+ valid = action_oui_string_to_hex(token, ext->mac_mask, 1,
|
|
|
+ expected_token_len);
|
|
|
+ if (!valid)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ mac_mask_length = qdf_str_len(token) / 2;
|
|
|
+ if (mac_mask_length > ACTION_OUI_MAC_MASK_LENGTH) {
|
|
|
+ action_oui_err("action OUI mac mask str token len is more than %u chars",
|
|
|
+ expected_token_len[0]);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ ext->mac_mask_length = mac_mask_length;
|
|
|
+
|
|
|
+ if ((info_mask & ACTION_OUI_INFO_AP_CAPABILITY_NSS) ||
|
|
|
+ (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_HT) ||
|
|
|
+ (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_VHT) ||
|
|
|
+ (info_mask & ACTION_OUI_INFO_AP_CAPABILITY_BAND)) {
|
|
|
+ *action_token = ACTION_OUI_CAPABILITY_TOKEN;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_END_TOKEN;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * validate_and_convert_capability() - validate and convert capability str
|
|
|
+ * @token: capability string
|
|
|
+ * @ext: pointer to container which holds converted hex value
|
|
|
+ * @action_token: next action to be parsed
|
|
|
+ *
|
|
|
+ * This is an internal function invoked from action_oui_parse to validate
|
|
|
+ * the capability string for action OUI inis, convert it to hex value and store
|
|
|
+ * in action_oui extension. After successful parsing update the
|
|
|
+ * @action_token to hold the next expected string.
|
|
|
+ *
|
|
|
+ * Return: If conversion is successful return true else false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+validate_and_convert_capability(uint8_t *token,
|
|
|
+ struct action_oui_extension *ext,
|
|
|
+ enum action_oui_token_type *action_token)
|
|
|
+{
|
|
|
+ uint32_t expected_token_len[1] = {2};
|
|
|
+ uint32_t info_mask = ext->info_mask;
|
|
|
+ uint32_t capability_length;
|
|
|
+ uint8_t caps_0;
|
|
|
+ bool valid;
|
|
|
+
|
|
|
+ valid = action_oui_string_to_hex(token, ext->capability, 1,
|
|
|
+ expected_token_len);
|
|
|
+ if (!valid)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ capability_length = qdf_str_len(token) / 2;
|
|
|
+ if (capability_length > ACTION_OUI_MAX_CAPABILITY_LENGTH) {
|
|
|
+ action_oui_err("action OUI capability str token len is more than %u chars",
|
|
|
+ expected_token_len[0]);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ caps_0 = ext->capability[0];
|
|
|
+
|
|
|
+ if ((info_mask & ACTION_OUI_INFO_AP_CAPABILITY_NSS) &&
|
|
|
+ (!(caps_0 & ACTION_OUI_CAPABILITY_NSS_MASK))) {
|
|
|
+ action_oui_err("Info presence for NSS is set but respective bits in capability are not set");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((info_mask & ACTION_OUI_INFO_AP_CAPABILITY_BAND) &&
|
|
|
+ (!(caps_0 & ACTION_OUI_CAPABILITY_BAND_MASK))) {
|
|
|
+ action_oui_err("Info presence for BAND is set but respective bits in capability are not set");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ ext->capability_length = capability_length;
|
|
|
+
|
|
|
+ *action_token = ACTION_OUI_END_TOKEN;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * action_oui_extension_store() - store action oui extension
|
|
|
+ * @priv_obj: pointer to action_oui priv obj
|
|
|
+ * @oui_priv: type of the action
|
|
|
+ * @ext: oui extension to store in sme
|
|
|
+ *
|
|
|
+ * This function stores the parsed oui extension
|
|
|
+ *
|
|
|
+ * Return: QDF_STATUS
|
|
|
+ *
|
|
|
+ */
|
|
|
+static QDF_STATUS
|
|
|
+action_oui_extension_store(struct action_oui_psoc_priv *psoc_priv,
|
|
|
+ struct action_oui_priv *oui_priv,
|
|
|
+ struct action_oui_extension ext)
|
|
|
+{
|
|
|
+ struct action_oui_extension_priv *ext_priv;
|
|
|
+
|
|
|
+ qdf_mutex_acquire(&oui_priv->extension_lock);
|
|
|
+ if (qdf_list_size(&oui_priv->extension_list) ==
|
|
|
+ ACTION_OUI_MAX_EXTENSIONS) {
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ action_oui_err("Reached maximum OUI extensions");
|
|
|
+ return QDF_STATUS_E_FAILURE;
|
|
|
+ }
|
|
|
+
|
|
|
+ ext_priv = qdf_mem_malloc(sizeof(*ext_priv));
|
|
|
+ if (!ext_priv) {
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ action_oui_err("Failed to allocate memory for action oui extension priv");
|
|
|
+ return QDF_STATUS_E_NOMEM;
|
|
|
+ }
|
|
|
+
|
|
|
+ ext_priv->extension = ext;
|
|
|
+ qdf_list_insert_back(&oui_priv->extension_list, &ext_priv->item);
|
|
|
+ psoc_priv->total_extensions++;
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+QDF_STATUS
|
|
|
+action_oui_parse(struct action_oui_psoc_priv *psoc_priv,
|
|
|
+ uint8_t *oui_string, enum action_oui_id action_id)
|
|
|
+{
|
|
|
+ struct action_oui_extension ext = {0};
|
|
|
+ enum action_oui_token_type action_token = ACTION_OUI_TOKEN;
|
|
|
+ char *str1;
|
|
|
+ char *str2;
|
|
|
+ char *token;
|
|
|
+ bool valid = true;
|
|
|
+ bool oui_count_exceed = false;
|
|
|
+ uint32_t oui_index = 0;
|
|
|
+ QDF_STATUS status = QDF_STATUS_SUCCESS;
|
|
|
+ struct action_oui_priv *oui_priv;
|
|
|
+
|
|
|
+ if (!oui_string) {
|
|
|
+ action_oui_err("Invalid string for action oui: %u", action_id);
|
|
|
+ return QDF_STATUS_E_INVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ oui_priv = psoc_priv->oui_priv[action_id];
|
|
|
+ if (!oui_priv) {
|
|
|
+ action_oui_err("action oui priv not allocated");
|
|
|
+ return QDF_STATUS_E_INVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ str1 = qdf_str_trim((char *)oui_string);
|
|
|
+
|
|
|
+ while (str1) {
|
|
|
+ str2 = skip_spaces(str1);
|
|
|
+ if (str2[0] == '\0') {
|
|
|
+ action_oui_err("Invalid spaces in action oui: %u at extension: %u for token: %s",
|
|
|
+ action_id,
|
|
|
+ oui_index + 1,
|
|
|
+ action_oui_token_string(action_token));
|
|
|
+ valid = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ token = strsep(&str2, " ");
|
|
|
+ if (!token) {
|
|
|
+ action_oui_err("Invalid string for token: %s at extension: %u in action oui: %u",
|
|
|
+ action_oui_token_string(action_token),
|
|
|
+ oui_index + 1, action_id);
|
|
|
+ valid = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ str1 = str2;
|
|
|
+
|
|
|
+ switch (action_token) {
|
|
|
+
|
|
|
+ case ACTION_OUI_TOKEN:
|
|
|
+ valid = validate_and_convert_oui(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_DATA_LENGTH_TOKEN:
|
|
|
+ valid = validate_and_convert_data_length(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_DATA_TOKEN:
|
|
|
+ valid = validate_and_convert_data(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_DATA_MASK_TOKEN:
|
|
|
+ valid = validate_and_convert_data_mask(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_INFO_MASK_TOKEN:
|
|
|
+ valid = validate_and_convert_info_mask(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_MAC_ADDR_TOKEN:
|
|
|
+ valid = validate_and_convert_mac_addr(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_MAC_MASK_TOKEN:
|
|
|
+ valid = validate_and_convert_mac_mask(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ACTION_OUI_CAPABILITY_TOKEN:
|
|
|
+ valid = validate_and_convert_capability(token, &ext,
|
|
|
+ &action_token);
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ valid = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!valid) {
|
|
|
+ action_oui_err("Invalid string for token: %s at extension: %u in action oui: %u",
|
|
|
+ action_oui_token_string(action_token),
|
|
|
+ oui_index + 1,
|
|
|
+ action_id);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (action_token != ACTION_OUI_END_TOKEN)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ status = action_oui_extension_store(psoc_priv, oui_priv, ext);
|
|
|
+ if (!QDF_IS_STATUS_SUCCESS(status)) {
|
|
|
+ valid = false;
|
|
|
+ action_oui_err("sme set of extension: %u for action oui: %u failed",
|
|
|
+ oui_index + 1, action_id);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ oui_index++;
|
|
|
+ if (oui_index == ACTION_OUI_MAX_EXTENSIONS) {
|
|
|
+ if (str1)
|
|
|
+ oui_count_exceed = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* reset the params for next action OUI parse */
|
|
|
+ action_token = ACTION_OUI_TOKEN;
|
|
|
+ qdf_mem_zero(&ext, sizeof(ext));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (oui_count_exceed) {
|
|
|
+ action_oui_err("Reached Maximum extensions: %u in action_oui: %u, ignoring the rest",
|
|
|
+ ACTION_OUI_MAX_EXTENSIONS, action_id);
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (action_token != ACTION_OUI_TOKEN &&
|
|
|
+ action_token != ACTION_OUI_END_TOKEN &&
|
|
|
+ valid && !str1) {
|
|
|
+ action_oui_err("No string for token: %s at extension: %u in action oui: %u",
|
|
|
+ action_oui_token_string(action_token),
|
|
|
+ oui_index + 1,
|
|
|
+ action_id);
|
|
|
+ valid = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!oui_index) {
|
|
|
+ action_oui_err("Not able to parse any extension in action oui: %u",
|
|
|
+ action_id);
|
|
|
+ return QDF_STATUS_E_INVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (valid)
|
|
|
+ action_oui_debug("All extensions: %u parsed successfully in action oui: %u",
|
|
|
+ oui_index, action_id);
|
|
|
+ else
|
|
|
+ action_oui_err("First %u extensions parsed successfully in action oui: %u",
|
|
|
+ oui_index, action_id);
|
|
|
+
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+QDF_STATUS action_oui_send(struct action_oui_psoc_priv *psoc_priv,
|
|
|
+ enum action_oui_id action_id)
|
|
|
+{
|
|
|
+ QDF_STATUS status;
|
|
|
+ struct action_oui_request *req;
|
|
|
+ struct action_oui_priv *oui_priv;
|
|
|
+ struct action_oui_extension *extension;
|
|
|
+ struct action_oui_extension_priv *ext_priv;
|
|
|
+ qdf_list_node_t *node = NULL;
|
|
|
+ qdf_list_node_t *next_node = NULL;
|
|
|
+ qdf_list_t *extension_list;
|
|
|
+ uint32_t len;
|
|
|
+ uint32_t no_oui_extensions;
|
|
|
+
|
|
|
+ oui_priv = psoc_priv->oui_priv[action_id];
|
|
|
+ if (!oui_priv)
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+
|
|
|
+ extension_list = &oui_priv->extension_list;
|
|
|
+ qdf_mutex_acquire(&oui_priv->extension_lock);
|
|
|
+ if (qdf_list_empty(extension_list)) {
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+ }
|
|
|
+
|
|
|
+ no_oui_extensions = qdf_list_size(extension_list);
|
|
|
+ len = sizeof(*req) + no_oui_extensions * sizeof(*extension);
|
|
|
+ req = qdf_mem_malloc(len);
|
|
|
+ if (!req) {
|
|
|
+ action_oui_err("Failed to allocate memory for action_oui");
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ return QDF_STATUS_E_NOMEM;
|
|
|
+ }
|
|
|
+
|
|
|
+ req->action_id = oui_priv->id;
|
|
|
+ req->no_oui_extensions = no_oui_extensions;
|
|
|
+ req->total_no_oui_extensions = psoc_priv->total_extensions;
|
|
|
+
|
|
|
+ extension = req->extension;
|
|
|
+ qdf_list_peek_front(extension_list, &node);
|
|
|
+ while (node) {
|
|
|
+ ext_priv = qdf_container_of(node,
|
|
|
+ struct action_oui_extension_priv,
|
|
|
+ item);
|
|
|
+ *extension = ext_priv->extension;
|
|
|
+ status = qdf_list_peek_next(extension_list, node,
|
|
|
+ &next_node);
|
|
|
+ if (!QDF_IS_STATUS_SUCCESS(status))
|
|
|
+ break;
|
|
|
+ node = next_node;
|
|
|
+ next_node = NULL;
|
|
|
+ extension++;
|
|
|
+ }
|
|
|
+
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+
|
|
|
+ status = tgt_action_oui_send(psoc_priv->psoc, req);
|
|
|
+ qdf_mem_free(req);
|
|
|
+
|
|
|
+ return status;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * check_for_vendor_oui_data() - compares for vendor OUI data from IE
|
|
|
+ * and returns true if OUI data matches with the ini
|
|
|
+ * @extension: pointer to action oui extension data
|
|
|
+ * @oui_ptr: pointer to Vendor IE in the beacon
|
|
|
+ *
|
|
|
+ * Return: true or false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+check_for_vendor_oui_data(struct action_oui_extension *extension,
|
|
|
+ const uint8_t *oui_ptr)
|
|
|
+{
|
|
|
+ const uint8_t *data;
|
|
|
+ uint8_t i, j, elem_len, data_len;
|
|
|
+ uint8_t data_mask = 0x80;
|
|
|
+
|
|
|
+ elem_len = oui_ptr[1];
|
|
|
+ if (elem_len < extension->oui_length)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ data_len = elem_len - extension->oui_length;
|
|
|
+ if (data_len < extension->data_length)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ data = &oui_ptr[2 + extension->oui_length];
|
|
|
+ for (i = 0, j = 0;
|
|
|
+ (i < data_len && j < extension->data_mask_length);
|
|
|
+ i++) {
|
|
|
+ if ((extension->data_mask[j] & data_mask) &&
|
|
|
+ !(extension->data[i] == data[i]))
|
|
|
+ return false;
|
|
|
+ data_mask = data_mask >> 1;
|
|
|
+ if (!data_mask) {
|
|
|
+ data_mask = 0x80;
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * check_for_vendor_ap_mac() - compares for vendor AP MAC in the ini with
|
|
|
+ * bssid from the session and returns true if matches
|
|
|
+ * @extension: pointer to action oui extension data
|
|
|
+ * @attr: pointer to structure containing mac_addr (bssid) of AP
|
|
|
+ *
|
|
|
+ * Return: true or false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+check_for_vendor_ap_mac(struct action_oui_extension *extension,
|
|
|
+ struct action_oui_search_attr *attr)
|
|
|
+{
|
|
|
+ uint8_t i;
|
|
|
+ uint8_t mac_mask = 0x80;
|
|
|
+ uint8_t *mac_addr = attr->mac_addr;
|
|
|
+
|
|
|
+ for (i = 0; i < QDF_MAC_ADDR_SIZE; i++) {
|
|
|
+ if ((*extension->mac_mask & mac_mask) &&
|
|
|
+ !(extension->mac_addr[i] == mac_addr[i]))
|
|
|
+ return false;
|
|
|
+ mac_mask = mac_mask >> 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * check_for_vendor_ap_capabilities() - Compares various Vendor AP
|
|
|
+ * capabilities like NSS, HT, VHT, Band from the ini with the AP's capability
|
|
|
+ * from the beacon and returns true if all the capability matches
|
|
|
+ * @extension: pointer to oui extension data
|
|
|
+ * @attr: pointer to structure containing type of action, ap capabilities
|
|
|
+ *
|
|
|
+ * Return: true or false
|
|
|
+ */
|
|
|
+static bool
|
|
|
+check_for_vendor_ap_capabilities(struct action_oui_extension *extension,
|
|
|
+ struct action_oui_search_attr *attr)
|
|
|
+{
|
|
|
+ uint8_t nss_mask;
|
|
|
+
|
|
|
+ if (extension->info_mask & ACTION_OUI_INFO_AP_CAPABILITY_NSS) {
|
|
|
+ nss_mask = 1 << (attr->nss - 1);
|
|
|
+ if (!((*extension->capability &
|
|
|
+ ACTION_OUI_CAPABILITY_NSS_MASK) &
|
|
|
+ nss_mask))
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (extension->info_mask & ACTION_OUI_INFO_AP_CAPABILITY_HT) {
|
|
|
+ if (*extension->capability &
|
|
|
+ ACTION_OUI_CAPABILITY_HT_ENABLE_MASK) {
|
|
|
+ if (!attr->ht_cap)
|
|
|
+ return false;
|
|
|
+ } else {
|
|
|
+ if (attr->ht_cap)
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (extension->info_mask & ACTION_OUI_INFO_AP_CAPABILITY_VHT) {
|
|
|
+ if (*extension->capability &
|
|
|
+ ACTION_OUI_CAPABILITY_VHT_ENABLE_MASK) {
|
|
|
+ if (!attr->vht_cap)
|
|
|
+ return false;
|
|
|
+ } else {
|
|
|
+ if (attr->vht_cap)
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (extension->info_mask & ACTION_OUI_INFO_AP_CAPABILITY_BAND) {
|
|
|
+ if ((*extension->capability &
|
|
|
+ ACTION_OUI_CAPABILITY_2G_BAND_MASK) &&
|
|
|
+ !attr->enable_2g)
|
|
|
+ return false;
|
|
|
+ if ((*extension->capability &
|
|
|
+ ACTION_CAPABILITY_5G_BAND_MASK) &&
|
|
|
+ !attr->enable_5g)
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+bool
|
|
|
+action_oui_search(struct action_oui_psoc_priv *psoc_priv,
|
|
|
+ struct action_oui_search_attr *attr,
|
|
|
+ enum action_oui_id action_id)
|
|
|
+{
|
|
|
+ struct action_oui_priv *oui_priv;
|
|
|
+ struct action_oui_extension_priv *priv_ext;
|
|
|
+ struct action_oui_extension *extension;
|
|
|
+ qdf_list_node_t *node = NULL;
|
|
|
+ qdf_list_node_t *next_node = NULL;
|
|
|
+ qdf_list_t *extension_list;
|
|
|
+ QDF_STATUS qdf_status;
|
|
|
+ const uint8_t *oui_ptr;
|
|
|
+
|
|
|
+ oui_priv = psoc_priv->oui_priv[action_id];
|
|
|
+ if (!oui_priv) {
|
|
|
+ action_oui_debug("action oui for id %d is empty",
|
|
|
+ action_id);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ extension_list = &oui_priv->extension_list;
|
|
|
+ qdf_mutex_acquire(&oui_priv->extension_lock);
|
|
|
+ if (qdf_list_empty(extension_list)) {
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ action_oui_debug("OUI List Empty");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ qdf_list_peek_front(extension_list, &node);
|
|
|
+ while (node) {
|
|
|
+ priv_ext = qdf_container_of(node,
|
|
|
+ struct action_oui_extension_priv,
|
|
|
+ item);
|
|
|
+ extension = &priv_ext->extension;
|
|
|
+ oui_ptr = wlan_get_vendor_ie_ptr_from_oui(extension->oui,
|
|
|
+ extension->oui_length,
|
|
|
+ attr->ie_data,
|
|
|
+ attr->ie_length);
|
|
|
+ if (!oui_ptr) {
|
|
|
+ action_oui_debug("No matching IE found for OUI");
|
|
|
+ QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE,
|
|
|
+ QDF_TRACE_LEVEL_DEBUG,
|
|
|
+ extension->oui,
|
|
|
+ extension->oui_length);
|
|
|
+ goto next;
|
|
|
+ }
|
|
|
+
|
|
|
+ action_oui_debug("IE found for OUI");
|
|
|
+ QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE,
|
|
|
+ QDF_TRACE_LEVEL_DEBUG,
|
|
|
+ extension->oui,
|
|
|
+ extension->oui_length);
|
|
|
+
|
|
|
+ if (extension->data_length &&
|
|
|
+ !check_for_vendor_oui_data(extension, oui_ptr)) {
|
|
|
+ action_oui_debug("Vendor IE Data mismatch");
|
|
|
+ goto next;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((extension->info_mask & ACTION_OUI_INFO_MAC_ADDRESS) &&
|
|
|
+ !check_for_vendor_ap_mac(extension, attr)) {
|
|
|
+ action_oui_debug("Vendor IE MAC Mismatch");
|
|
|
+ goto next;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!check_for_vendor_ap_capabilities(extension, attr)) {
|
|
|
+ action_oui_debug("Vendor IE capabilties mismatch");
|
|
|
+ goto next;
|
|
|
+ }
|
|
|
+
|
|
|
+ action_oui_debug("Vendor AP found for OUI");
|
|
|
+ QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG,
|
|
|
+ extension->oui, extension->oui_length);
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ return true;
|
|
|
+next:
|
|
|
+ qdf_status = qdf_list_peek_next(extension_list,
|
|
|
+ node, &next_node);
|
|
|
+ if (!QDF_IS_STATUS_SUCCESS(qdf_status))
|
|
|
+ break;
|
|
|
+
|
|
|
+ node = next_node;
|
|
|
+ next_node = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ qdf_mutex_release(&oui_priv->extension_lock);
|
|
|
+ return false;
|
|
|
+}
|
Rajeev Kumar Sirasanagandla