| /* |
| * Copyright (C) 2016, 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 "offload_utils.h" |
| |
| #include <android-base/logging.h> |
| #include <chre/apps/wifi_offload/error_codes.h> |
| |
| namespace { |
| |
| bool ToHidlRecordName(const wifi_offload::RpcLogRecord::RpcLogRecordType& chreRecordType, |
| android::hardware::wifi::offload::V1_0::RecordName* hidlRecordName) { |
| bool result = true; |
| switch (chreRecordType) { |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_INIT: |
| *hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::CMD_INT; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_CONFIG_SCANS: |
| *hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::CMD_CONFIG_SCANS; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_SUBSCRIBE_SCAN_RESULTS: |
| *hidlRecordName = |
| android::hardware::wifi::offload::V1_0::RecordName::CMD_SUBSCRIBE_SCAN_RESULTS; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_UNSUBSCRIBE_SCAN_RESULTS: |
| *hidlRecordName = |
| android::hardware::wifi::offload::V1_0::RecordName::CMD_UNSUBSCRIBE_SCAN_RESULTS; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_GET_SCAN_STATS: |
| *hidlRecordName = |
| android::hardware::wifi::offload::V1_0::RecordName::CMD_GET_SCAN_STATS; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_RESET: |
| *hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::CMD_RESET; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_RECVD_SCAN_RESULT_ASYNC: |
| *hidlRecordName = |
| android::hardware::wifi::offload::V1_0::RecordName::EVENT_RECVD_SCAN_RESULT_ASYNC; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_RECVD_SCAN_RESULT: |
| *hidlRecordName = |
| android::hardware::wifi::offload::V1_0::RecordName::EVENT_RECVD_SCAN_RESULT; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_SENT_SCAN_RESULT: |
| *hidlRecordName = |
| android::hardware::wifi::offload::V1_0::RecordName::EVENT_SENT_SCAN_RESULT; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_SENT_ABORT: |
| *hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::EVENT_SENT_ABORT; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_SENT_ERROR: |
| *hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::EVENT_SENT_ERROR; |
| break; |
| case wifi_offload::RpcLogRecord::RpcLogRecordType::REQ_SCAN: |
| *hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::REQ_SCAN; |
| break; |
| default: |
| result = false; |
| break; |
| } |
| return result; |
| } |
| |
| uint8_t ToChreSecurityMode(uint8_t hidlSecurityMode) { |
| uint8_t chreSecurityMode = 0; |
| if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::OPEN) { |
| chreSecurityMode |= wifi_offload::SecurityMode::OPEN; |
| } |
| if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::WEP) { |
| chreSecurityMode |= wifi_offload::SecurityMode::WEP; |
| } |
| if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::PSK) { |
| chreSecurityMode |= wifi_offload::SecurityMode::PSK; |
| } |
| if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::EAP) { |
| chreSecurityMode |= wifi_offload::SecurityMode::EAP; |
| } |
| return chreSecurityMode; |
| } |
| |
| uint8_t ToHidlSecurityMode(uint8_t chreSecurityMode) { |
| uint8_t hidlSecurityMode = 0; |
| if (chreSecurityMode & wifi_offload::SecurityMode::OPEN) { |
| hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::OPEN; |
| } |
| if (chreSecurityMode & wifi_offload::SecurityMode::WEP) { |
| hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::WEP; |
| } |
| if (chreSecurityMode & wifi_offload::SecurityMode::PSK) { |
| hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::PSK; |
| } |
| if (chreSecurityMode & wifi_offload::SecurityMode::EAP) { |
| hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::EAP; |
| } |
| return hidlSecurityMode; |
| } |
| |
| } // namespace |
| |
| namespace android { |
| namespace hardware { |
| namespace wifi { |
| namespace offload { |
| namespace V1_0 { |
| namespace implementation { |
| namespace offload_utils { |
| |
| bool ToHidlScanResult(const wifi_offload::ScanResult& chreScanResult, ScanResult* hidlScanResult) { |
| if (hidlScanResult == nullptr) { |
| return false; |
| } |
| hidlScanResult->tsf = chreScanResult.tsf_; |
| hidlScanResult->capability = chreScanResult.capability_; |
| hidlScanResult->rssi = chreScanResult.rssi_dbm_; |
| hidlScanResult->frequency = chreScanResult.frequency_scanned_mhz_; |
| memcpy(&hidlScanResult->bssid[0], &chreScanResult.bssid_[0], |
| wifi_offload::ScanResult::kBssidSize); |
| chreWifiSsidListItem chreWifiSsid; |
| chreScanResult.ssid_.ToChreWifiSsidListItem(&chreWifiSsid); |
| std::vector<uint8_t> ssid; |
| for (size_t i = 0; i < chreWifiSsid.ssidLen; i++) { |
| ssid.push_back(chreWifiSsid.ssid[i]); |
| } |
| hidlScanResult->networkInfo.ssid = ssid; |
| hidlScanResult->networkInfo.flags = ToHidlSecurityMode(chreScanResult.security_modes_); |
| return true; |
| } |
| |
| bool ToHidlScanResults(const std::vector<wifi_offload::ScanResult>& chreScanResults, |
| std::vector<ScanResult>* hidlScanResults) { |
| LOG(VERBOSE) << "ScanResults from CHRE, size=" << chreScanResults.size(); |
| for (const auto& scan_result_from_nano_app : chreScanResults) { |
| ScanResult hidl_scan_result; |
| if (!ToHidlScanResult(scan_result_from_nano_app, &hidl_scan_result)) { |
| return false; |
| } |
| hidlScanResults->push_back(hidl_scan_result); |
| } |
| return true; |
| } |
| |
| bool ToHidlScanStats(const wifi_offload::ScanStats& chreScanStats, ScanStats* hidlScanStats) { |
| hidlScanStats->subscriptionDurationMs = chreScanStats.last_subscription_duration_ms_; |
| hidlScanStats->numScansRequestedByWifi = chreScanStats.num_scans_requested_by_nanoapp_; |
| hidlScanStats->numScansServicedByWifi = chreScanStats.num_scans_serviced_by_hardware_; |
| hidlScanStats->numScansServicedbyCache = chreScanStats.num_scans_serviced_by_cache_; |
| std::vector<ScanRecord> hidlScanRecords; |
| for (const auto& chreScanRecord : chreScanStats.scan_records_) { |
| ScanRecord hidlScanRecord; |
| hidlScanRecord.durationMs = chreScanRecord.time_spent_scanning_ms_; |
| hidlScanRecord.numChannelsScanned = chreScanRecord.num_channels_scanned_; |
| hidlScanRecord.numEntriesAggregated = chreScanRecord.num_entries_aggregated_; |
| hidlScanRecords.push_back(hidlScanRecord); |
| } |
| hidlScanStats->scanRecord = hidlScanRecords; |
| std::vector<LogRecord> logRecords; |
| for (const auto& chreLogRecord : chreScanStats.rpc_log_records_) { |
| LogRecord logRecord; |
| if (!ToHidlRecordName(chreLogRecord.record_type_, &logRecord.recordName)) { |
| return false; |
| } |
| logRecord.logTimeMs = chreLogRecord.timestamp_chre_ms_; |
| logRecords.push_back(logRecord); |
| } |
| hidlScanStats->logRecord = logRecords; |
| for (size_t i = 0; i < hidlScanStats->histogramChannelsScanned.elementCount(); i++) { |
| hidlScanStats->histogramChannelsScanned[i] = |
| chreScanStats.channel_histogram_.GetChannelScanCount(i); |
| } |
| return true; |
| } |
| |
| bool ToChreScanConfig(const ScanParam& param, const ScanFilter& filter, |
| wifi_offload::ScanConfig* scanConfig) { |
| scanConfig->scan_params_.disconnected_mode_scan_interval_ms_ = |
| param.disconnectedModeScanIntervalMs; |
| for (const auto& ssid : param.ssidList) { |
| wifi_offload::Ssid chreSsid; |
| chreSsid.SetData(ssid.data(), ssid.size()); |
| scanConfig->scan_params_.ssids_to_scan_.push_back(chreSsid); |
| } |
| for (const auto& freq : param.frequencyList) { |
| scanConfig->scan_params_.frequencies_to_scan_mhz_.push_back(freq); |
| } |
| scanConfig->scan_filter_.min_rssi_threshold_dbm_ = filter.rssiThreshold; |
| for (const auto& nwInfo : filter.preferredNetworkInfoList) { |
| wifi_offload::PreferredNetwork chreNwInfo; |
| chreNwInfo.security_modes_ = ToChreSecurityMode(nwInfo.flags); |
| chreNwInfo.ssid_.SetData(nwInfo.ssid.data(), nwInfo.ssid.size()); |
| scanConfig->scan_filter_.networks_to_match_.push_back(std::move(chreNwInfo)); |
| } |
| return true; |
| } |
| |
| bool ToHidlErrorMessage(uint32_t errorCode, std::string* errorMessage) { |
| bool reportError = true; |
| switch (errorCode) { |
| case wifi_offload::ErrorCode::FAILED_TO_ALLOCATE_MESSAGE_BUFFER: |
| *errorMessage = "Failed to allocate message buffer"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SERIALIZE_MESSAGE: |
| *errorMessage = "Failed to serialize message"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SEND_MESSAGE: |
| *errorMessage = "Failed to send message"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_DESERIALIZE_SCAN_CONFIG: |
| *errorMessage = "Failed to deserialize scan config"; |
| break; |
| case wifi_offload::ErrorCode::INVALID_SUBSCRIBE_MESSAGE_SIZE: |
| *errorMessage = "Invalid subscribe message size"; |
| break; |
| case wifi_offload::ErrorCode::SCAN_CONFIG_NOT_INITIALIZED: |
| *errorMessage = "Scan config not initialized"; |
| break; |
| case wifi_offload::ErrorCode::UNSPECIFIED_HOST_ENDPOINT: |
| *errorMessage = "Unspecified host end point"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SEND_SCAN_RESULTS: |
| *errorMessage = "Failed to send scan results"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SEND_SCAN_STATS: |
| *errorMessage = "Failed to send scan stats"; |
| break; |
| case wifi_offload::ErrorCode::ONDEMAND_SCAN_NOT_SUPPORTED: |
| *errorMessage = "On demand scans not supported"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SEND_ONDEMAND_SCAN_REQUEST: |
| *errorMessage = "Failed to send on demand scan request"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SEND_ONDEMAND_SCAN_REQUEST_ASYNC: |
| *errorMessage = "Failed to send on demand scan request async"; |
| break; |
| case wifi_offload::ErrorCode::OUT_OF_ORDER_SCAN_RESULTS: |
| *errorMessage = "Out of order scan results"; |
| break; |
| case wifi_offload::ErrorCode::INCOMPLETE_SCAN_RESULTS_BEFORE_SCAN_REQUEST: |
| *errorMessage = "Incomplete scan results before scan request"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_SET_SCAN_TIMER: |
| *errorMessage = "Failed to set scan timer"; |
| break; |
| case wifi_offload::ErrorCode::SCAN_MONITORING_NOT_SUPPORTED: |
| *errorMessage = "Scan Monitoring not supported"; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_START_SCAN_MONITORING: |
| *errorMessage = "Failed to start scan monitoring"; |
| reportError = false; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_STOP_SCAN_MONITORING: |
| *errorMessage = "Failed to stop scan monitoring"; |
| reportError = false; |
| break; |
| case wifi_offload::ErrorCode::FAILED_TO_CONFIGURE_SCAN_MONITORING_ASYNC: |
| *errorMessage = "Failed to configure scan monitoring async"; |
| reportError = false; |
| break; |
| default: |
| *errorMessage = "Invalid error code"; |
| reportError = false; |
| break; |
| } |
| return reportError; |
| } |
| |
| } // namespace offload_utils |
| } // namespace implementation |
| } // namespace V1_0 |
| } // namespace offload |
| } // namespace wifi |
| } // namespace hardware |
| } // namespace android |
