/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "sync.h" #include #include "wifi_hal.h" #include "nan_i.h" #include "nancommand.h" wifi_error NanCommand::putNanEnable(transaction_id id, const NanEnableRequest *pReq) { wifi_error ret; ALOGV("NAN_ENABLE"); size_t message_len = NAN_MAX_ENABLE_REQ_SIZE; if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } message_len += \ ( pReq->config_support_5g ? (SIZEOF_TLV_HDR + \ sizeof(pReq->support_5g_val)) : 0 \ ) + \ ( pReq->config_sid_beacon ? (SIZEOF_TLV_HDR + \ sizeof(pReq->sid_beacon_val)) : 0 \ ) + \ ( pReq->config_2dot4g_rssi_close ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_close_2dot4g_val)) : 0 \ ) + \ ( pReq->config_2dot4g_rssi_middle ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_middle_2dot4g_val)) : 0 \ ) + \ ( pReq->config_hop_count_limit ? (SIZEOF_TLV_HDR + \ sizeof(pReq->hop_count_limit_val)) : 0 \ ) + \ ( pReq->config_2dot4g_support ? (SIZEOF_TLV_HDR + \ sizeof(pReq->support_2dot4g_val)) : 0 \ ) + \ ( pReq->config_2dot4g_beacons ? (SIZEOF_TLV_HDR + \ sizeof(pReq->beacon_2dot4g_val)) : 0 \ ) + \ ( pReq->config_2dot4g_sdf ? (SIZEOF_TLV_HDR + \ sizeof(pReq->sdf_2dot4g_val)) : 0 \ ) + \ ( pReq->config_5g_beacons ? (SIZEOF_TLV_HDR + \ sizeof(pReq->beacon_5g_val)) : 0 \ ) + \ ( pReq->config_5g_sdf ? (SIZEOF_TLV_HDR + \ sizeof(pReq->sdf_5g_val)) : 0 \ ) + \ ( pReq->config_5g_rssi_close ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_close_5g_val)) : 0 \ ) + \ ( pReq->config_5g_rssi_middle ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_middle_5g_val)) : 0 \ ) + \ ( pReq->config_2dot4g_rssi_proximity ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_proximity_2dot4g_val)) : 0 \ ) + \ ( pReq->config_5g_rssi_close_proximity ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_close_proximity_5g_val)) : 0 \ ) + \ ( pReq->config_rssi_window_size ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_window_size_val)) : 0 \ ) + \ ( pReq->config_oui ? (SIZEOF_TLV_HDR + \ sizeof(pReq->oui_val)) : 0 \ ) + \ ( pReq->config_intf_addr ? (SIZEOF_TLV_HDR + \ sizeof(pReq->intf_addr_val)) : 0 \ ) + \ ( pReq->config_cluster_attribute_val ? (SIZEOF_TLV_HDR + \ sizeof(pReq->config_cluster_attribute_val)) : 0 \ ) + \ ( pReq->config_scan_params ? NAN_MAX_SOCIAL_CHANNELS * (SIZEOF_TLV_HDR + sizeof(u32)) : 0 \ ) + \ ( pReq->config_random_factor_force ? (SIZEOF_TLV_HDR + \ sizeof(pReq->random_factor_force_val)) : 0 \ ) + \ ( pReq->config_hop_count_force ? (SIZEOF_TLV_HDR + \ sizeof(pReq->hop_count_force_val)) : 0 \ ) + \ ( pReq->config_24g_channel ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_5g_channel ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_dw.config_2dot4g_dw_band ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_dw.config_5g_dw_band ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_disc_mac_addr_randomization ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( /* Always include cfg discovery indication TLV */ SIZEOF_TLV_HDR + sizeof(u32) \ ) + \ ( pReq->config_subscribe_sid_beacon ? (SIZEOF_TLV_HDR + \ sizeof(pReq->subscribe_sid_beacon_val)) : 0 \ ) + \ ( pReq->config_discovery_beacon_int ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_nss ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_enable_ranging ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_dw_early_termination ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ); pNanEnableReqMsg pFwReq = (pNanEnableReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset (pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_ENABLE_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; u8* tlvs = pFwReq->ptlv; /* Write the TLVs to the message. */ tlvs = addTlv(NAN_TLV_TYPE_CLUSTER_ID_LOW, sizeof(pReq->cluster_low), (const u8*)&pReq->cluster_low, tlvs); tlvs = addTlv(NAN_TLV_TYPE_CLUSTER_ID_HIGH, sizeof(pReq->cluster_high), (const u8*)&pReq->cluster_high, tlvs); tlvs = addTlv(NAN_TLV_TYPE_MASTER_PREFERENCE, sizeof(pReq->master_pref), (const u8*)&pReq->master_pref, tlvs); if (pReq->config_support_5g) { tlvs = addTlv(NAN_TLV_TYPE_5G_SUPPORT, sizeof(pReq->support_5g_val), (const u8*)&pReq->support_5g_val, tlvs); } if (pReq->config_sid_beacon) { tlvs = addTlv(NAN_TLV_TYPE_SID_BEACON, sizeof(pReq->sid_beacon_val), (const u8*)&pReq->sid_beacon_val, tlvs); } if (pReq->config_2dot4g_rssi_close) { tlvs = addTlv(NAN_TLV_TYPE_24G_RSSI_CLOSE, sizeof(pReq->rssi_close_2dot4g_val), (const u8*)&pReq->rssi_close_2dot4g_val, tlvs); } if (pReq->config_2dot4g_rssi_middle) { tlvs = addTlv(NAN_TLV_TYPE_24G_RSSI_MIDDLE, sizeof(pReq->rssi_middle_2dot4g_val), (const u8*)&pReq->rssi_middle_2dot4g_val, tlvs); } if (pReq->config_hop_count_limit) { tlvs = addTlv(NAN_TLV_TYPE_HOP_COUNT_LIMIT, sizeof(pReq->hop_count_limit_val), (const u8*)&pReq->hop_count_limit_val, tlvs); } if (pReq->config_2dot4g_support) { tlvs = addTlv(NAN_TLV_TYPE_24G_SUPPORT, sizeof(pReq->support_2dot4g_val), (const u8*)&pReq->support_2dot4g_val, tlvs); } if (pReq->config_2dot4g_beacons) { tlvs = addTlv(NAN_TLV_TYPE_24G_BEACON, sizeof(pReq->beacon_2dot4g_val), (const u8*)&pReq->beacon_2dot4g_val, tlvs); } if (pReq->config_2dot4g_sdf) { tlvs = addTlv(NAN_TLV_TYPE_24G_SDF, sizeof(pReq->sdf_2dot4g_val), (const u8*)&pReq->sdf_2dot4g_val, tlvs); } if (pReq->config_5g_beacons) { tlvs = addTlv(NAN_TLV_TYPE_5G_BEACON, sizeof(pReq->beacon_5g_val), (const u8*)&pReq->beacon_5g_val, tlvs); } if (pReq->config_5g_sdf) { tlvs = addTlv(NAN_TLV_TYPE_5G_SDF, sizeof(pReq->sdf_5g_val), (const u8*)&pReq->sdf_5g_val, tlvs); } if (pReq->config_2dot4g_rssi_proximity) { tlvs = addTlv(NAN_TLV_TYPE_24G_RSSI_CLOSE_PROXIMITY, sizeof(pReq->rssi_proximity_2dot4g_val), (const u8*)&pReq->rssi_proximity_2dot4g_val, tlvs); } /* Add the support of sending 5G RSSI values */ if (pReq->config_5g_rssi_close) { tlvs = addTlv(NAN_TLV_TYPE_5G_RSSI_CLOSE, sizeof(pReq->rssi_close_5g_val), (const u8*)&pReq->rssi_close_5g_val, tlvs); } if (pReq->config_5g_rssi_middle) { tlvs = addTlv(NAN_TLV_TYPE_5G_RSSI_MIDDLE, sizeof(pReq->rssi_middle_5g_val), (const u8*)&pReq->rssi_middle_5g_val, tlvs); } if (pReq->config_5g_rssi_close_proximity) { tlvs = addTlv(NAN_TLV_TYPE_5G_RSSI_CLOSE_PROXIMITY, sizeof(pReq->rssi_close_proximity_5g_val), (const u8*)&pReq->rssi_close_proximity_5g_val, tlvs); } if (pReq->config_rssi_window_size) { tlvs = addTlv(NAN_TLV_TYPE_RSSI_AVERAGING_WINDOW_SIZE, sizeof(pReq->rssi_window_size_val), (const u8*)&pReq->rssi_window_size_val, tlvs); } if (pReq->config_oui) { tlvs = addTlv(NAN_TLV_TYPE_CLUSTER_OUI_NETWORK_ID, sizeof(pReq->oui_val), (const u8*)&pReq->oui_val, tlvs); } if (pReq->config_intf_addr) { tlvs = addTlv(NAN_TLV_TYPE_SOURCE_MAC_ADDRESS, sizeof(pReq->intf_addr_val), (const u8*)&pReq->intf_addr_val[0], tlvs); } if (pReq->config_cluster_attribute_val) { tlvs = addTlv(NAN_TLV_TYPE_CLUSTER_ATTRIBUTE_IN_SDF, sizeof(pReq->config_cluster_attribute_val), (const u8*)&pReq->config_cluster_attribute_val, tlvs); } if (pReq->config_scan_params) { u32 socialChannelParamVal[NAN_MAX_SOCIAL_CHANNELS]; /* Fill the social channel param */ fillNanSocialChannelParamVal(&pReq->scan_params_val, socialChannelParamVal); int i; for (i = 0; i < NAN_MAX_SOCIAL_CHANNELS; i++) { tlvs = addTlv(NAN_TLV_TYPE_SOCIAL_CHANNEL_SCAN_PARAMS, sizeof(socialChannelParamVal[i]), (const u8*)&socialChannelParamVal[i], tlvs); } } if (pReq->config_random_factor_force) { tlvs = addTlv(NAN_TLV_TYPE_RANDOM_FACTOR_FORCE, sizeof(pReq->random_factor_force_val), (const u8*)&pReq->random_factor_force_val, tlvs); } if (pReq->config_hop_count_force) { tlvs = addTlv(NAN_TLV_TYPE_HOP_COUNT_FORCE, sizeof(pReq->hop_count_force_val), (const u8*)&pReq->hop_count_force_val, tlvs); } if (pReq->config_24g_channel) { tlvs = addTlv(NAN_TLV_TYPE_24G_CHANNEL, sizeof(u32), (const u8*)&pReq->channel_24g_val, tlvs); } if (pReq->config_5g_channel) { tlvs = addTlv(NAN_TLV_TYPE_5G_CHANNEL, sizeof(u32), (const u8*)&pReq->channel_5g_val, tlvs); } if (pReq->config_dw.config_2dot4g_dw_band) { tlvs = addTlv(NAN_TLV_TYPE_2G_COMMITTED_DW, sizeof(pReq->config_dw.dw_2dot4g_interval_val), (const u8*)&pReq->config_dw.dw_2dot4g_interval_val, tlvs); } if (pReq->config_dw.config_5g_dw_band) { tlvs = addTlv(NAN_TLV_TYPE_5G_COMMITTED_DW, sizeof(pReq->config_dw.dw_5g_interval_val), (const u8*)&pReq->config_dw.dw_5g_interval_val, tlvs); } if (pReq->config_disc_mac_addr_randomization) { tlvs = addTlv(NAN_TLV_TYPE_DISC_MAC_ADDR_RANDOM_INTERVAL, sizeof(u32), (const u8*)&pReq->disc_mac_addr_rand_interval_sec, tlvs); } u32 config_discovery_indications; config_discovery_indications = (u32)pReq->discovery_indication_cfg; tlvs = addTlv(NAN_TLV_TYPE_CONFIG_DISCOVERY_INDICATIONS, sizeof(u32), (const u8*)&config_discovery_indications, tlvs); if (pReq->config_subscribe_sid_beacon) { tlvs = addTlv(NAN_TLV_TYPE_SUBSCRIBE_SID_BEACON, sizeof(pReq->subscribe_sid_beacon_val), (const u8*)&pReq->subscribe_sid_beacon_val, tlvs); } if (pReq->config_discovery_beacon_int) { tlvs = addTlv(NAN_TLV_TYPE_DB_INTERVAL, sizeof(u32), (const u8*)&pReq->discovery_beacon_interval, tlvs); } if (pReq->config_nss) { tlvs = addTlv(NAN_TLV_TYPE_TX_RX_CHAINS, sizeof(u32), (const u8*)&pReq->nss, tlvs); } if (pReq->config_enable_ranging) { tlvs = addTlv(NAN_TLV_TYPE_ENABLE_DEVICE_RANGING, sizeof(u32), (const u8*)&pReq->enable_ranging, tlvs); } if (pReq->config_dw_early_termination) { tlvs = addTlv(NAN_TLV_TYPE_DW_EARLY_TERMINATION, sizeof(u32), (const u8*)&pReq->enable_dw_termination, tlvs); } mVendorData = (char*)pFwReq; mDataLen = message_len; //Insert the vendor specific data ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanDisable(transaction_id id) { wifi_error ret; ALOGV("NAN_DISABLE"); size_t message_len = sizeof(NanDisableReqMsg); pNanDisableReqMsg pFwReq = (pNanDisableReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset (pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_DISABLE_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; mVendorData = (char*)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanConfig(transaction_id id, const NanConfigRequest *pReq) { wifi_error ret; ALOGV("NAN_CONFIG"); size_t message_len = 0; int idx = 0; if (pReq == NULL || pReq->num_config_discovery_attr > NAN_MAX_POSTDISCOVERY_LEN) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } message_len = sizeof(NanMsgHeader); message_len += \ ( pReq->config_sid_beacon ? (SIZEOF_TLV_HDR + \ sizeof(pReq->sid_beacon)) : 0 \ ) + \ ( pReq->config_master_pref ? (SIZEOF_TLV_HDR + \ sizeof(pReq->master_pref)) : 0 \ ) + \ ( pReq->config_rssi_proximity ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_proximity)) : 0 \ ) + \ ( pReq->config_5g_rssi_close_proximity ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_close_proximity_5g_val)) : 0 \ ) + \ ( pReq->config_rssi_window_size ? (SIZEOF_TLV_HDR + \ sizeof(pReq->rssi_window_size_val)) : 0 \ ) + \ ( pReq->config_cluster_attribute_val ? (SIZEOF_TLV_HDR + \ sizeof(pReq->config_cluster_attribute_val)) : 0 \ ) + \ ( pReq->config_scan_params ? NAN_MAX_SOCIAL_CHANNELS * (SIZEOF_TLV_HDR + sizeof(u32)) : 0 \ ) + \ ( pReq->config_random_factor_force ? (SIZEOF_TLV_HDR + \ sizeof(pReq->random_factor_force_val)) : 0 \ ) + \ ( pReq->config_hop_count_force ? (SIZEOF_TLV_HDR + \ sizeof(pReq->hop_count_force_val)) : 0 \ ) + \ ( pReq->config_conn_capability ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_dw.config_2dot4g_dw_band ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_dw.config_5g_dw_band ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_disc_mac_addr_randomization ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_subscribe_sid_beacon ? (SIZEOF_TLV_HDR + \ sizeof(pReq->subscribe_sid_beacon_val)) : 0 \ ) + \ ( /* Always include cfg discovery indication TLV */ SIZEOF_TLV_HDR + sizeof(u32) \ ) + \ ( pReq->config_discovery_beacon_int ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_nss ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_enable_ranging ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ) + \ ( pReq->config_dw_early_termination ? (SIZEOF_TLV_HDR + \ sizeof(u32)) : 0 \ ); if (pReq->num_config_discovery_attr) { for (idx = 0; idx < pReq->num_config_discovery_attr; idx ++) { message_len += SIZEOF_TLV_HDR +\ calcNanTransmitPostDiscoverySize(&pReq->discovery_attr_val[idx]); } } if (pReq->config_fam && \ calcNanFurtherAvailabilityMapSize(&pReq->fam_val)) { message_len += (SIZEOF_TLV_HDR + \ calcNanFurtherAvailabilityMapSize(&pReq->fam_val)); } pNanConfigurationReqMsg pFwReq = (pNanConfigurationReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset (pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_CONFIGURATION_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; u8* tlvs = pFwReq->ptlv; if (pReq->config_sid_beacon) { tlvs = addTlv(NAN_TLV_TYPE_SID_BEACON, sizeof(pReq->sid_beacon), (const u8*)&pReq->sid_beacon, tlvs); } if (pReq->config_master_pref) { tlvs = addTlv(NAN_TLV_TYPE_MASTER_PREFERENCE, sizeof(pReq->master_pref), (const u8*)&pReq->master_pref, tlvs); } if (pReq->config_rssi_window_size) { tlvs = addTlv(NAN_TLV_TYPE_RSSI_AVERAGING_WINDOW_SIZE, sizeof(pReq->rssi_window_size_val), (const u8*)&pReq->rssi_window_size_val, tlvs); } if (pReq->config_rssi_proximity) { tlvs = addTlv(NAN_TLV_TYPE_24G_RSSI_CLOSE_PROXIMITY, sizeof(pReq->rssi_proximity), (const u8*)&pReq->rssi_proximity, tlvs); } if (pReq->config_5g_rssi_close_proximity) { tlvs = addTlv(NAN_TLV_TYPE_5G_RSSI_CLOSE_PROXIMITY, sizeof(pReq->rssi_close_proximity_5g_val), (const u8*)&pReq->rssi_close_proximity_5g_val, tlvs); } if (pReq->config_cluster_attribute_val) { tlvs = addTlv(NAN_TLV_TYPE_CLUSTER_ATTRIBUTE_IN_SDF, sizeof(pReq->config_cluster_attribute_val), (const u8*)&pReq->config_cluster_attribute_val, tlvs); } if (pReq->config_scan_params) { u32 socialChannelParamVal[NAN_MAX_SOCIAL_CHANNELS]; /* Fill the social channel param */ fillNanSocialChannelParamVal(&pReq->scan_params_val, socialChannelParamVal); int i; for (i = 0; i < NAN_MAX_SOCIAL_CHANNELS; i++) { tlvs = addTlv(NAN_TLV_TYPE_SOCIAL_CHANNEL_SCAN_PARAMS, sizeof(socialChannelParamVal[i]), (const u8*)&socialChannelParamVal[i], tlvs); } } if (pReq->config_random_factor_force) { tlvs = addTlv(NAN_TLV_TYPE_RANDOM_FACTOR_FORCE, sizeof(pReq->random_factor_force_val), (const u8*)&pReq->random_factor_force_val, tlvs); } if (pReq->config_hop_count_force) { tlvs = addTlv(NAN_TLV_TYPE_HOP_COUNT_FORCE, sizeof(pReq->hop_count_force_val), (const u8*)&pReq->hop_count_force_val, tlvs); } if (pReq->config_conn_capability) { u32 val = \ getNanTransmitPostConnectivityCapabilityVal(&pReq->conn_capability_val); tlvs = addTlv(NAN_TLV_TYPE_POST_NAN_CONNECTIVITY_CAPABILITIES_TRANSMIT, sizeof(val), (const u8*)&val, tlvs); } if (pReq->num_config_discovery_attr) { for (idx = 0; idx < pReq->num_config_discovery_attr; idx ++) { fillNanTransmitPostDiscoveryVal(&pReq->discovery_attr_val[idx], (u8*)(tlvs + SIZEOF_TLV_HDR)); tlvs = addTlv(NAN_TLV_TYPE_POST_NAN_DISCOVERY_ATTRIBUTE_TRANSMIT, calcNanTransmitPostDiscoverySize( &pReq->discovery_attr_val[idx]), (const u8*)(tlvs + SIZEOF_TLV_HDR), tlvs); } } if (pReq->config_fam && \ calcNanFurtherAvailabilityMapSize(&pReq->fam_val)) { fillNanFurtherAvailabilityMapVal(&pReq->fam_val, (u8*)(tlvs + SIZEOF_TLV_HDR)); tlvs = addTlv(NAN_TLV_TYPE_FURTHER_AVAILABILITY_MAP, calcNanFurtherAvailabilityMapSize(&pReq->fam_val), (const u8*)(tlvs + SIZEOF_TLV_HDR), tlvs); } if (pReq->config_dw.config_2dot4g_dw_band) { tlvs = addTlv(NAN_TLV_TYPE_2G_COMMITTED_DW, sizeof(pReq->config_dw.dw_2dot4g_interval_val), (const u8*)&pReq->config_dw.dw_2dot4g_interval_val, tlvs); } if (pReq->config_dw.config_5g_dw_band) { tlvs = addTlv(NAN_TLV_TYPE_5G_COMMITTED_DW, sizeof(pReq->config_dw.dw_5g_interval_val), (const u8*)&pReq->config_dw.dw_5g_interval_val, tlvs); } if (pReq->config_disc_mac_addr_randomization) { tlvs = addTlv(NAN_TLV_TYPE_DISC_MAC_ADDR_RANDOM_INTERVAL, sizeof(u32), (const u8*)&pReq->disc_mac_addr_rand_interval_sec, tlvs); } if (pReq->config_subscribe_sid_beacon) { tlvs = addTlv(NAN_TLV_TYPE_SUBSCRIBE_SID_BEACON, sizeof(pReq->subscribe_sid_beacon_val), (const u8*)&pReq->subscribe_sid_beacon_val, tlvs); } if (pReq->config_discovery_beacon_int) { tlvs = addTlv(NAN_TLV_TYPE_DB_INTERVAL, sizeof(u32), (const u8*)&pReq->discovery_beacon_interval, tlvs); } u32 config_discovery_indications; config_discovery_indications = (u32)(pReq->discovery_indication_cfg); /* Always include the discovery cfg TLV as there is no cfg flag */ tlvs = addTlv(NAN_TLV_TYPE_CONFIG_DISCOVERY_INDICATIONS, sizeof(u32), (const u8*)&config_discovery_indications, tlvs); if (pReq->config_nss) { tlvs = addTlv(NAN_TLV_TYPE_TX_RX_CHAINS, sizeof(u32), (const u8*)&pReq->nss, tlvs); } if (pReq->config_enable_ranging) { tlvs = addTlv(NAN_TLV_TYPE_ENABLE_DEVICE_RANGING, sizeof(u32), (const u8*)&pReq->enable_ranging, tlvs); } if (pReq->config_dw_early_termination) { tlvs = addTlv(NAN_TLV_TYPE_DW_EARLY_TERMINATION, sizeof(u32), (const u8*)&pReq->enable_dw_termination, tlvs); } mVendorData = (char*)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanPublish(transaction_id id, const NanPublishRequest *pReq) { wifi_error ret; ALOGV("NAN_PUBLISH"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanMsgHeader) + sizeof(NanPublishServiceReqParams) + (pReq->service_name_len ? SIZEOF_TLV_HDR + pReq->service_name_len : 0) + (pReq->service_specific_info_len ? SIZEOF_TLV_HDR + pReq->service_specific_info_len : 0) + (pReq->rx_match_filter_len ? SIZEOF_TLV_HDR + pReq->rx_match_filter_len : 0) + (pReq->tx_match_filter_len ? SIZEOF_TLV_HDR + pReq->tx_match_filter_len : 0) + (SIZEOF_TLV_HDR + sizeof(NanServiceAcceptPolicy)) + (pReq->cipher_type ? SIZEOF_TLV_HDR + sizeof(NanCsidType) : 0) + ((pReq->sdea_params.config_nan_data_path || pReq->sdea_params.security_cfg || pReq->sdea_params.ranging_state || pReq->sdea_params.range_report || pReq->sdea_params.qos_cfg) ? SIZEOF_TLV_HDR + sizeof(NanFWSdeaCtrlParams) : 0) + ((pReq->ranging_cfg.ranging_interval_msec || pReq->ranging_cfg.config_ranging_indications || pReq->ranging_cfg.distance_ingress_mm || pReq->ranging_cfg.distance_egress_mm) ? SIZEOF_TLV_HDR + sizeof(NanFWRangeConfigParams) : 0) + ((pReq->range_response_cfg.publish_id || pReq->range_response_cfg.ranging_response) ? SIZEOF_TLV_HDR + sizeof(NanFWRangeReqMsg) : 0) + (pReq->sdea_service_specific_info_len ? SIZEOF_TLV_HDR + pReq->sdea_service_specific_info_len : 0); if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) && (pReq->key_info.body.pmk_info.pmk_len == NAN_PMK_INFO_LEN)) message_len += SIZEOF_TLV_HDR + NAN_PMK_INFO_LEN; else if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) && (pReq->key_info.body.passphrase_info.passphrase_len >= NAN_SECURITY_MIN_PASSPHRASE_LEN) && (pReq->key_info.body.passphrase_info.passphrase_len <= NAN_SECURITY_MAX_PASSPHRASE_LEN)) message_len += SIZEOF_TLV_HDR + pReq->key_info.body.passphrase_info.passphrase_len; pNanPublishServiceReqMsg pFwReq = (pNanPublishServiceReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_PUBLISH_SERVICE_REQ; pFwReq->fwHeader.msgLen = message_len; if (pReq->publish_id == 0) { pFwReq->fwHeader.handle = 0xFFFF; } else { pFwReq->fwHeader.handle = pReq->publish_id; } pFwReq->fwHeader.transactionId = id; pFwReq->publishServiceReqParams.ttl = pReq->ttl; pFwReq->publishServiceReqParams.period = pReq->period; pFwReq->publishServiceReqParams.replyIndFlag = (pReq->recv_indication_cfg & BIT_3) ? 0 : 1; pFwReq->publishServiceReqParams.publishType = pReq->publish_type; pFwReq->publishServiceReqParams.txType = pReq->tx_type; pFwReq->publishServiceReqParams.rssiThresholdFlag = pReq->rssi_threshold_flag; pFwReq->publishServiceReqParams.matchAlg = pReq->publish_match_indicator; pFwReq->publishServiceReqParams.count = pReq->publish_count; pFwReq->publishServiceReqParams.connmap = pReq->connmap; pFwReq->publishServiceReqParams.pubTerminatedIndDisableFlag = (pReq->recv_indication_cfg & BIT_0) ? 1 : 0; pFwReq->publishServiceReqParams.pubMatchExpiredIndDisableFlag = (pReq->recv_indication_cfg & BIT_1) ? 1 : 0; pFwReq->publishServiceReqParams.followupRxIndDisableFlag = (pReq->recv_indication_cfg & BIT_2) ? 1 : 0; pFwReq->publishServiceReqParams.reserved2 = 0; u8* tlvs = pFwReq->ptlv; if (pReq->service_name_len) { tlvs = addTlv(NAN_TLV_TYPE_SERVICE_NAME, pReq->service_name_len, (const u8*)&pReq->service_name[0], tlvs); } if (pReq->service_specific_info_len) { tlvs = addTlv(NAN_TLV_TYPE_SERVICE_SPECIFIC_INFO, pReq->service_specific_info_len, (const u8*)&pReq->service_specific_info[0], tlvs); } if (pReq->rx_match_filter_len) { tlvs = addTlv(NAN_TLV_TYPE_RX_MATCH_FILTER, pReq->rx_match_filter_len, (const u8*)&pReq->rx_match_filter[0], tlvs); } if (pReq->tx_match_filter_len) { tlvs = addTlv(NAN_TLV_TYPE_TX_MATCH_FILTER, pReq->tx_match_filter_len, (const u8*)&pReq->tx_match_filter[0], tlvs); } /* Pass the Accept policy always */ tlvs = addTlv(NAN_TLV_TYPE_NAN_SERVICE_ACCEPT_POLICY, sizeof(NanServiceAcceptPolicy), (const u8*)&pReq->service_responder_policy, tlvs); if (pReq->cipher_type) { NanCsidType pNanCsidType; pNanCsidType.csid_type = pReq->cipher_type; tlvs = addTlv(NAN_TLV_TYPE_NAN_CSID, sizeof(NanCsidType), (const u8*)&pNanCsidType, tlvs); } if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) && (pReq->key_info.body.pmk_info.pmk_len == NAN_PMK_INFO_LEN)) { tlvs = addTlv(NAN_TLV_TYPE_NAN_PMK, pReq->key_info.body.pmk_info.pmk_len, (const u8*)&pReq->key_info.body.pmk_info.pmk[0], tlvs); } else if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) && (pReq->key_info.body.passphrase_info.passphrase_len >= NAN_SECURITY_MIN_PASSPHRASE_LEN) && (pReq->key_info.body.passphrase_info.passphrase_len <= NAN_SECURITY_MAX_PASSPHRASE_LEN)) { tlvs = addTlv(NAN_TLV_TYPE_NAN_PASSPHRASE, pReq->key_info.body.passphrase_info.passphrase_len, (const u8*)&pReq->key_info.body.passphrase_info.passphrase[0], tlvs); } if (pReq->sdea_params.config_nan_data_path || pReq->sdea_params.security_cfg || pReq->sdea_params.ranging_state || pReq->sdea_params.range_report || pReq->sdea_params.qos_cfg) { NanFWSdeaCtrlParams pNanFWSdeaCtrlParams; memset(&pNanFWSdeaCtrlParams, 0, sizeof(NanFWSdeaCtrlParams)); if (pReq->sdea_params.config_nan_data_path) { pNanFWSdeaCtrlParams.data_path_required = 1; pNanFWSdeaCtrlParams.data_path_type = (pReq->sdea_params.ndp_type & BIT_0) ? NAN_DATA_PATH_MULTICAST_MSG : NAN_DATA_PATH_UNICAST_MSG; } if (pReq->sdea_params.security_cfg) { pNanFWSdeaCtrlParams.security_required = pReq->sdea_params.security_cfg; } if (pReq->sdea_params.ranging_state) { pNanFWSdeaCtrlParams.ranging_required = pReq->sdea_params.ranging_state; } if (pReq->sdea_params.range_report) { pNanFWSdeaCtrlParams.range_report = (((pReq->sdea_params.range_report & NAN_ENABLE_RANGE_REPORT) >> 1) ? 1 : 0); } if (pReq->sdea_params.qos_cfg) { pNanFWSdeaCtrlParams.qos_required = pReq->sdea_params.qos_cfg; } tlvs = addTlv(NAN_TLV_TYPE_SDEA_CTRL_PARAMS, sizeof(NanFWSdeaCtrlParams), (const u8*)&pNanFWSdeaCtrlParams, tlvs); } if (pReq->ranging_cfg.ranging_interval_msec || pReq->ranging_cfg.config_ranging_indications || pReq->ranging_cfg.distance_ingress_mm || pReq->ranging_cfg.distance_egress_mm) { NanFWRangeConfigParams pNanFWRangingCfg; memset(&pNanFWRangingCfg, 0, sizeof(NanFWRangeConfigParams)); pNanFWRangingCfg.range_interval = pReq->ranging_cfg.ranging_interval_msec; pNanFWRangingCfg.ranging_indication_event = ((pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_CONTINUOUS_MASK) | (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_INGRESS_MET_MASK) | (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_EGRESS_MET_MASK)); pNanFWRangingCfg.ranging_indication_event = pReq->ranging_cfg.config_ranging_indications; if (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_INGRESS_MET_MASK) pNanFWRangingCfg.geo_fence_threshold.inner_threshold = pReq->ranging_cfg.distance_ingress_mm; if (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_EGRESS_MET_MASK) pNanFWRangingCfg.geo_fence_threshold.outer_threshold = pReq->ranging_cfg.distance_egress_mm; tlvs = addTlv(NAN_TLV_TYPE_NAN_RANGING_CFG, sizeof(NanFWRangeConfigParams), (const u8*)&pNanFWRangingCfg, tlvs); } if (pReq->sdea_service_specific_info_len) { tlvs = addTlv(NAN_TLV_TYPE_SDEA_SERVICE_SPECIFIC_INFO, pReq->sdea_service_specific_info_len, (const u8*)&pReq->sdea_service_specific_info[0], tlvs); } if (pReq->range_response_cfg.publish_id || pReq->range_response_cfg.ranging_response) { NanFWRangeReqMsg pNanFWRangeReqMsg; memset(&pNanFWRangeReqMsg, 0, sizeof(NanFWRangeReqMsg)); pNanFWRangeReqMsg.range_id = (u16)pReq->range_response_cfg.publish_id; CHAR_ARRAY_TO_MAC_ADDR(pReq->range_response_cfg.peer_addr, pNanFWRangeReqMsg.range_mac_addr); pNanFWRangeReqMsg.ranging_accept = ((pReq->range_response_cfg.ranging_response == NAN_RANGE_REQUEST_ACCEPT) ? 1 : 0); pNanFWRangeReqMsg.ranging_reject = ((pReq->range_response_cfg.ranging_response == NAN_RANGE_REQUEST_REJECT) ? 1 : 0); pNanFWRangeReqMsg.ranging_cancel = ((pReq->range_response_cfg.ranging_response == NAN_RANGE_REQUEST_CANCEL) ? 1 : 0); tlvs = addTlv(NAN_TLV_TYPE_NAN20_RANGING_REQUEST, sizeof(NanFWRangeReqMsg), (const u8*)&pNanFWRangeReqMsg, tlvs); } mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanPublishCancel(transaction_id id, const NanPublishCancelRequest *pReq) { wifi_error ret; ALOGV("NAN_PUBLISH_CANCEL"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanPublishServiceCancelReqMsg); pNanPublishServiceCancelReqMsg pFwReq = (pNanPublishServiceCancelReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_PUBLISH_SERVICE_CANCEL_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.handle = pReq->publish_id; pFwReq->fwHeader.transactionId = id; mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanSubscribe(transaction_id id, const NanSubscribeRequest *pReq) { wifi_error ret; ALOGV("NAN_SUBSCRIBE"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanMsgHeader) + sizeof(NanSubscribeServiceReqParams) + (pReq->service_name_len ? SIZEOF_TLV_HDR + pReq->service_name_len : 0) + (pReq->service_specific_info_len ? SIZEOF_TLV_HDR + pReq->service_specific_info_len : 0) + (pReq->rx_match_filter_len ? SIZEOF_TLV_HDR + pReq->rx_match_filter_len : 0) + (pReq->tx_match_filter_len ? SIZEOF_TLV_HDR + pReq->tx_match_filter_len : 0) + (pReq->cipher_type ? SIZEOF_TLV_HDR + sizeof(NanCsidType) : 0) + ((pReq->sdea_params.config_nan_data_path || pReq->sdea_params.security_cfg || pReq->sdea_params.ranging_state || pReq->sdea_params.range_report || pReq->sdea_params.qos_cfg) ? SIZEOF_TLV_HDR + sizeof(NanFWSdeaCtrlParams) : 0) + ((pReq->ranging_cfg.ranging_interval_msec || pReq->ranging_cfg.config_ranging_indications || pReq->ranging_cfg.distance_ingress_mm || pReq->ranging_cfg.distance_egress_mm) ? SIZEOF_TLV_HDR + sizeof(NanFWRangeConfigParams) : 0) + ((pReq->range_response_cfg.requestor_instance_id || pReq->range_response_cfg.ranging_response) ? SIZEOF_TLV_HDR + sizeof(NanFWRangeReqMsg) : 0) + (pReq->sdea_service_specific_info_len ? SIZEOF_TLV_HDR + pReq->sdea_service_specific_info_len : 0); message_len += \ (pReq->num_intf_addr_present * (SIZEOF_TLV_HDR + NAN_MAC_ADDR_LEN)); if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) && (pReq->key_info.body.pmk_info.pmk_len == NAN_PMK_INFO_LEN)) message_len += SIZEOF_TLV_HDR + NAN_PMK_INFO_LEN; else if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) && (pReq->key_info.body.passphrase_info.passphrase_len >= NAN_SECURITY_MIN_PASSPHRASE_LEN) && (pReq->key_info.body.passphrase_info.passphrase_len <= NAN_SECURITY_MAX_PASSPHRASE_LEN)) message_len += SIZEOF_TLV_HDR + pReq->key_info.body.passphrase_info.passphrase_len; pNanSubscribeServiceReqMsg pFwReq = (pNanSubscribeServiceReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_SUBSCRIBE_SERVICE_REQ; pFwReq->fwHeader.msgLen = message_len; if (pReq->subscribe_id == 0) { pFwReq->fwHeader.handle = 0xFFFF; } else { pFwReq->fwHeader.handle = pReq->subscribe_id; } pFwReq->fwHeader.transactionId = id; pFwReq->subscribeServiceReqParams.ttl = pReq->ttl; pFwReq->subscribeServiceReqParams.period = pReq->period; pFwReq->subscribeServiceReqParams.subscribeType = pReq->subscribe_type; pFwReq->subscribeServiceReqParams.srfAttr = pReq->serviceResponseFilter; pFwReq->subscribeServiceReqParams.srfInclude = pReq->serviceResponseInclude; pFwReq->subscribeServiceReqParams.srfSend = pReq->useServiceResponseFilter; pFwReq->subscribeServiceReqParams.ssiRequired = pReq->ssiRequiredForMatchIndication; pFwReq->subscribeServiceReqParams.matchAlg = pReq->subscribe_match_indicator; pFwReq->subscribeServiceReqParams.count = pReq->subscribe_count; pFwReq->subscribeServiceReqParams.rssiThresholdFlag = pReq->rssi_threshold_flag; pFwReq->subscribeServiceReqParams.subTerminatedIndDisableFlag = (pReq->recv_indication_cfg & BIT_0) ? 1 : 0; pFwReq->subscribeServiceReqParams.subMatchExpiredIndDisableFlag = (pReq->recv_indication_cfg & BIT_1) ? 1 : 0; pFwReq->subscribeServiceReqParams.followupRxIndDisableFlag = (pReq->recv_indication_cfg & BIT_2) ? 1 : 0; pFwReq->subscribeServiceReqParams.connmap = pReq->connmap; pFwReq->subscribeServiceReqParams.reserved = 0; u8* tlvs = pFwReq->ptlv; if (pReq->service_name_len) { tlvs = addTlv(NAN_TLV_TYPE_SERVICE_NAME, pReq->service_name_len, (const u8*)&pReq->service_name[0], tlvs); } if (pReq->service_specific_info_len) { tlvs = addTlv(NAN_TLV_TYPE_SERVICE_SPECIFIC_INFO, pReq->service_specific_info_len, (const u8*)&pReq->service_specific_info[0], tlvs); } if (pReq->rx_match_filter_len) { tlvs = addTlv(NAN_TLV_TYPE_RX_MATCH_FILTER, pReq->rx_match_filter_len, (const u8*)&pReq->rx_match_filter[0], tlvs); } if (pReq->tx_match_filter_len) { tlvs = addTlv(NAN_TLV_TYPE_TX_MATCH_FILTER, pReq->tx_match_filter_len, (const u8*)&pReq->tx_match_filter[0], tlvs); } int i = 0; for (i = 0; i < pReq->num_intf_addr_present; i++) { tlvs = addTlv(NAN_TLV_TYPE_MAC_ADDRESS, NAN_MAC_ADDR_LEN, (const u8*)&pReq->intf_addr[i][0], tlvs); } if (pReq->cipher_type) { NanCsidType pNanCsidType; pNanCsidType.csid_type = pReq->cipher_type; tlvs = addTlv(NAN_TLV_TYPE_NAN_CSID, sizeof(NanCsidType), (const u8*)&pNanCsidType, tlvs); } if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) && (pReq->key_info.body.pmk_info.pmk_len == NAN_PMK_INFO_LEN)) { tlvs = addTlv(NAN_TLV_TYPE_NAN_PMK, pReq->key_info.body.pmk_info.pmk_len, (const u8*)&pReq->key_info.body.pmk_info.pmk[0], tlvs); } else if ((pReq->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) && (pReq->key_info.body.passphrase_info.passphrase_len >= NAN_SECURITY_MIN_PASSPHRASE_LEN) && (pReq->key_info.body.passphrase_info.passphrase_len <= NAN_SECURITY_MAX_PASSPHRASE_LEN)) { tlvs = addTlv(NAN_TLV_TYPE_NAN_PASSPHRASE, pReq->key_info.body.passphrase_info.passphrase_len, (const u8*)&pReq->key_info.body.passphrase_info.passphrase[0], tlvs); } if (pReq->sdea_params.config_nan_data_path || pReq->sdea_params.security_cfg || pReq->sdea_params.ranging_state || pReq->sdea_params.range_report || pReq->sdea_params.qos_cfg) { NanFWSdeaCtrlParams pNanFWSdeaCtrlParams; memset(&pNanFWSdeaCtrlParams, 0, sizeof(NanFWSdeaCtrlParams)); if (pReq->sdea_params.config_nan_data_path) { pNanFWSdeaCtrlParams.data_path_required = 1; pNanFWSdeaCtrlParams.data_path_type = (pReq->sdea_params.ndp_type & BIT_0) ? NAN_DATA_PATH_MULTICAST_MSG : NAN_DATA_PATH_UNICAST_MSG; } if (pReq->sdea_params.security_cfg) { pNanFWSdeaCtrlParams.security_required = pReq->sdea_params.security_cfg; } if (pReq->sdea_params.ranging_state) { pNanFWSdeaCtrlParams.ranging_required = pReq->sdea_params.ranging_state; } if (pReq->sdea_params.range_report) { pNanFWSdeaCtrlParams.range_report = ((pReq->sdea_params.range_report & NAN_ENABLE_RANGE_REPORT >> 1) ? 1 : 0); } if (pReq->sdea_params.qos_cfg) { pNanFWSdeaCtrlParams.qos_required = pReq->sdea_params.qos_cfg; } tlvs = addTlv(NAN_TLV_TYPE_SDEA_CTRL_PARAMS, sizeof(NanFWSdeaCtrlParams), (const u8*)&pNanFWSdeaCtrlParams, tlvs); } if (pReq->ranging_cfg.ranging_interval_msec || pReq->ranging_cfg.config_ranging_indications || pReq->ranging_cfg.distance_ingress_mm || pReq->ranging_cfg.distance_egress_mm) { NanFWRangeConfigParams pNanFWRangingCfg; memset(&pNanFWRangingCfg, 0, sizeof(NanFWRangeConfigParams)); pNanFWRangingCfg.range_interval = pReq->ranging_cfg.ranging_interval_msec; pNanFWRangingCfg.ranging_indication_event = ((pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_CONTINUOUS_MASK) | (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_INGRESS_MET_MASK) | (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_EGRESS_MET_MASK)); pNanFWRangingCfg.ranging_indication_event = pReq->ranging_cfg.config_ranging_indications; if (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_INGRESS_MET_MASK) pNanFWRangingCfg.geo_fence_threshold.inner_threshold = pReq->ranging_cfg.distance_ingress_mm; if (pReq->ranging_cfg.config_ranging_indications & NAN_RANGING_INDICATE_EGRESS_MET_MASK) pNanFWRangingCfg.geo_fence_threshold.outer_threshold = pReq->ranging_cfg.distance_egress_mm; tlvs = addTlv(NAN_TLV_TYPE_NAN_RANGING_CFG, sizeof(NanFWRangeConfigParams), (const u8*)&pNanFWRangingCfg, tlvs); } if (pReq->sdea_service_specific_info_len) { tlvs = addTlv(NAN_TLV_TYPE_SDEA_SERVICE_SPECIFIC_INFO, pReq->sdea_service_specific_info_len, (const u8*)&pReq->sdea_service_specific_info[0], tlvs); } if (pReq->range_response_cfg.requestor_instance_id || pReq->range_response_cfg.ranging_response) { NanFWRangeReqMsg pNanFWRangeReqMsg; memset(&pNanFWRangeReqMsg, 0, sizeof(NanFWRangeReqMsg)); pNanFWRangeReqMsg.range_id = pReq->range_response_cfg.requestor_instance_id; memcpy(&pNanFWRangeReqMsg.range_mac_addr, &pReq->range_response_cfg.peer_addr, NAN_MAC_ADDR_LEN); pNanFWRangeReqMsg.ranging_accept = ((pReq->range_response_cfg.ranging_response == NAN_RANGE_REQUEST_ACCEPT) ? 1 : 0); pNanFWRangeReqMsg.ranging_reject = ((pReq->range_response_cfg.ranging_response == NAN_RANGE_REQUEST_REJECT) ? 1 : 0); pNanFWRangeReqMsg.ranging_cancel = ((pReq->range_response_cfg.ranging_response == NAN_RANGE_REQUEST_CANCEL) ? 1 : 0); tlvs = addTlv(NAN_TLV_TYPE_NAN20_RANGING_REQUEST, sizeof(NanFWRangeReqMsg), (const u8*)&pNanFWRangeReqMsg, tlvs); } mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanSubscribeCancel(transaction_id id, const NanSubscribeCancelRequest *pReq) { wifi_error ret; ALOGV("NAN_SUBSCRIBE_CANCEL"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanSubscribeServiceCancelReqMsg); pNanSubscribeServiceCancelReqMsg pFwReq = (pNanSubscribeServiceCancelReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_SUBSCRIBE_SERVICE_CANCEL_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.handle = pReq->subscribe_id; pFwReq->fwHeader.transactionId = id; mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanTransmitFollowup(transaction_id id, const NanTransmitFollowupRequest *pReq) { wifi_error ret; ALOGV("TRANSMIT_FOLLOWUP"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanMsgHeader) + sizeof(NanTransmitFollowupReqParams) + (pReq->service_specific_info_len ? SIZEOF_TLV_HDR + pReq->service_specific_info_len : 0) + (pReq->sdea_service_specific_info_len ? SIZEOF_TLV_HDR + pReq->sdea_service_specific_info_len : 0); /* Mac address needs to be added in TLV */ message_len += (SIZEOF_TLV_HDR + sizeof(pReq->addr)); pNanTransmitFollowupReqMsg pFwReq = (pNanTransmitFollowupReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset (pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_TRANSMIT_FOLLOWUP_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.handle = pReq->publish_subscribe_id; pFwReq->fwHeader.transactionId = id; pFwReq->transmitFollowupReqParams.matchHandle = pReq->requestor_instance_id; if (pReq->priority != NAN_TX_PRIORITY_HIGH) { pFwReq->transmitFollowupReqParams.priority = 1; } else { pFwReq->transmitFollowupReqParams.priority = 2; } pFwReq->transmitFollowupReqParams.window = pReq->dw_or_faw; pFwReq->transmitFollowupReqParams.followupTxRspDisableFlag = (pReq->recv_indication_cfg & BIT_0) ? 1 : 0; pFwReq->transmitFollowupReqParams.reserved = 0; u8* tlvs = pFwReq->ptlv; /* Mac address needs to be added in TLV */ tlvs = addTlv(NAN_TLV_TYPE_MAC_ADDRESS, sizeof(pReq->addr), (const u8*)&pReq->addr[0], tlvs); u16 tlv_type = NAN_TLV_TYPE_SERVICE_SPECIFIC_INFO; if (pReq->service_specific_info_len) { tlvs = addTlv(tlv_type, pReq->service_specific_info_len, (const u8*)&pReq->service_specific_info[0], tlvs); } if (pReq->sdea_service_specific_info_len) { tlvs = addTlv(NAN_TLV_TYPE_SDEA_SERVICE_SPECIFIC_INFO, pReq->sdea_service_specific_info_len, (const u8*)&pReq->sdea_service_specific_info[0], tlvs); } mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanStats(transaction_id id, const NanStatsRequest *pReq) { wifi_error ret; ALOGV("NAN_STATS"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanStatsReqMsg); pNanStatsReqMsg pFwReq = (pNanStatsReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_STATS_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; pFwReq->statsReqParams.statsType = pReq->stats_type; pFwReq->statsReqParams.clear = pReq->clear; pFwReq->statsReqParams.reserved = 0; mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanTCA(transaction_id id, const NanTCARequest *pReq) { wifi_error ret; ALOGV("NAN_TCA"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanTcaReqMsg); message_len += (SIZEOF_TLV_HDR + 2 * sizeof(u32)); pNanTcaReqMsg pFwReq = (pNanTcaReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_TCA_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; u32 tcaReqParams[2]; memset (tcaReqParams, 0, sizeof(tcaReqParams)); tcaReqParams[0] = (pReq->rising_direction_evt_flag & 0x01); tcaReqParams[0] |= (pReq->falling_direction_evt_flag & 0x01) << 1; tcaReqParams[0] |= (pReq->clear & 0x01) << 2; tcaReqParams[1] = pReq->threshold; u8* tlvs = pFwReq->ptlv; if (pReq->tca_type == NAN_TCA_ID_CLUSTER_SIZE) { tlvs = addTlv(NAN_TLV_TYPE_CLUSTER_SIZE_REQ, sizeof(tcaReqParams), (const u8*)&tcaReqParams[0], tlvs); } else { ALOGE("%s: Unrecognized tca_type:%u", __FUNCTION__, pReq->tca_type); cleanup(); return WIFI_ERROR_INVALID_ARGS; } mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanBeaconSdfPayload(transaction_id id, const NanBeaconSdfPayloadRequest *pReq) { wifi_error ret; ALOGV("NAN_BEACON_SDF_PAYLAOD"); if (pReq == NULL) { cleanup(); return WIFI_ERROR_INVALID_ARGS; } size_t message_len = sizeof(NanMsgHeader) + \ SIZEOF_TLV_HDR + sizeof(u32) + \ pReq->vsa.vsa_len; pNanBeaconSdfPayloadReqMsg pFwReq = (pNanBeaconSdfPayloadReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu", message_len); memset(pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_BEACON_SDF_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; /* Construct First 4 bytes of NanBeaconSdfPayloadReqMsg */ u32 temp = 0; temp = pReq->vsa.payload_transmit_flag & 0x01; temp |= (pReq->vsa.tx_in_discovery_beacon & 0x01) << 1; temp |= (pReq->vsa.tx_in_sync_beacon & 0x01) << 2; temp |= (pReq->vsa.tx_in_service_discovery & 0x01) << 3; temp |= (pReq->vsa.vendor_oui & 0x00FFFFFF) << 8; int tlv_len = sizeof(u32) + pReq->vsa.vsa_len; u8* tempBuf = (u8*)malloc(tlv_len); if (tempBuf == NULL) { ALOGE("%s: Malloc failed", __func__); free(pFwReq); cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } memset(tempBuf, 0, tlv_len); memcpy(tempBuf, &temp, sizeof(u32)); memcpy((tempBuf + sizeof(u32)), pReq->vsa.vsa, pReq->vsa.vsa_len); u8* tlvs = pFwReq->ptlv; /* Write the TLVs to the message. */ tlvs = addTlv(NAN_TLV_TYPE_VENDOR_SPECIFIC_ATTRIBUTE_TRANSMIT, tlv_len, (const u8*)tempBuf, tlvs); free(tempBuf); mVendorData = (char *)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } //callback handlers registered for nl message send static int error_handler_nan(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) { struct sockaddr_nl * tmp; int *ret = (int *)arg; tmp = nla; *ret = err->error; ALOGE("%s: Error code:%d (%s)", __func__, *ret, strerror(-(*ret))); return NL_STOP; } //callback handlers registered for nl message send static int ack_handler_nan(struct nl_msg *msg, void *arg) { int *ret = (int *)arg; struct nl_msg * a; ALOGE("%s: called", __func__); a = msg; *ret = 0; return NL_STOP; } //callback handlers registered for nl message send static int finish_handler_nan(struct nl_msg *msg, void *arg) { int *ret = (int *)arg; struct nl_msg * a; ALOGE("%s: called", __func__); a = msg; *ret = 0; return NL_SKIP; } //Override base class requestEvent and implement little differently here //This will send the request message //We dont wait for any response back in case of Nan as it is asynchronous //thus no wait for condition. wifi_error NanCommand::requestEvent() { wifi_error res; int status; struct nl_cb * cb; cb = nl_cb_alloc(NL_CB_DEFAULT); if (!cb) { ALOGE("%s: Callback allocation failed",__func__); res = WIFI_ERROR_OUT_OF_MEMORY; goto out; } if (!mInfo->cmd_sock) { ALOGE("%s: Command socket is null",__func__); res = WIFI_ERROR_OUT_OF_MEMORY; goto out; } /* send message */ ALOGV("%s:Handle:%p Socket Value:%p", __func__, mInfo, mInfo->cmd_sock); status = nl_send_auto_complete(mInfo->cmd_sock, mMsg.getMessage()); if (status < 0) { res = mapKernelErrortoWifiHalError(status); goto out; } status = 1; nl_cb_err(cb, NL_CB_CUSTOM, error_handler_nan, &status); nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler_nan, &status); nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler_nan, &status); // err is populated as part of finish_handler while (status > 0) nl_recvmsgs(mInfo->cmd_sock, cb); res = mapKernelErrortoWifiHalError(status); out: //free the VendorData if (mVendorData) { free(mVendorData); } mVendorData = NULL; //cleanup the mMsg mMsg.destroy(); return res; } int NanCommand::calcNanTransmitPostDiscoverySize( const NanTransmitPostDiscovery *pPostDiscovery) { /* Fixed size of u32 for Conn Type, Device Role and R flag + Dur + Rsvd*/ int ret = sizeof(u32); /* size of availability interval bit map is 4 bytes */ ret += sizeof(u32); /* size of mac address is 6 bytes*/ ret += (SIZEOF_TLV_HDR + NAN_MAC_ADDR_LEN); if (pPostDiscovery && pPostDiscovery->type == NAN_CONN_WLAN_MESH) { /* size of WLAN_MESH_ID */ ret += (SIZEOF_TLV_HDR + \ pPostDiscovery->mesh_id_len); } if (pPostDiscovery && pPostDiscovery->type == NAN_CONN_WLAN_INFRA) { /* size of Infrastructure ssid */ ret += (SIZEOF_TLV_HDR + \ pPostDiscovery->infrastructure_ssid_len); } ALOGV("%s:size:%d", __func__, ret); return ret; } void NanCommand::fillNanSocialChannelParamVal( const NanSocialChannelScanParams *pScanParams, u32* pChannelParamArr) { int i; if (pChannelParamArr) { memset(pChannelParamArr, 0, NAN_MAX_SOCIAL_CHANNELS * sizeof(u32)); for (i= 0; i < NAN_MAX_SOCIAL_CHANNELS; i++) { pChannelParamArr[i] = pScanParams->scan_period[i] << 16; pChannelParamArr[i] |= pScanParams->dwell_time[i] << 8; } pChannelParamArr[NAN_CHANNEL_24G_BAND] |= 6; pChannelParamArr[NAN_CHANNEL_5G_BAND_LOW]|= 44; pChannelParamArr[NAN_CHANNEL_5G_BAND_HIGH]|= 149; ALOGV("%s: Filled SocialChannelParamVal", __func__); hexdump((char*)pChannelParamArr, NAN_MAX_SOCIAL_CHANNELS * sizeof(u32)); } return; } u32 NanCommand::getNanTransmitPostConnectivityCapabilityVal( const NanTransmitPostConnectivityCapability *pCapab) { u32 ret = 0; ret |= (pCapab->payload_transmit_flag? 1:0) << 16; ret |= (pCapab->is_mesh_supported? 1:0) << 5; ret |= (pCapab->is_ibss_supported? 1:0) << 4; ret |= (pCapab->wlan_infra_field? 1:0) << 3; ret |= (pCapab->is_tdls_supported? 1:0) << 2; ret |= (pCapab->is_wfds_supported? 1:0) << 1; ret |= (pCapab->is_wfd_supported? 1:0); ALOGV("%s: val:%d", __func__, ret); return ret; } void NanCommand::fillNanTransmitPostDiscoveryVal( const NanTransmitPostDiscovery *pTxDisc, u8 *pOutValue) { if (pTxDisc && pOutValue) { u8 *tlvs = &pOutValue[8]; pOutValue[0] = pTxDisc->type; pOutValue[1] = pTxDisc->role; pOutValue[2] = (pTxDisc->transmit_freq? 1:0); pOutValue[2] |= ((pTxDisc->duration & 0x03) << 1); memcpy(&pOutValue[4], &pTxDisc->avail_interval_bitmap, sizeof(pTxDisc->avail_interval_bitmap)); tlvs = addTlv(NAN_TLV_TYPE_MAC_ADDRESS, NAN_MAC_ADDR_LEN, (const u8*)&pTxDisc->addr[0], tlvs); if (pTxDisc->type == NAN_CONN_WLAN_MESH) { tlvs = addTlv(NAN_TLV_TYPE_WLAN_MESH_ID, pTxDisc->mesh_id_len, (const u8*)&pTxDisc->mesh_id[0], tlvs); } if (pTxDisc->type == NAN_CONN_WLAN_INFRA) { tlvs = addTlv(NAN_TLV_TYPE_WLAN_INFRA_SSID, pTxDisc->infrastructure_ssid_len, (const u8*)&pTxDisc->infrastructure_ssid_val[0], tlvs); } ALOGV("%s: Filled TransmitPostDiscoveryVal", __func__); hexdump((char*)pOutValue, calcNanTransmitPostDiscoverySize(pTxDisc)); } return; } void NanCommand::fillNanFurtherAvailabilityMapVal( const NanFurtherAvailabilityMap *pFam, u8 *pOutValue) { int idx = 0; if (pFam && pOutValue) { u32 famsize = calcNanFurtherAvailabilityMapSize(pFam); pNanFurtherAvailabilityMapAttrTlv pFwReq = \ (pNanFurtherAvailabilityMapAttrTlv)pOutValue; memset(pOutValue, 0, famsize); pFwReq->numChan = pFam->numchans; for (idx = 0; idx < pFam->numchans; idx++) { const NanFurtherAvailabilityChannel *pFamChan = \ &pFam->famchan[idx]; pNanFurtherAvailabilityChan pFwFamChan = \ (pNanFurtherAvailabilityChan)((u8*)&pFwReq->pFaChan[0] + \ (idx * sizeof(NanFurtherAvailabilityChan))); pFwFamChan->entryCtrl.availIntDuration = \ pFamChan->entry_control; pFwFamChan->entryCtrl.mapId = \ pFamChan->mapid; pFwFamChan->opClass = pFamChan->class_val; pFwFamChan->channel = pFamChan->channel; memcpy(&pFwFamChan->availIntBitmap, &pFamChan->avail_interval_bitmap, sizeof(pFwFamChan->availIntBitmap)); } ALOGV("%s: Filled FurtherAvailabilityMapVal", __func__); hexdump((char*)pOutValue, famsize); } return; } int NanCommand::calcNanFurtherAvailabilityMapSize( const NanFurtherAvailabilityMap *pFam) { int ret = 0; if (pFam && pFam->numchans && pFam->numchans <= NAN_MAX_FAM_CHANNELS) { /* Fixed size of u8 for numchans*/ ret = sizeof(u8); /* numchans * sizeof(FamChannels) */ ret += (pFam->numchans * sizeof(NanFurtherAvailabilityChan)); } ALOGV("%s:size:%d", __func__, ret); return ret; } wifi_error NanCommand::putNanCapabilities(transaction_id id) { wifi_error ret; ALOGV("NAN_CAPABILITIES"); size_t message_len = sizeof(NanCapabilitiesReqMsg); pNanCapabilitiesReqMsg pFwReq = (pNanCapabilitiesReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } memset (pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_CAPABILITIES_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = id; mVendorData = (char*)pFwReq; mDataLen = message_len; ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; } wifi_error NanCommand::putNanDebugCommand(NanDebugParams debug, int debug_msg_length) { wifi_error ret; ALOGV("NAN_AVAILABILITY_DEBUG"); size_t message_len = sizeof(NanTestModeReqMsg); message_len += (SIZEOF_TLV_HDR + debug_msg_length); pNanTestModeReqMsg pFwReq = (pNanTestModeReqMsg)malloc(message_len); if (pFwReq == NULL) { cleanup(); return WIFI_ERROR_OUT_OF_MEMORY; } ALOGV("Message Len %zu\n", message_len); ALOGV("%s: Debug Command Type = 0x%x \n", __func__, debug.cmd); ALOGV("%s: ** Debug Command Data Start **", __func__); hexdump(debug.debug_cmd_data, debug_msg_length); ALOGV("%s: ** Debug Command Data End **", __func__); memset (pFwReq, 0, message_len); pFwReq->fwHeader.msgVersion = (u16)NAN_MSG_VERSION1; pFwReq->fwHeader.msgId = NAN_MSG_ID_TESTMODE_REQ; pFwReq->fwHeader.msgLen = message_len; pFwReq->fwHeader.transactionId = 0; u8* tlvs = pFwReq->ptlv; tlvs = addTlv(NAN_TLV_TYPE_TESTMODE_GENERIC_CMD, debug_msg_length, (const u8*)&debug, tlvs); mVendorData = (char*)pFwReq; mDataLen = message_len; /* Write the TLVs to the message. */ ret = mMsg.put_bytes(NL80211_ATTR_VENDOR_DATA, mVendorData, mDataLen); if (ret != WIFI_SUCCESS) { ALOGE("%s: put_bytes Error:%d",__func__, ret); cleanup(); return ret; } hexdump(mVendorData, mDataLen); return ret; }