/* * 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" int NanCommand::isNanResponse() { if (mNanVendorEvent == NULL) { ALOGE("NULL check failed"); return WIFI_ERROR_INVALID_ARGS; } NanMsgHeader *pHeader = (NanMsgHeader *)mNanVendorEvent; switch (pHeader->msgId) { case NAN_MSG_ID_ERROR_RSP: case NAN_MSG_ID_CONFIGURATION_RSP: case NAN_MSG_ID_PUBLISH_SERVICE_CANCEL_RSP: case NAN_MSG_ID_PUBLISH_SERVICE_RSP: case NAN_MSG_ID_SUBSCRIBE_SERVICE_RSP: case NAN_MSG_ID_SUBSCRIBE_SERVICE_CANCEL_RSP: case NAN_MSG_ID_TRANSMIT_FOLLOWUP_RSP: case NAN_MSG_ID_STATS_RSP: case NAN_MSG_ID_ENABLE_RSP: case NAN_MSG_ID_DISABLE_RSP: case NAN_MSG_ID_TCA_RSP: case NAN_MSG_ID_BEACON_SDF_RSP: case NAN_MSG_ID_CAPABILITIES_RSP: case NAN_MSG_ID_TESTMODE_RSP: return 1; default: return 0; } } struct verboseTlv { NanTlvType tlvType; char strTlv[NAN_ERROR_STR_LEN]; }; struct verboseTlv tlvToStr[] = { {NAN_TLV_TYPE_SDF_MATCH_FILTER, " SDF match filter"}, {NAN_TLV_TYPE_TX_MATCH_FILTER, " Tx match filter"}, {NAN_TLV_TYPE_RX_MATCH_FILTER, " Rx match filter"}, {NAN_TLV_TYPE_SERVICE_SPECIFIC_INFO, " Service specific info"}, {NAN_TLV_TYPE_EXT_SERVICE_SPECIFIC_INFO, " Extended Service specific info"}, {NAN_TLV_TYPE_VENDOR_SPECIFIC_ATTRIBUTE_TRANSMIT, " Vendor specific attribute transmit"}, {NAN_TLV_TYPE_VENDOR_SPECIFIC_ATTRIBUTE_RECEIVE, " Vendor specific attribute receive"}, {NAN_TLV_TYPE_POST_NAN_CONNECTIVITY_CAPABILITIES_RECEIVE, " Post Nan connectivity capability receive"}, {NAN_TLV_TYPE_POST_NAN_DISCOVERY_ATTRIBUTE_RECEIVE, " Post Nan discovery attribute receive"}, {NAN_TLV_TYPE_BEACON_SDF_PAYLOAD_RECEIVE, " Beacon SDF payload receive"}, /* Configuration types */ {NAN_TLV_TYPE_CONFIG_FIRST, " Config first"}, {NAN_TLV_TYPE_24G_SUPPORT, " 2.4G support"}, {NAN_TLV_TYPE_24G_BEACON, " 2.4G beacon"}, {NAN_TLV_TYPE_24G_SDF, " 2.4G SDF"}, {NAN_TLV_TYPE_24G_RSSI_CLOSE, " 2.4G RSSI close"}, {NAN_TLV_TYPE_24G_RSSI_MIDDLE, " 2.4G RSSI middle"}, {NAN_TLV_TYPE_24G_RSSI_CLOSE_PROXIMITY, " 2.4G RSSI close proximity"}, {NAN_TLV_TYPE_5G_SUPPORT, " 5G support"}, {NAN_TLV_TYPE_5G_BEACON, " 5G beacon"}, {NAN_TLV_TYPE_5G_SDF, " 5G SDF"}, {NAN_TLV_TYPE_5G_RSSI_CLOSE, " 5G RSSI close"}, {NAN_TLV_TYPE_5G_RSSI_MIDDLE, " 5G RSSI middle"}, {NAN_TLV_TYPE_5G_RSSI_CLOSE_PROXIMITY, " 5G RSSI close proximity"}, {NAN_TLV_TYPE_SID_BEACON, " SID beacon"}, {NAN_TLV_TYPE_HOP_COUNT_LIMIT, " Hop count limit"}, {NAN_TLV_TYPE_MASTER_PREFERENCE, " Master preference"}, {NAN_TLV_TYPE_CLUSTER_ID_LOW, " Cluster ID low"}, {NAN_TLV_TYPE_CLUSTER_ID_HIGH, " Cluster ID high"}, {NAN_TLV_TYPE_RSSI_AVERAGING_WINDOW_SIZE, " RSSI averaging window size"}, {NAN_TLV_TYPE_CLUSTER_OUI_NETWORK_ID, " Cluster OUI network ID"}, {NAN_TLV_TYPE_SOURCE_MAC_ADDRESS, " Source MAC address"}, {NAN_TLV_TYPE_CLUSTER_ATTRIBUTE_IN_SDF, " Cluster attribute in SDF"}, {NAN_TLV_TYPE_SOCIAL_CHANNEL_SCAN_PARAMS, " Social channel scan params"}, {NAN_TLV_TYPE_DEBUGGING_FLAGS, " Debugging flags"}, {NAN_TLV_TYPE_POST_NAN_CONNECTIVITY_CAPABILITIES_TRANSMIT, " Post nan connectivity capabilities transmit"}, {NAN_TLV_TYPE_POST_NAN_DISCOVERY_ATTRIBUTE_TRANSMIT, " Post nan discovery attribute transmit"}, {NAN_TLV_TYPE_FURTHER_AVAILABILITY_MAP, " Further availability map"}, {NAN_TLV_TYPE_HOP_COUNT_FORCE, " Hop count force"}, {NAN_TLV_TYPE_RANDOM_FACTOR_FORCE, " Random factor force"}, {NAN_TLV_TYPE_RANDOM_UPDATE_TIME, " Random update time"}, {NAN_TLV_TYPE_EARLY_WAKEUP, " Early wakeup"}, {NAN_TLV_TYPE_PERIODIC_SCAN_INTERVAL, " Periodic scan interval"}, {NAN_TLV_TYPE_DW_INTERVAL, " DW interval"}, {NAN_TLV_TYPE_DB_INTERVAL, " DB interval"}, {NAN_TLV_TYPE_FURTHER_AVAILABILITY, " Further availability"}, {NAN_TLV_TYPE_24G_CHANNEL, " 2.4G channel"}, {NAN_TLV_TYPE_5G_CHANNEL, " 5G channel"}, {NAN_TLV_TYPE_CONFIG_LAST, " Config last"}, /* Attributes types */ {NAN_TLV_TYPE_ATTRS_FIRST, " Attributes first"}, {NAN_TLV_TYPE_AVAILABILITY_INTERVALS_MAP, " Availability intervals map"}, {NAN_TLV_TYPE_WLAN_MESH_ID, " WLAN mesh ID"}, {NAN_TLV_TYPE_MAC_ADDRESS, " MAC address"}, {NAN_TLV_TYPE_RECEIVED_RSSI_VALUE, " Received RSSI value"}, {NAN_TLV_TYPE_CLUSTER_ATTRIBUTE, " Cluster attribute"}, {NAN_TLV_TYPE_WLAN_INFRA_SSID, " WLAN infra SSID"}, {NAN_TLV_TYPE_ATTRS_LAST, " Attributes last"}, /* Events Type */ {NAN_TLV_TYPE_EVENTS_FIRST, " Events first"}, {NAN_TLV_TYPE_EVENT_SELF_STATION_MAC_ADDRESS, " Event Self station MAC address"}, {NAN_TLV_TYPE_EVENT_STARTED_CLUSTER, " Event started cluster"}, {NAN_TLV_TYPE_EVENT_JOINED_CLUSTER, " Event joined cluster"}, {NAN_TLV_TYPE_EVENT_CLUSTER_SCAN_RESULTS, " Event cluster scan results"}, {NAN_TLV_TYPE_FAW_MEM_AVAIL, " FAW memory availability"}, {NAN_TLV_TYPE_EVENTS_LAST, " Events last"}, /* TCA types */ {NAN_TLV_TYPE_TCA_FIRST, " TCA-Threshold Crossing Alert first"}, {NAN_TLV_TYPE_CLUSTER_SIZE_REQ, " Cluster size request"}, {NAN_TLV_TYPE_CLUSTER_SIZE_RSP, " Cluster size response"}, {NAN_TLV_TYPE_TCA_LAST, " TCA last"}, /* Statistics types */ {NAN_TLV_TYPE_STATS_FIRST, " Stats first"}, {NAN_TLV_TYPE_DE_PUBLISH_STATS, " Discovery engine publish stats"}, {NAN_TLV_TYPE_DE_SUBSCRIBE_STATS, " Discovery engine subscribe stats"}, {NAN_TLV_TYPE_DE_MAC_STATS, " Discovery engine MAC stats"}, {NAN_TLV_TYPE_DE_TIMING_SYNC_STATS, " Discovery engine timing sync stats"}, {NAN_TLV_TYPE_DE_DW_STATS, " Discovery engine DW stats"}, {NAN_TLV_TYPE_DE_STATS, " Discovery engine stats"}, {NAN_TLV_TYPE_STATS_LAST, " Stats last"}, {NAN_TLV_TYPE_LAST, " Last"} }; struct errorCode { NanStatusType frameworkError; NanInternalStatusType firmwareError; char nan_error[NAN_ERROR_STR_LEN]; }; struct errorCode errorCodeTranslation[] = { {NAN_STATUS_SUCCESS, NAN_I_STATUS_SUCCESS, "NAN status success"}, {NAN_STATUS_INTERNAL_FAILURE, NAN_I_STATUS_DE_FAILURE, "NAN Discovery engine failure"}, {NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID, NAN_I_STATUS_INVALID_HANDLE, "Invalid Publish/Subscribe ID"}, {NAN_STATUS_NO_RESOURCE_AVAILABLE, NAN_I_STATUS_NO_SPACE_AVAILABLE, "No space available"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_PUBLISH_TYPE, "Invalid Publish type, can be 0 or 1"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TX_TYPE, "Invalid Tx type"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MSG_VERSION, "Invalid internal message version"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MSG_LEN, "Invalid message length"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MSG_ID, "Invalid message ID"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_MATCH_ALGORITHM, "Invalid matching algorithm, can be 0(match once), 1(match continuous) or 2(match never)"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TLV_LEN, "Invalid TLV length"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TLV_TYPE, "Invalid TLV type"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_MISSING_TLV_TYPE, "Missing TLV type"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TOTAL_TLVS_LEN, "Invalid total TLV length"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TLV_VALUE, "Invalid TLV value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_TX_PRIORITY, "Invalid Tx priority"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_CONNECTION_MAP, "Invalid connection map"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_THRESHOLD_CROSSING_ALERT_ID, "Invalid TCA-Threshold Crossing Alert ID"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_STATS_ID, "Invalid STATS ID"}, {NAN_STATUS_PROTOCOL_FAILURE, NAN_I_STATUS_TX_FAIL, "Tx Fail"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_RSSI_CLOSE_VALUE, "Invalid RSSI close value range is 20dbm to 60dbm"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_RSSI_MIDDLE_VALUE, "Invalid RSSI middle value range is 20dbm to 75dbm"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_HOP_COUNT_LIMIT, "Invalid hop count limit, max hop count limit is 5"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_HIGH_CLUSTER_ID_VALUE, "Invalid cluster ID value. Please set the cluster id high greater than the cluster id low"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_BACKGROUND_SCAN_PERIOD, "Invalid background scan period. The range is 10 to 30 milliseconds"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_SCAN_CHANNEL, "Invalid scan channel. Only valid channels are the NAN social channels"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_CONNECTIVITY_CAPABILITIES_BITMAP, "Invalid post nan connectivity bitmap"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_NUMCHAN_VALUE, "Invalid further availability map number of channel value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_DURATION_VALUE, "Invalid further availability map duration value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_CLASS_VALUE, "Invalid further availability map class value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_CHANNEL_VALUE, "Invalid further availability map channel value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_AVAILABILITY_INTERVAL_BITMAP_VALUE, "Invalid further availability map availability interval bitmap value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_FURTHER_AVAILABILITY_MAP_MAP_ID, "Invalid further availability map map ID"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_CONN_TYPE_VALUE, "Invalid post nan discovery connection type value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_DEVICE_ROLE_VALUE, "Invalid post nan discovery device role value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_DURATION_VALUE, "Invalid post nan discovery duration value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_POST_NAN_DISCOVERY_BITMAP_VALUE, "Invalid post nan discovery bitmap value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_MISSING_FUTHER_AVAILABILITY_MAP, "Missing further availability map"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_BAND_CONFIG_FLAGS, "Invalid band configuration flags"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_RANDOM_FACTOR_UPDATE_TIME_VALUE, "Invalid random factor update time value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_ONGOING_SCAN_PERIOD, "Invalid ongoing scan period"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_DW_INTERVAL_VALUE, "Invalid DW interval value"}, {NAN_STATUS_INVALID_PARAM, NAN_I_STATUS_INVALID_DB_INTERVAL_VALUE, "Invalid DB interval value"}, {NAN_STATUS_SUCCESS, NAN_I_PUBLISH_SUBSCRIBE_TERMINATED_REASON_TIMEOUT, "Terminated Reason: Timeout"}, {NAN_STATUS_SUCCESS, NAN_I_PUBLISH_SUBSCRIBE_TERMINATED_REASON_USER_REQUEST, "Terminated Reason: User Request"}, {NAN_STATUS_SUCCESS, NAN_I_PUBLISH_SUBSCRIBE_TERMINATED_REASON_COUNT_REACHED, "Terminated Reason: Count Reached"}, {NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID, NAN_I_STATUS_INVALID_REQUESTER_INSTANCE_ID, "Invalid match handle"}, {NAN_STATUS_NAN_NOT_ALLOWED, NAN_I_STATUS_NAN_NOT_ALLOWED, "Nan not allowed"}, {NAN_STATUS_NO_OTA_ACK, NAN_I_STATUS_NO_OTA_ACK, "No OTA ack"}, {NAN_STATUS_ALREADY_ENABLED, NAN_I_STATUS_NAN_ALREADY_ENABLED, "NAN is Already enabled"}, {NAN_STATUS_FOLLOWUP_QUEUE_FULL, NAN_I_STATUS_FOLLOWUP_QUEUE_FULL, "Follow-up queue full"}, {NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED, NDP_I_UNSUPPORTED_CONCURRENCY, "Unsupported Concurrency"}, {NAN_STATUS_INTERNAL_FAILURE, NDP_I_NAN_DATA_IFACE_CREATE_FAILED, "NAN data interface create failed"}, {NAN_STATUS_INTERNAL_FAILURE, NDP_I_NAN_DATA_IFACE_DELETE_FAILED, "NAN data interface delete failed"}, {NAN_STATUS_INTERNAL_FAILURE, NDP_I_DATA_INITIATOR_REQUEST_FAILED, "NAN data initiator request failed"}, {NAN_STATUS_INTERNAL_FAILURE, NDP_I_DATA_RESPONDER_REQUEST_FAILED, "NAN data responder request failed"}, {NAN_STATUS_INVALID_NDP_ID, NDP_I_INVALID_NDP_INSTANCE_ID, "Invalid NDP instance ID"}, {NAN_STATUS_INVALID_PARAM, NDP_I_INVALID_RESPONSE_CODE, "Invalid response code"}, {NAN_STATUS_INVALID_PARAM, NDP_I_INVALID_APP_INFO_LEN, "Invalid app info length"}, {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_REQUEST_FAILED, "Management frame request failed"}, {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_RESPONSE_FAILED, "Management frame response failed"}, {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_CONFIRM_FAILED, "Management frame confirm failed"}, {NAN_STATUS_INTERNAL_FAILURE, NDP_I_END_FAILED, "NDP end failed"}, {NAN_STATUS_PROTOCOL_FAILURE, NDP_I_MGMT_FRAME_END_REQUEST_FAILED, "Management frame end request failed"}, {NAN_STATUS_INTERNAL_FAILURE, NDP_I_VENDOR_SPECIFIC_ERROR, "Vendor specific error"} }; void NanCommand::NanErrorTranslation(NanInternalStatusType firmwareErrorRecvd, u32 valueRcvd, void* pResponse, bool is_ndp_rsp) { int i = 0, j = 0; u16 msg_id; /* Based on the message_id in the header determine the Indication type */ NanResponseMsg *pRsp; NanPublishTerminatedInd* pRspInd; NanDisabledInd* pRspdInd; char tlvInfo[NAN_ERROR_STR_LEN]; tlvInfo[0] = '\0'; if ((is_ndp_rsp == true) || isNanResponse()) { pRsp = (NanResponseMsg*)pResponse; for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) { if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) { pRsp->status = errorCodeTranslation[i].frameworkError; strlcpy(pRsp->nan_error, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN); if (NAN_I_STATUS_INVALID_TLV_TYPE == firmwareErrorRecvd) { for (j = 0; j < (int)(sizeof(tlvToStr)/sizeof(verboseTlv)); j++) { if (tlvToStr[j].tlvType == valueRcvd) { strlcpy(tlvInfo, tlvToStr[i].strTlv, NAN_ERROR_STR_LEN); break; } } } strlcat(pRsp->nan_error, tlvInfo, sizeof(pRsp->nan_error)); break; } } if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) { pRsp->status = NAN_STATUS_INTERNAL_FAILURE; strlcpy(pRsp->nan_error, "NAN Discovery engine failure", NAN_ERROR_STR_LEN); } ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRsp->status, valueRcvd, pRsp->nan_error); } else { msg_id = getIndicationType(); switch(msg_id) { case NAN_INDICATION_PUBLISH_TERMINATED: case NAN_INDICATION_SUBSCRIBE_TERMINATED: case NAN_INDICATION_SELF_TRANSMIT_FOLLOWUP: pRspInd = (NanPublishTerminatedInd*)pResponse; for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) { if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) { pRspInd->reason = errorCodeTranslation[i].frameworkError; strlcpy(pRspInd->nan_reason, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN); break; } } if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) { pRspInd->reason = NAN_STATUS_INTERNAL_FAILURE; strlcpy(pRspInd->nan_reason, "NAN Discovery engine failure", NAN_ERROR_STR_LEN); } ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRspInd->reason, valueRcvd, pRspInd->nan_reason); break; case NAN_INDICATION_DISABLED: pRspdInd = (NanDisabledInd*)pResponse; for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) { if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) { pRspdInd->reason = errorCodeTranslation[i].frameworkError; strlcpy(pRspdInd->nan_reason, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN); break; } } if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) { pRspdInd->reason = NAN_STATUS_INTERNAL_FAILURE; strlcpy(pRspdInd->nan_reason, "NAN Discovery engine failure", NAN_ERROR_STR_LEN); } ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRspdInd->reason, valueRcvd, pRspdInd->nan_reason); break; } } } int NanCommand::getNanResponse(transaction_id *id, NanResponseMsg *pRsp) { if (mNanVendorEvent == NULL || pRsp == NULL) { ALOGE("NULL check failed"); return WIFI_ERROR_INVALID_ARGS; } NanMsgHeader *pHeader = (NanMsgHeader *)mNanVendorEvent; switch (pHeader->msgId) { case NAN_MSG_ID_ERROR_RSP: { pNanErrorRspMsg pFwRsp = \ (pNanErrorRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_ERROR; break; } case NAN_MSG_ID_CONFIGURATION_RSP: { pNanConfigurationRspMsg pFwRsp = \ (pNanConfigurationRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_CONFIG; } break; case NAN_MSG_ID_PUBLISH_SERVICE_CANCEL_RSP: { pNanPublishServiceCancelRspMsg pFwRsp = \ (pNanPublishServiceCancelRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_PUBLISH_CANCEL; pRsp->body.publish_response.publish_id = \ pFwRsp->fwHeader.handle; break; } case NAN_MSG_ID_PUBLISH_SERVICE_RSP: { pNanPublishServiceRspMsg pFwRsp = \ (pNanPublishServiceRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_PUBLISH; pRsp->body.publish_response.publish_id = \ pFwRsp->fwHeader.handle; break; } case NAN_MSG_ID_SUBSCRIBE_SERVICE_RSP: { pNanSubscribeServiceRspMsg pFwRsp = \ (pNanSubscribeServiceRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_SUBSCRIBE; pRsp->body.subscribe_response.subscribe_id = \ pFwRsp->fwHeader.handle; } break; case NAN_MSG_ID_SUBSCRIBE_SERVICE_CANCEL_RSP: { pNanSubscribeServiceCancelRspMsg pFwRsp = \ (pNanSubscribeServiceCancelRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_SUBSCRIBE_CANCEL; pRsp->body.subscribe_response.subscribe_id = \ pFwRsp->fwHeader.handle; break; } case NAN_MSG_ID_TRANSMIT_FOLLOWUP_RSP: { pNanTransmitFollowupRspMsg pFwRsp = \ (pNanTransmitFollowupRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_TRANSMIT_FOLLOWUP; break; } case NAN_MSG_ID_STATS_RSP: { pNanStatsRspMsg pFwRsp = \ (pNanStatsRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->statsRspParams.status, pFwRsp->statsRspParams.value, pRsp, false); pRsp->response_type = NAN_RESPONSE_STATS; pRsp->body.stats_response.stats_type = \ (NanStatsType)pFwRsp->statsRspParams.statsType; ALOGV("%s: stats_type:%d",__func__, pRsp->body.stats_response.stats_type); u8 *pInputTlv = pFwRsp->ptlv; NanTlv outputTlv; memset(&outputTlv, 0, sizeof(outputTlv)); u16 readLen = 0; int remainingLen = (mNanDataLen - \ (sizeof(NanMsgHeader) + sizeof(NanStatsRspParams))); if (remainingLen > 0) { readLen = NANTLV_ReadTlv(pInputTlv, &outputTlv); ALOGV("%s: Remaining Len:%d readLen:%d type:%d length:%d", __func__, remainingLen, readLen, outputTlv.type, outputTlv.length); if (outputTlv.length <= \ sizeof(pRsp->body.stats_response.data)) { handleNanStatsResponse(pRsp->body.stats_response.stats_type, (char *)outputTlv.value, &pRsp->body.stats_response, outputTlv.length); } } else ALOGV("%s: No TLV's present",__func__); break; } case NAN_MSG_ID_ENABLE_RSP: { pNanEnableRspMsg pFwRsp = \ (pNanEnableRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_ENABLED; break; } case NAN_MSG_ID_DISABLE_RSP: { pNanDisableRspMsg pFwRsp = \ (pNanDisableRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, 0, pRsp, false); pRsp->response_type = NAN_RESPONSE_DISABLED; break; } case NAN_MSG_ID_TCA_RSP: { pNanTcaRspMsg pFwRsp = \ (pNanTcaRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_RESPONSE_TCA; break; } case NAN_MSG_ID_BEACON_SDF_RSP: { pNanBeaconSdfPayloadRspMsg pFwRsp = \ (pNanBeaconSdfPayloadRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, 0, pRsp, false); pRsp->response_type = NAN_RESPONSE_BEACON_SDF_PAYLOAD; break; } case NAN_MSG_ID_CAPABILITIES_RSP: { pNanCapabilitiesRspMsg pFwRsp = \ (pNanCapabilitiesRspMsg)mNanVendorEvent; *id = (transaction_id)pFwRsp->fwHeader.transactionId; NanErrorTranslation((NanInternalStatusType)pFwRsp->status, pFwRsp->value, pRsp, false); pRsp->response_type = NAN_GET_CAPABILITIES; pRsp->body.nan_capabilities.max_concurrent_nan_clusters = \ pFwRsp->max_concurrent_nan_clusters; pRsp->body.nan_capabilities.max_publishes = \ pFwRsp->max_publishes; pRsp->body.nan_capabilities.max_subscribes = \ pFwRsp->max_subscribes; pRsp->body.nan_capabilities.max_service_name_len = \ pFwRsp->max_service_name_len; pRsp->body.nan_capabilities.max_match_filter_len = \ pFwRsp->max_match_filter_len; pRsp->body.nan_capabilities.max_total_match_filter_len = \ pFwRsp->max_total_match_filter_len; pRsp->body.nan_capabilities.max_service_specific_info_len = \ pFwRsp->max_service_specific_info_len; pRsp->body.nan_capabilities.max_vsa_data_len = \ pFwRsp->max_vsa_data_len; pRsp->body.nan_capabilities.max_mesh_data_len = \ pFwRsp->max_mesh_data_len; pRsp->body.nan_capabilities.max_ndi_interfaces = \ pFwRsp->max_ndi_interfaces; pRsp->body.nan_capabilities.max_ndp_sessions = \ pFwRsp->max_ndp_sessions; pRsp->body.nan_capabilities.max_app_info_len = \ pFwRsp->max_app_info_len; pRsp->body.nan_capabilities.max_queued_transmit_followup_msgs = \ pFwRsp->max_queued_transmit_followup_msgs; pRsp->body.nan_capabilities.ndp_supported_bands = \ pFwRsp->ndp_supported_bands; pRsp->body.nan_capabilities.cipher_suites_supported = \ pFwRsp->cipher_suites_supported; pRsp->body.nan_capabilities.max_scid_len = \ pFwRsp->max_scid_len; pRsp->body.nan_capabilities.is_ndp_security_supported = \ pFwRsp->is_ndp_security_supported; pRsp->body.nan_capabilities.max_sdea_service_specific_info_len = \ pFwRsp->max_sdea_service_specific_info_len; pRsp->body.nan_capabilities.max_subscribe_address = \ pFwRsp->max_subscribe_address; pRsp->body.nan_capabilities.ndpe_attr_supported = \ pFwRsp->ndpe_attr_supported; break; } default: return -1; } return 0; } int NanCommand::handleNanResponse() { //parse the data and call //the response callback handler with the populated //NanResponseMsg NanResponseMsg rsp_data; int ret; transaction_id id; ALOGV("handleNanResponse called %p", this); memset(&rsp_data, 0, sizeof(rsp_data)); //get the rsp_data ret = getNanResponse(&id, &rsp_data); ALOGI("handleNanResponse ret:%d status:%u value:%s response_type:%u", ret, rsp_data.status, rsp_data.nan_error, rsp_data.response_type); if (ret == 0 && (rsp_data.response_type == NAN_RESPONSE_STATS) && (mStaParam != NULL) && (rsp_data.body.stats_response.stats_type == NAN_STATS_ID_DE_TIMING_SYNC)) { /* Fill the staParam with appropriate values and return from here. No need to call NotifyResponse as the request is for getting the STA response */ NanSyncStats *pSyncStats = &rsp_data.body.stats_response.data.sync_stats; mStaParam->master_rank = pSyncStats->myRank; mStaParam->master_pref = (pSyncStats->myRank & 0xFF00000000000000) >> 56; mStaParam->random_factor = (pSyncStats->myRank & 0x00FF000000000000) >> 48; mStaParam->hop_count = pSyncStats->currAmHopCount; mStaParam->beacon_transmit_time = pSyncStats->currAmBTT; mStaParam->ndp_channel_freq = pSyncStats->ndpChannelFreq; ALOGI("%s:0x%02x master_pref 0x%02x random_factor 0x%02x hop_count %u Channel", __func__, mStaParam->master_pref, mStaParam->random_factor, mStaParam->hop_count, mStaParam->ndp_channel_freq); return ret; } //Call the NotifyResponse Handler if (ret == 0 && mHandler.NotifyResponse) { (*mHandler.NotifyResponse)(id, &rsp_data); } return ret; } void NanCommand::handleNanStatsResponse(NanStatsType stats_type, char *rspBuf, NanStatsResponse *pRsp, u32 message_len) { if (stats_type == NAN_STATS_ID_DE_PUBLISH) { NanPublishStats publish_stats; if (message_len != sizeof(NanPublishStats)) { ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n", __func__, stats_type, message_len, sizeof(NanPublishStats)); return; } FwNanPublishStats *pPubStats = (FwNanPublishStats *)rspBuf; publish_stats.validPublishServiceReqMsgs = pPubStats->validPublishServiceReqMsgs; publish_stats.validPublishServiceRspMsgs = pPubStats->validPublishServiceRspMsgs; publish_stats.validPublishServiceCancelReqMsgs = pPubStats->validPublishServiceCancelReqMsgs; publish_stats.validPublishServiceCancelRspMsgs = pPubStats->validPublishServiceCancelRspMsgs; publish_stats.validPublishRepliedIndMsgs = pPubStats->validPublishRepliedIndMsgs; publish_stats.validPublishTerminatedIndMsgs = pPubStats->validPublishTerminatedIndMsgs; publish_stats.validActiveSubscribes = pPubStats->validActiveSubscribes; publish_stats.validMatches = pPubStats->validMatches; publish_stats.validFollowups = pPubStats->validFollowups; publish_stats.invalidPublishServiceReqMsgs = pPubStats->invalidPublishServiceReqMsgs; publish_stats.invalidPublishServiceCancelReqMsgs = pPubStats->invalidPublishServiceCancelReqMsgs; publish_stats.invalidActiveSubscribes = pPubStats->invalidActiveSubscribes; publish_stats.invalidMatches = pPubStats->invalidMatches; publish_stats.invalidFollowups = pPubStats->invalidFollowups; publish_stats.publishCount = pPubStats->publishCount; publish_stats.publishNewMatchCount = pPubStats->publishNewMatchCount; publish_stats.pubsubGlobalNewMatchCount = pPubStats->pubsubGlobalNewMatchCount; memcpy(&pRsp->data.publish_stats, &publish_stats, sizeof(NanPublishStats)); } else if (stats_type == NAN_STATS_ID_DE_SUBSCRIBE) { NanSubscribeStats sub_stats; if (message_len != sizeof(NanSubscribeStats)) { ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n", __func__, stats_type, message_len, sizeof(NanSubscribeStats)); return; } FwNanSubscribeStats *pSubStats = (FwNanSubscribeStats *)rspBuf; sub_stats.validSubscribeServiceReqMsgs = pSubStats->validSubscribeServiceReqMsgs; sub_stats.validSubscribeServiceRspMsgs = pSubStats->validSubscribeServiceRspMsgs; sub_stats.validSubscribeServiceCancelReqMsgs = pSubStats->validSubscribeServiceCancelReqMsgs; sub_stats.validSubscribeServiceCancelRspMsgs = pSubStats->validSubscribeServiceCancelRspMsgs; sub_stats.validSubscribeTerminatedIndMsgs = pSubStats->validSubscribeTerminatedIndMsgs; sub_stats.validSubscribeMatchIndMsgs = pSubStats->validSubscribeMatchIndMsgs; sub_stats.validSubscribeUnmatchIndMsgs = pSubStats->validSubscribeUnmatchIndMsgs; sub_stats.validSolicitedPublishes = pSubStats->validSolicitedPublishes; sub_stats.validMatches = pSubStats->validMatches; sub_stats.validFollowups = pSubStats->validFollowups; sub_stats.invalidSubscribeServiceReqMsgs = pSubStats->invalidSubscribeServiceReqMsgs; sub_stats.invalidSubscribeServiceCancelReqMsgs = pSubStats->invalidSubscribeServiceCancelReqMsgs; sub_stats.invalidSubscribeFollowupReqMsgs = pSubStats->invalidSubscribeFollowupReqMsgs; sub_stats.invalidSolicitedPublishes = pSubStats->invalidSolicitedPublishes; sub_stats.invalidMatches = pSubStats->invalidMatches; sub_stats.invalidFollowups = pSubStats->invalidFollowups; sub_stats.subscribeCount = pSubStats->subscribeCount; sub_stats.bloomFilterIndex = pSubStats->bloomFilterIndex; sub_stats.subscribeNewMatchCount = pSubStats->subscribeNewMatchCount; sub_stats.pubsubGlobalNewMatchCount = pSubStats->pubsubGlobalNewMatchCount; memcpy(&pRsp->data.subscribe_stats, &sub_stats, sizeof(NanSubscribeStats)); } else if (stats_type == NAN_STATS_ID_DE_DW) { NanDWStats dw_stats; if (message_len != sizeof(NanDWStats)) { ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n", __func__, stats_type, message_len, sizeof(NanDWStats)); return; } FwNanMacStats *pMacStats = (FwNanMacStats *)rspBuf; dw_stats.validFrames = pMacStats->validFrames; dw_stats.validActionFrames = pMacStats->validActionFrames; dw_stats.validBeaconFrames = pMacStats->validBeaconFrames; dw_stats.ignoredActionFrames = pMacStats->ignoredActionFrames; dw_stats.ignoredBeaconFrames = pMacStats->ignoredBeaconFrames; dw_stats.invalidFrames = pMacStats->invalidFrames; dw_stats.invalidActionFrames = pMacStats->invalidActionFrames; dw_stats.invalidBeaconFrames = pMacStats->invalidBeaconFrames; dw_stats.invalidMacHeaders = pMacStats->invalidMacHeaders; dw_stats.invalidPafHeaders = pMacStats->invalidPafHeaders; dw_stats.nonNanBeaconFrames = pMacStats->nonNanBeaconFrames; dw_stats.earlyActionFrames = pMacStats->earlyActionFrames; dw_stats.inDwActionFrames = pMacStats->inDwActionFrames; dw_stats.lateActionFrames = pMacStats->lateActionFrames; dw_stats.framesQueued = pMacStats->framesQueued; dw_stats.totalTRSpUpdates = pMacStats->totalTRSpUpdates; dw_stats.completeByTRSp = pMacStats->completeByTRSp; dw_stats.completeByTp75DW = pMacStats->completeByTp75DW; dw_stats.completeByTendDW = pMacStats->completeByTendDW; dw_stats.lateActionFramesTx = pMacStats->lateActionFramesTx; memcpy(&pRsp->data.dw_stats, &dw_stats, sizeof(NanDWStats)); } else if (stats_type == NAN_STATS_ID_DE_MAC) { NanMacStats mac_stats; if (message_len != sizeof(NanMacStats)) { ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n", __func__, stats_type, message_len, sizeof(NanMacStats)); return; } FwNanMacStats *pMacStats = (FwNanMacStats *)rspBuf; mac_stats.validFrames = pMacStats->validFrames; mac_stats.validActionFrames = pMacStats->validActionFrames; mac_stats.validBeaconFrames = pMacStats->validBeaconFrames; mac_stats.ignoredActionFrames = pMacStats->ignoredActionFrames; mac_stats.ignoredBeaconFrames = pMacStats->ignoredBeaconFrames; mac_stats.invalidFrames = pMacStats->invalidFrames; mac_stats.invalidActionFrames = pMacStats->invalidActionFrames; mac_stats.invalidBeaconFrames = pMacStats->invalidBeaconFrames; mac_stats.invalidMacHeaders = pMacStats->invalidMacHeaders; mac_stats.invalidPafHeaders = pMacStats->invalidPafHeaders; mac_stats.nonNanBeaconFrames = pMacStats->nonNanBeaconFrames; mac_stats.earlyActionFrames = pMacStats->earlyActionFrames; mac_stats.inDwActionFrames = pMacStats->inDwActionFrames; mac_stats.lateActionFrames = pMacStats->lateActionFrames; mac_stats.framesQueued = pMacStats->framesQueued; mac_stats.totalTRSpUpdates = pMacStats->totalTRSpUpdates; mac_stats.completeByTRSp = pMacStats->completeByTRSp; mac_stats.completeByTp75DW = pMacStats->completeByTp75DW; mac_stats.completeByTendDW = pMacStats->completeByTendDW; mac_stats.lateActionFramesTx = pMacStats->lateActionFramesTx; mac_stats.twIncreases = pMacStats->twIncreases; mac_stats.twDecreases = pMacStats->twDecreases; mac_stats.twChanges = pMacStats->twChanges; mac_stats.twHighwater = pMacStats->twHighwater; mac_stats.bloomFilterIndex = pMacStats->bloomFilterIndex; memcpy(&pRsp->data.mac_stats, &mac_stats, sizeof(NanMacStats)); } else if (stats_type == NAN_STATS_ID_DE_TIMING_SYNC) { NanSyncStats sync_stats; if (message_len != sizeof(NanSyncStats)) { ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n", __func__, stats_type, message_len, sizeof(NanSyncStats)); return; } FwNanSyncStats *pSyncStats = (FwNanSyncStats *)rspBuf; sync_stats.currTsf = pSyncStats->currTsf; sync_stats.myRank = pSyncStats->myRank; sync_stats.currAmRank = pSyncStats->currAmRank; sync_stats.lastAmRank = pSyncStats->lastAmRank; sync_stats.currAmBTT = pSyncStats->currAmBTT; sync_stats.lastAmBTT = pSyncStats->lastAmBTT; sync_stats.currAmHopCount = pSyncStats->currAmHopCount; sync_stats.currRole = pSyncStats->currRole; sync_stats.currClusterId = pSyncStats->currClusterId; sync_stats.timeSpentInCurrRole = pSyncStats->timeSpentInCurrRole; sync_stats.totalTimeSpentAsMaster = pSyncStats->totalTimeSpentAsMaster; sync_stats.totalTimeSpentAsNonMasterSync = pSyncStats->totalTimeSpentAsNonMasterSync; sync_stats.totalTimeSpentAsNonMasterNonSync = pSyncStats->totalTimeSpentAsNonMasterNonSync; sync_stats.transitionsToAnchorMaster = pSyncStats->transitionsToAnchorMaster; sync_stats.transitionsToMaster = pSyncStats->transitionsToMaster; sync_stats.transitionsToNonMasterSync = pSyncStats->transitionsToNonMasterSync; sync_stats.transitionsToNonMasterNonSync = pSyncStats->transitionsToNonMasterNonSync; sync_stats.amrUpdateCount = pSyncStats->amrUpdateCount; sync_stats.amrUpdateRankChangedCount = pSyncStats->amrUpdateRankChangedCount; sync_stats.amrUpdateBTTChangedCount = pSyncStats->amrUpdateBTTChangedCount; sync_stats.amrUpdateHcChangedCount = pSyncStats->amrUpdateHcChangedCount; sync_stats.amrUpdateNewDeviceCount = pSyncStats->amrUpdateNewDeviceCount; sync_stats.amrExpireCount = pSyncStats->amrExpireCount; sync_stats.mergeCount = pSyncStats->mergeCount; sync_stats.beaconsAboveHcLimit = pSyncStats->beaconsAboveHcLimit; sync_stats.beaconsBelowRssiThresh = pSyncStats->beaconsBelowRssiThresh; sync_stats.beaconsIgnoredNoSpace = pSyncStats->beaconsIgnoredNoSpace; sync_stats.beaconsForOurCluster = pSyncStats->beaconsForOtherCluster; sync_stats.beaconsForOtherCluster = pSyncStats->beaconsForOtherCluster; sync_stats.beaconCancelRequests = pSyncStats->beaconCancelRequests; sync_stats.beaconCancelFailures = pSyncStats->beaconCancelFailures; sync_stats.beaconUpdateRequests = pSyncStats->beaconUpdateRequests; sync_stats.beaconUpdateFailures = pSyncStats->beaconUpdateFailures; sync_stats.syncBeaconTxAttempts = pSyncStats->syncBeaconTxAttempts; sync_stats.syncBeaconTxFailures = pSyncStats->syncBeaconTxFailures; sync_stats.discBeaconTxAttempts = pSyncStats->discBeaconTxAttempts; sync_stats.discBeaconTxFailures = pSyncStats->discBeaconTxFailures; sync_stats.amHopCountExpireCount = pSyncStats->amHopCountExpireCount; sync_stats.ndpChannelFreq = pSyncStats->ndpChannelFreq; sync_stats.ndpChannelFreq2 = pSyncStats->ndpChannelFreq2; sync_stats.schedUpdateChannelFreq = pSyncStats->schedUpdateChannelFreq; memcpy(&pRsp->data.sync_stats, &sync_stats, sizeof(NanSyncStats)); } else if (stats_type == NAN_STATS_ID_DE) { NanDeStats de_stats; if (message_len != sizeof(NanDeStats)) { ALOGE("%s: stats_type = %d invalid stats length = %u expected length = %zu\n", __func__, stats_type, message_len, sizeof(NanDeStats)); return; } FwNanDeStats *pDeStats = (FwNanDeStats *)rspBuf; de_stats.validErrorRspMsgs = pDeStats->validErrorRspMsgs; de_stats.validTransmitFollowupReqMsgs = pDeStats->validTransmitFollowupReqMsgs; de_stats.validTransmitFollowupRspMsgs = pDeStats->validTransmitFollowupRspMsgs; de_stats.validFollowupIndMsgs = pDeStats->validFollowupIndMsgs; de_stats.validConfigurationReqMsgs = pDeStats->validConfigurationReqMsgs; de_stats.validConfigurationRspMsgs = pDeStats->validConfigurationRspMsgs; de_stats.validStatsReqMsgs = pDeStats->validStatsReqMsgs; de_stats.validStatsRspMsgs = pDeStats->validStatsRspMsgs; de_stats.validEnableReqMsgs = pDeStats->validEnableReqMsgs; de_stats.validEnableRspMsgs = pDeStats->validEnableRspMsgs; de_stats.validDisableReqMsgs = pDeStats->validDisableReqMsgs; de_stats.validDisableRspMsgs = pDeStats->validDisableRspMsgs; de_stats.validDisableIndMsgs = pDeStats->validDisableIndMsgs; de_stats.validEventIndMsgs = pDeStats->validEventIndMsgs; de_stats.validTcaReqMsgs = pDeStats->validTcaReqMsgs; de_stats.validTcaRspMsgs = pDeStats->validTcaRspMsgs; de_stats.validTcaIndMsgs = pDeStats->validTcaIndMsgs; de_stats.invalidTransmitFollowupReqMsgs = pDeStats->invalidTransmitFollowupReqMsgs; de_stats.invalidConfigurationReqMsgs = pDeStats->invalidConfigurationReqMsgs; de_stats.invalidStatsReqMsgs = pDeStats->invalidStatsReqMsgs; de_stats.invalidEnableReqMsgs = pDeStats->invalidEnableReqMsgs; de_stats.invalidDisableReqMsgs = pDeStats->invalidDisableReqMsgs; de_stats.invalidTcaReqMsgs = pDeStats->invalidTcaReqMsgs; memcpy(&pRsp->data.de_stats, &de_stats, sizeof(NanDeStats)); } else { ALOGE("Unknown stats_type:%d\n", stats_type); } } int NanCommand::handleNdpResponse(NanResponseType ndpCmdType, struct nlattr **tb_vendor) { //parse the data and call //the response callback handler with the populated //NanResponseMsg NanResponseMsg rsp_data; transaction_id id; memset(&rsp_data, 0, sizeof(rsp_data)); if ((!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]) || (!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE]) || (!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE])) { ALOGE("%s: QCA_WLAN_VENDOR_ATTR_NDP not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } id = nla_get_u16(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_TRANSACTION_ID]); ALOGD("%s: Transaction id : val %d", __FUNCTION__, id); NanErrorTranslation((NanInternalStatusType)nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RESPONSE_STATUS_TYPE]), nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_DRV_RETURN_VALUE]), &rsp_data, true); rsp_data.response_type = ndpCmdType; if (ndpCmdType == NAN_DP_INITIATOR_RESPONSE) { if (!tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID]) { ALOGE("%s: QCA_WLAN_VENDOR_ATTR_NDP not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } rsp_data.body.data_request_response.ndp_instance_id = nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_NDP_INSTANCE_ID]); } //Call the NotifyResponse Handler if (mHandler.NotifyResponse) { (*mHandler.NotifyResponse)(id, &rsp_data); } return WIFI_SUCCESS; }