| /* |
| * hidl interface for wpa_supplicant daemon |
| * Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi> |
| * Copyright (c) 2004-2016, Roshan Pius <rpius@google.com> |
| * Copyright (C) 2017 Sony Mobile Communications Inc. |
| * |
| * This software may be distributed under the terms of the BSD license. |
| * See README for more details. |
| */ |
| |
| #include "hidl_manager.h" |
| #include "hidl_return_util.h" |
| #include "iface_config_utils.h" |
| #include "misc_utils.h" |
| #include "p2p_iface.h" |
| #include "sta_network.h" |
| |
| extern "C" |
| { |
| #include "ap.h" |
| #include "wps_supplicant.h" |
| #include "wifi_display.h" |
| #include "utils/eloop.h" |
| #include "wpa_supplicant_i.h" |
| #include "driver_i.h" |
| } |
| |
| #define P2P_MAX_JOIN_SCAN_ATTEMPTS 10 |
| |
| namespace { |
| const char kConfigMethodStrPbc[] = "pbc"; |
| const char kConfigMethodStrDisplay[] = "display"; |
| const char kConfigMethodStrKeypad[] = "keypad"; |
| constexpr char kSetMiracastMode[] = "MIRACAST "; |
| constexpr uint8_t kWfdDeviceInfoSubelemId = 0; |
| constexpr char kWfdDeviceInfoSubelemLenHexStr[] = "0006"; |
| |
| std::function<void()> pending_join_scan_callback = NULL; |
| std::function<void()> pending_scan_res_join_callback = NULL; |
| |
| using android::hardware::wifi::supplicant::V1_0::ISupplicantP2pIface; |
| using android::hardware::wifi::supplicant::V1_0::ISupplicantStaNetwork; |
| uint8_t convertHidlMiracastModeToInternal( |
| ISupplicantP2pIface::MiracastMode mode) |
| { |
| switch (mode) { |
| case ISupplicantP2pIface::MiracastMode::DISABLED: |
| return 0; |
| case ISupplicantP2pIface::MiracastMode::SOURCE: |
| return 1; |
| case ISupplicantP2pIface::MiracastMode::SINK: |
| return 2; |
| }; |
| WPA_ASSERT(false); |
| } |
| |
| /** |
| * Check if the provided ssid is valid or not. |
| * |
| * Returns 1 if valid, 0 otherwise. |
| */ |
| int isSsidValid(const std::vector<uint8_t>& ssid) |
| { |
| if (ssid.size() == 0 || |
| ssid.size() > |
| static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits:: |
| SSID_MAX_LEN_IN_BYTES)) { |
| return 0; |
| } |
| return 1; |
| } |
| |
| /** |
| * Check if the provided psk passhrase is valid or not. |
| * |
| * Returns 1 if valid, 0 otherwise. |
| */ |
| int isPskPassphraseValid(const std::string &psk) |
| { |
| if (psk.size() < |
| static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits:: |
| PSK_PASSPHRASE_MIN_LEN_IN_BYTES) || |
| psk.size() > |
| static_cast<uint32_t>(ISupplicantStaNetwork::ParamSizeLimits:: |
| PSK_PASSPHRASE_MAX_LEN_IN_BYTES)) { |
| return 0; |
| } |
| if (has_ctrl_char((u8 *)psk.c_str(), psk.size())) { |
| return 0; |
| } |
| return 1; |
| } |
| |
| void setBandScanFreqsList( |
| struct wpa_supplicant *wpa_s, |
| enum hostapd_hw_mode band, |
| struct wpa_driver_scan_params *params) |
| { |
| /* Include only supported channels for the specified band */ |
| struct hostapd_hw_modes *mode; |
| int count, i; |
| |
| mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, band); |
| if (mode == NULL) { |
| /* No channels supported in this band. */ |
| return; |
| } |
| |
| params->freqs = (int *) os_calloc(mode->num_channels + 1, sizeof(int)); |
| if (params->freqs == NULL) |
| return; |
| for (count = 0, i = 0; i < mode->num_channels; i++) { |
| if (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED) |
| continue; |
| params->freqs[count++] = mode->channels[i].freq; |
| } |
| } |
| /* |
| * isAnyEtherAddr - match any ether address |
| * |
| */ |
| int isAnyEtherAddr(const u8 *a) |
| { |
| // 02:00:00:00:00:00 |
| return (a[0] == 2) && !(a[1] | a[2] | a[3] | a[4] | a[5]); |
| } |
| |
| /** |
| * findBssBySsid - Fetch a BSS table entry based on SSID and optional BSSID. |
| * @wpa_s: Pointer to wpa_supplicant data |
| * @bssid: BSSID, 02:00:00:00:00:00 matches any bssid |
| * @ssid: SSID |
| * @ssid_len: Length of @ssid |
| * Returns: Pointer to the BSS entry or %NULL if not found |
| */ |
| struct wpa_bss* findBssBySsid( |
| struct wpa_supplicant *wpa_s, const u8 *bssid, |
| const u8 *ssid, size_t ssid_len) |
| { |
| struct wpa_bss *bss; |
| dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) { |
| if ((isAnyEtherAddr(bssid) || |
| os_memcmp(bss->bssid, bssid, ETH_ALEN) == 0) && |
| bss->ssid_len == ssid_len && |
| os_memcmp(bss->ssid, ssid, ssid_len) == 0) |
| return bss; |
| } |
| return NULL; |
| } |
| |
| struct wpa_ssid* addGroupClientNetwork( |
| struct wpa_supplicant* wpa_s, |
| uint8_t *group_owner_bssid, |
| const std::vector<uint8_t>& ssid, |
| const std::string& passphrase) |
| { |
| struct wpa_ssid* wpa_network = wpa_config_add_network(wpa_s->conf); |
| if (!wpa_network) { |
| return NULL; |
| } |
| // set general network defaults |
| wpa_config_set_network_defaults(wpa_network); |
| |
| // set P2p network defaults |
| wpa_network->p2p_group = 1; |
| wpa_network->mode = wpa_ssid::wpas_mode::WPAS_MODE_INFRA; |
| |
| wpa_network->auth_alg = WPA_AUTH_ALG_OPEN; |
| wpa_network->key_mgmt = WPA_KEY_MGMT_PSK; |
| wpa_network->proto = WPA_PROTO_RSN; |
| wpa_network->pairwise_cipher = WPA_CIPHER_CCMP; |
| wpa_network->group_cipher = WPA_CIPHER_CCMP; |
| wpa_network->disabled = 2; |
| |
| // set necessary fields |
| os_memcpy(wpa_network->bssid, group_owner_bssid, ETH_ALEN); |
| wpa_network->bssid_set = 1; |
| |
| wpa_network->ssid = (uint8_t *)os_malloc(ssid.size()); |
| if (wpa_network->ssid == NULL) { |
| wpa_config_remove_network(wpa_s->conf, wpa_network->id); |
| return NULL; |
| } |
| memcpy(wpa_network->ssid, ssid.data(), ssid.size()); |
| wpa_network->ssid_len = ssid.size(); |
| |
| wpa_network->psk_set = 0; |
| wpa_network->passphrase = dup_binstr(passphrase.c_str(), passphrase.length()); |
| if (wpa_network->passphrase == NULL) { |
| wpa_config_remove_network(wpa_s->conf, wpa_network->id); |
| return NULL; |
| } |
| wpa_config_update_psk(wpa_network); |
| |
| return wpa_network; |
| |
| } |
| |
| void joinScanWrapper(void *eloop_ctx, void *timeout_ctx) |
| { |
| struct wpa_supplicant *wpa_s = (struct wpa_supplicant *) eloop_ctx; |
| |
| if (pending_join_scan_callback != NULL) { |
| pending_join_scan_callback(); |
| } |
| } |
| |
| void scanResJoinWrapper( |
| struct wpa_supplicant *wpa_s, |
| struct wpa_scan_results *scan_res) |
| { |
| if (pending_scan_res_join_callback) { |
| pending_scan_res_join_callback(); |
| } |
| } |
| |
| int joinScanReq( |
| struct wpa_supplicant* wpa_s, |
| const std::vector<uint8_t>& ssid, |
| int freq) |
| { |
| int ret; |
| struct wpa_driver_scan_params params; |
| struct wpabuf *ies; |
| size_t ielen; |
| unsigned int bands; |
| |
| os_memset(¶ms, 0, sizeof(params)); |
| if (ssid.size() > 0) { |
| params.ssids[0].ssid = ssid.data(); |
| params.ssids[0].ssid_len = ssid.size(); |
| } else { |
| params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID; |
| params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN; |
| } |
| wpa_printf(MSG_DEBUG, "Scan SSID %s for join with frequency %d (reinvoke)", |
| wpa_ssid_txt(params.ssids[0].ssid, params.ssids[0].ssid_len), freq); |
| |
| if (freq > 0) { |
| if (freq == 2 || freq == 5) { |
| if (wpa_s->hw.modes != NULL) { |
| switch (freq) { |
| case 2: |
| setBandScanFreqsList(wpa_s, |
| HOSTAPD_MODE_IEEE80211G, ¶ms); |
| break; |
| case 5: |
| setBandScanFreqsList(wpa_s, |
| HOSTAPD_MODE_IEEE80211A, ¶ms); |
| break; |
| } |
| if (!params.freqs) { |
| wpa_printf(MSG_ERROR, |
| "P2P: No supported channels in %dG band.", freq); |
| return -1; |
| } |
| } else { |
| wpa_printf(MSG_DEBUG, |
| "P2P: Unknown what %dG channels the driver supports.", freq); |
| } |
| } else { |
| if (0 == p2p_supported_freq_cli(wpa_s->global->p2p, freq)) { |
| wpa_printf(MSG_ERROR, |
| "P2P: freq %d is not supported for a client.", freq); |
| return -1; |
| } |
| |
| /* |
| * Allocate memory for frequency array, allocate one extra |
| * slot for the zero-terminator. |
| */ |
| params.freqs = (int *) os_calloc(2, sizeof(int)); |
| if (params.freqs) { |
| params.freqs[0] = freq; |
| } else { |
| wpa_printf(MSG_ERROR, |
| "P2P: Cannot allocate memory for scan params."); |
| return -1; |
| } |
| } |
| } |
| |
| ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p); |
| ies = wpabuf_alloc(ielen); |
| if (ies == NULL) { |
| if (params.freqs) { |
| os_free(params.freqs); |
| } |
| return -1; |
| } |
| |
| bands = wpas_get_bands(wpa_s, params.freqs); |
| p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands); |
| |
| params.p2p_probe = 1; |
| params.extra_ies = (u8 *) wpabuf_head(ies); |
| params.extra_ies_len = wpabuf_len(ies); |
| if (wpa_s->clear_driver_scan_cache) { |
| wpa_printf(MSG_DEBUG, |
| "Request driver to clear scan cache due to local BSS flush"); |
| params.only_new_results = 1; |
| } |
| |
| ret = wpa_drv_scan(wpa_s, ¶ms); |
| if (!ret) { |
| os_get_reltime(&wpa_s->scan_trigger_time); |
| wpa_s->scan_res_handler = scanResJoinWrapper; |
| wpa_s->own_scan_requested = 1; |
| wpa_s->clear_driver_scan_cache = 0; |
| } |
| |
| if (params.freqs) { |
| os_free(params.freqs); |
| } |
| |
| wpabuf_free(ies); |
| |
| return ret; |
| } |
| |
| int joinGroup( |
| struct wpa_supplicant* wpa_s, |
| uint8_t *group_owner_bssid, |
| const std::vector<uint8_t>& ssid, |
| const std::string& passphrase) |
| { |
| int ret = 0; |
| int vht = wpa_s->conf->p2p_go_vht; |
| int ht40 = wpa_s->conf->p2p_go_ht40 || vht; |
| |
| // Construct a network for adding group. |
| // Group client follows the persistent attribute of Group Owner. |
| // If joined group is persistent, it adds a persistent network on GroupStarted. |
| struct wpa_ssid *wpa_network = addGroupClientNetwork( |
| wpa_s, group_owner_bssid, ssid, passphrase); |
| if (wpa_network == NULL) { |
| wpa_printf(MSG_ERROR, "P2P: Cannot construct a network for group join."); |
| return -1; |
| } |
| |
| // this is temporary network only for establishing the connection. |
| wpa_network->temporary = 1; |
| |
| if (wpas_p2p_group_add_persistent( |
| wpa_s, wpa_network, 0, 0, 0, 0, ht40, vht, |
| VHT_CHANWIDTH_USE_HT, 0, NULL, 0, 1)) { |
| ret = -1; |
| } |
| |
| // Always remove this temporary network at the end. |
| wpa_config_remove_network(wpa_s->conf, wpa_network->id); |
| return ret; |
| } |
| |
| void notifyGroupJoinFailure( |
| struct wpa_supplicant* wpa_s) |
| { |
| u8 zero_addr[ETH_ALEN] = {0}; |
| std::vector<uint8_t> ssid = {'D', 'I', 'R', 'E','C', 'T', '-'}; |
| std::string passphrase = ""; |
| struct wpa_ssid *wpa_network = addGroupClientNetwork( |
| wpa_s, zero_addr, ssid, passphrase); |
| if (wpa_network) { |
| wpa_network->temporary = 1; |
| wpas_notify_p2p_group_formation_failure(wpa_s, "Failed to find the group."); |
| wpas_notify_p2p_group_removed( |
| wpa_s, wpa_network, "client"); |
| wpa_config_remove_network( |
| wpa_s->conf, wpa_network->id); |
| } else { |
| wpa_printf(MSG_ERROR, |
| "P2P: Cannot construct a network."); |
| } |
| } |
| |
| void scanResJoinIgnore(struct wpa_supplicant *wpa_s, struct wpa_scan_results *scan_res) { |
| wpa_printf(MSG_DEBUG, "P2P: Ignore group join scan results."); |
| } |
| |
| } // namespace |
| |
| namespace android { |
| namespace hardware { |
| namespace wifi { |
| namespace supplicant { |
| namespace V1_2 { |
| namespace implementation { |
| using hidl_return_util::validateAndCall; |
| |
| P2pIface::P2pIface(struct wpa_global* wpa_global, const char ifname[]) |
| : wpa_global_(wpa_global), ifname_(ifname), is_valid_(true) |
| {} |
| |
| void P2pIface::invalidate() { is_valid_ = false; } |
| bool P2pIface::isValid() |
| { |
| return (is_valid_ && (retrieveIfacePtr() != nullptr)); |
| } |
| Return<void> P2pIface::getName(getName_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::getNameInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::getType(getType_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::getTypeInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::addNetwork(addNetwork_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::addNetworkInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::removeNetwork( |
| SupplicantNetworkId id, removeNetwork_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::removeNetworkInternal, _hidl_cb, id); |
| } |
| |
| Return<void> P2pIface::getNetwork( |
| SupplicantNetworkId id, getNetwork_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::getNetworkInternal, _hidl_cb, id); |
| } |
| |
| Return<void> P2pIface::listNetworks(listNetworks_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::listNetworksInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::registerCallback( |
| const sp<ISupplicantP2pIfaceCallback>& callback, |
| registerCallback_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::registerCallbackInternal, _hidl_cb, callback); |
| } |
| |
| Return<void> P2pIface::getDeviceAddress(getDeviceAddress_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::getDeviceAddressInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::setSsidPostfix( |
| const hidl_vec<uint8_t>& postfix, setSsidPostfix_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setSsidPostfixInternal, _hidl_cb, postfix); |
| } |
| |
| Return<void> P2pIface::setGroupIdle( |
| const hidl_string& group_ifname, uint32_t timeout_in_sec, |
| setGroupIdle_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setGroupIdleInternal, _hidl_cb, group_ifname, |
| timeout_in_sec); |
| } |
| |
| Return<void> P2pIface::setPowerSave( |
| const hidl_string& group_ifname, bool enable, setPowerSave_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setPowerSaveInternal, _hidl_cb, group_ifname, enable); |
| } |
| |
| Return<void> P2pIface::find(uint32_t timeout_in_sec, find_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::findInternal, _hidl_cb, timeout_in_sec); |
| } |
| |
| Return<void> P2pIface::stopFind(stopFind_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::stopFindInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::flush(flush_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::flushInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::connect( |
| const hidl_array<uint8_t, 6>& peer_address, |
| ISupplicantP2pIface::WpsProvisionMethod provision_method, |
| const hidl_string& pre_selected_pin, bool join_existing_group, |
| bool persistent, uint32_t go_intent, connect_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::connectInternal, _hidl_cb, peer_address, |
| provision_method, pre_selected_pin, join_existing_group, persistent, |
| go_intent); |
| } |
| |
| Return<void> P2pIface::cancelConnect(cancelConnect_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::cancelConnectInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::provisionDiscovery( |
| const hidl_array<uint8_t, 6>& peer_address, |
| ISupplicantP2pIface::WpsProvisionMethod provision_method, |
| provisionDiscovery_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::provisionDiscoveryInternal, _hidl_cb, peer_address, |
| provision_method); |
| } |
| |
| Return<void> P2pIface::addGroup( |
| bool persistent, SupplicantNetworkId persistent_network_id, |
| addGroup_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::addGroupInternal, _hidl_cb, persistent, |
| persistent_network_id); |
| } |
| |
| Return<void> P2pIface::removeGroup( |
| const hidl_string& group_ifname, removeGroup_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::removeGroupInternal, _hidl_cb, group_ifname); |
| } |
| |
| Return<void> P2pIface::reject( |
| const hidl_array<uint8_t, 6>& peer_address, reject_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::rejectInternal, _hidl_cb, peer_address); |
| } |
| |
| Return<void> P2pIface::invite( |
| const hidl_string& group_ifname, |
| const hidl_array<uint8_t, 6>& go_device_address, |
| const hidl_array<uint8_t, 6>& peer_address, invite_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::inviteInternal, _hidl_cb, group_ifname, |
| go_device_address, peer_address); |
| } |
| |
| Return<void> P2pIface::reinvoke( |
| SupplicantNetworkId persistent_network_id, |
| const hidl_array<uint8_t, 6>& peer_address, reinvoke_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::reinvokeInternal, _hidl_cb, persistent_network_id, |
| peer_address); |
| } |
| |
| Return<void> P2pIface::configureExtListen( |
| uint32_t period_in_millis, uint32_t interval_in_millis, |
| configureExtListen_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::configureExtListenInternal, _hidl_cb, period_in_millis, |
| interval_in_millis); |
| } |
| |
| Return<void> P2pIface::setListenChannel( |
| uint32_t channel, uint32_t operating_class, setListenChannel_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setListenChannelInternal, _hidl_cb, channel, |
| operating_class); |
| } |
| |
| Return<void> P2pIface::setDisallowedFrequencies( |
| const hidl_vec<FreqRange>& ranges, setDisallowedFrequencies_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setDisallowedFrequenciesInternal, _hidl_cb, ranges); |
| } |
| |
| Return<void> P2pIface::getSsid( |
| const hidl_array<uint8_t, 6>& peer_address, getSsid_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::getSsidInternal, _hidl_cb, peer_address); |
| } |
| |
| Return<void> P2pIface::getGroupCapability( |
| const hidl_array<uint8_t, 6>& peer_address, getGroupCapability_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::getGroupCapabilityInternal, _hidl_cb, peer_address); |
| } |
| |
| Return<void> P2pIface::addBonjourService( |
| const hidl_vec<uint8_t>& query, const hidl_vec<uint8_t>& response, |
| addBonjourService_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::addBonjourServiceInternal, _hidl_cb, query, response); |
| } |
| |
| Return<void> P2pIface::removeBonjourService( |
| const hidl_vec<uint8_t>& query, removeBonjourService_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::removeBonjourServiceInternal, _hidl_cb, query); |
| } |
| |
| Return<void> P2pIface::addUpnpService( |
| uint32_t version, const hidl_string& service_name, |
| addUpnpService_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::addUpnpServiceInternal, _hidl_cb, version, service_name); |
| } |
| |
| Return<void> P2pIface::removeUpnpService( |
| uint32_t version, const hidl_string& service_name, |
| removeUpnpService_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::removeUpnpServiceInternal, _hidl_cb, version, |
| service_name); |
| } |
| |
| Return<void> P2pIface::flushServices(flushServices_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::flushServicesInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::requestServiceDiscovery( |
| const hidl_array<uint8_t, 6>& peer_address, const hidl_vec<uint8_t>& query, |
| requestServiceDiscovery_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::requestServiceDiscoveryInternal, _hidl_cb, peer_address, |
| query); |
| } |
| |
| Return<void> P2pIface::cancelServiceDiscovery( |
| uint64_t identifier, cancelServiceDiscovery_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::cancelServiceDiscoveryInternal, _hidl_cb, identifier); |
| } |
| |
| Return<void> P2pIface::setMiracastMode( |
| ISupplicantP2pIface::MiracastMode mode, setMiracastMode_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setMiracastModeInternal, _hidl_cb, mode); |
| } |
| |
| Return<void> P2pIface::startWpsPbc( |
| const hidl_string& group_ifname, const hidl_array<uint8_t, 6>& bssid, |
| startWpsPbc_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::startWpsPbcInternal, _hidl_cb, group_ifname, bssid); |
| } |
| |
| Return<void> P2pIface::startWpsPinKeypad( |
| const hidl_string& group_ifname, const hidl_string& pin, |
| startWpsPinKeypad_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::startWpsPinKeypadInternal, _hidl_cb, group_ifname, pin); |
| } |
| |
| Return<void> P2pIface::startWpsPinDisplay( |
| const hidl_string& group_ifname, const hidl_array<uint8_t, 6>& bssid, |
| startWpsPinDisplay_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::startWpsPinDisplayInternal, _hidl_cb, group_ifname, |
| bssid); |
| } |
| |
| Return<void> P2pIface::cancelWps( |
| const hidl_string& group_ifname, cancelWps_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::cancelWpsInternal, _hidl_cb, group_ifname); |
| } |
| |
| Return<void> P2pIface::setWpsDeviceName( |
| const hidl_string& name, setWpsDeviceName_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsDeviceNameInternal, _hidl_cb, name); |
| } |
| |
| Return<void> P2pIface::setWpsDeviceType( |
| const hidl_array<uint8_t, 8>& type, setWpsDeviceType_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsDeviceTypeInternal, _hidl_cb, type); |
| } |
| |
| Return<void> P2pIface::setWpsManufacturer( |
| const hidl_string& manufacturer, setWpsManufacturer_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsManufacturerInternal, _hidl_cb, manufacturer); |
| } |
| |
| Return<void> P2pIface::setWpsModelName( |
| const hidl_string& model_name, setWpsModelName_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsModelNameInternal, _hidl_cb, model_name); |
| } |
| |
| Return<void> P2pIface::setWpsModelNumber( |
| const hidl_string& model_number, setWpsModelNumber_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsModelNumberInternal, _hidl_cb, model_number); |
| } |
| |
| Return<void> P2pIface::setWpsSerialNumber( |
| const hidl_string& serial_number, setWpsSerialNumber_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsSerialNumberInternal, _hidl_cb, serial_number); |
| } |
| |
| Return<void> P2pIface::setWpsConfigMethods( |
| uint16_t config_methods, setWpsConfigMethods_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWpsConfigMethodsInternal, _hidl_cb, config_methods); |
| } |
| |
| Return<void> P2pIface::enableWfd(bool enable, enableWfd_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::enableWfdInternal, _hidl_cb, enable); |
| } |
| |
| Return<void> P2pIface::setWfdDeviceInfo( |
| const hidl_array<uint8_t, 6>& info, setWfdDeviceInfo_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setWfdDeviceInfoInternal, _hidl_cb, info); |
| } |
| |
| Return<void> P2pIface::createNfcHandoverRequestMessage( |
| createNfcHandoverRequestMessage_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::createNfcHandoverRequestMessageInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::createNfcHandoverSelectMessage( |
| createNfcHandoverSelectMessage_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::createNfcHandoverSelectMessageInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::reportNfcHandoverResponse( |
| const hidl_vec<uint8_t>& request, reportNfcHandoverResponse_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::reportNfcHandoverResponseInternal, _hidl_cb, request); |
| } |
| |
| Return<void> P2pIface::reportNfcHandoverInitiation( |
| const hidl_vec<uint8_t>& select, reportNfcHandoverInitiation_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::reportNfcHandoverInitiationInternal, _hidl_cb, select); |
| } |
| |
| Return<void> P2pIface::saveConfig(saveConfig_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::saveConfigInternal, _hidl_cb); |
| } |
| |
| Return<void> P2pIface::addGroup_1_2( |
| const hidl_vec<uint8_t>& ssid, const hidl_string& passphrase, |
| bool persistent, uint32_t freq, const hidl_array<uint8_t, 6>& peer_address, |
| bool join, addGroup_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::addGroup_1_2Internal, _hidl_cb, |
| ssid, passphrase, persistent, freq, peer_address, join); |
| } |
| |
| Return<void> P2pIface::setMacRandomization(bool enable, setMacRandomization_cb _hidl_cb) |
| { |
| return validateAndCall( |
| this, SupplicantStatusCode::FAILURE_IFACE_INVALID, |
| &P2pIface::setMacRandomizationInternal, _hidl_cb, enable); |
| } |
| |
| std::pair<SupplicantStatus, std::string> P2pIface::getNameInternal() |
| { |
| return {{SupplicantStatusCode::SUCCESS, ""}, ifname_}; |
| } |
| |
| std::pair<SupplicantStatus, IfaceType> P2pIface::getTypeInternal() |
| { |
| return {{SupplicantStatusCode::SUCCESS, ""}, IfaceType::P2P}; |
| } |
| |
| std::pair<SupplicantStatus, sp<ISupplicantP2pNetwork>> |
| P2pIface::addNetworkInternal() |
| { |
| android::sp<ISupplicantP2pNetwork> network; |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| struct wpa_ssid* ssid = wpa_supplicant_add_network(wpa_s); |
| if (!ssid) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network}; |
| } |
| HidlManager* hidl_manager = HidlManager::getInstance(); |
| if (!hidl_manager || |
| hidl_manager->getP2pNetworkHidlObjectByIfnameAndNetworkId( |
| wpa_s->ifname, ssid->id, &network)) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, network}; |
| } |
| |
| SupplicantStatus P2pIface::removeNetworkInternal(SupplicantNetworkId id) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| int result = wpa_supplicant_remove_network(wpa_s, id); |
| if (result == -1) { |
| return {SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, ""}; |
| } |
| if (result != 0) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| std::pair<SupplicantStatus, sp<ISupplicantP2pNetwork>> |
| P2pIface::getNetworkInternal(SupplicantNetworkId id) |
| { |
| android::sp<ISupplicantP2pNetwork> network; |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| struct wpa_ssid* ssid = wpa_config_get_network(wpa_s->conf, id); |
| if (!ssid) { |
| return {{SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, ""}, |
| network}; |
| } |
| HidlManager* hidl_manager = HidlManager::getInstance(); |
| if (!hidl_manager || |
| hidl_manager->getP2pNetworkHidlObjectByIfnameAndNetworkId( |
| wpa_s->ifname, ssid->id, &network)) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, network}; |
| } |
| |
| std::pair<SupplicantStatus, std::vector<SupplicantNetworkId>> |
| P2pIface::listNetworksInternal() |
| { |
| std::vector<SupplicantNetworkId> network_ids; |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| for (struct wpa_ssid* wpa_ssid = wpa_s->conf->ssid; wpa_ssid; |
| wpa_ssid = wpa_ssid->next) { |
| network_ids.emplace_back(wpa_ssid->id); |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, std::move(network_ids)}; |
| } |
| |
| SupplicantStatus P2pIface::registerCallbackInternal( |
| const sp<ISupplicantP2pIfaceCallback>& callback) |
| { |
| HidlManager* hidl_manager = HidlManager::getInstance(); |
| if (!hidl_manager || |
| hidl_manager->addP2pIfaceCallbackHidlObject(ifname_, callback)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| std::pair<SupplicantStatus, std::array<uint8_t, 6>> |
| P2pIface::getDeviceAddressInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| std::array<uint8_t, 6> addr; |
| static_assert(ETH_ALEN == addr.size(), "Size mismatch"); |
| os_memcpy(addr.data(), wpa_s->global->p2p_dev_addr, ETH_ALEN); |
| return {{SupplicantStatusCode::SUCCESS, ""}, addr}; |
| } |
| |
| SupplicantStatus P2pIface::setSsidPostfixInternal( |
| const std::vector<uint8_t>& postfix) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (p2p_set_ssid_postfix( |
| wpa_s->global->p2p, postfix.data(), postfix.size())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setGroupIdleInternal( |
| const std::string& group_ifname, uint32_t timeout_in_sec) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}; |
| } |
| wpa_group_s->conf->p2p_group_idle = timeout_in_sec; |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setPowerSaveInternal( |
| const std::string& group_ifname, bool enable) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}; |
| } |
| if (wpa_drv_set_p2p_powersave(wpa_group_s, enable, -1, -1)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::findInternal(uint32_t timeout_in_sec) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { |
| return {SupplicantStatusCode::FAILURE_IFACE_DISABLED, ""}; |
| } |
| uint32_t search_delay = wpas_p2p_search_delay(wpa_s); |
| if (wpas_p2p_find( |
| wpa_s, timeout_in_sec, P2P_FIND_START_WITH_FULL, 0, nullptr, |
| nullptr, search_delay, 0, nullptr, 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::stopFindInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { |
| return {SupplicantStatusCode::FAILURE_IFACE_DISABLED, ""}; |
| } |
| if (wpa_s->scan_res_handler == scanResJoinWrapper) { |
| wpa_printf(MSG_DEBUG, "P2P: Stop pending group scan for stopping find)."); |
| pending_scan_res_join_callback = NULL; |
| wpa_s->scan_res_handler = scanResJoinIgnore; |
| } |
| wpas_p2p_stop_find(wpa_s); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::flushInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN); |
| wpa_s->force_long_sd = 0; |
| wpas_p2p_stop_find(wpa_s); |
| wpa_s->parent->p2ps_method_config_any = 0; |
| if (wpa_s->global->p2p) |
| p2p_flush(wpa_s->global->p2p); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| // This method only implements support for subset (needed by Android framework) |
| // of parameters that can be specified for connect. |
| std::pair<SupplicantStatus, std::string> P2pIface::connectInternal( |
| const std::array<uint8_t, 6>& peer_address, |
| ISupplicantP2pIface::WpsProvisionMethod provision_method, |
| const std::string& pre_selected_pin, bool join_existing_group, |
| bool persistent, uint32_t go_intent) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (go_intent > 15) { |
| return {{SupplicantStatusCode::FAILURE_ARGS_INVALID, ""}, {}}; |
| } |
| int go_intent_signed = join_existing_group ? -1 : go_intent; |
| p2p_wps_method wps_method = {}; |
| switch (provision_method) { |
| case WpsProvisionMethod::PBC: |
| wps_method = WPS_PBC; |
| break; |
| case WpsProvisionMethod::DISPLAY: |
| wps_method = WPS_PIN_DISPLAY; |
| break; |
| case WpsProvisionMethod::KEYPAD: |
| wps_method = WPS_PIN_KEYPAD; |
| break; |
| } |
| int vht = wpa_s->conf->p2p_go_vht; |
| int ht40 = wpa_s->conf->p2p_go_ht40 || vht; |
| const char* pin = |
| pre_selected_pin.length() > 0 ? pre_selected_pin.data() : nullptr; |
| int new_pin = wpas_p2p_connect( |
| wpa_s, peer_address.data(), pin, wps_method, persistent, false, |
| join_existing_group, false, go_intent_signed, 0, 0, -1, false, ht40, |
| vht, VHT_CHANWIDTH_USE_HT, 0, nullptr, 0); |
| if (new_pin < 0) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| std::string pin_ret; |
| if (provision_method == WpsProvisionMethod::DISPLAY && |
| pre_selected_pin.empty()) { |
| pin_ret = misc_utils::convertWpsPinToString(new_pin); |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, pin_ret}; |
| } |
| |
| SupplicantStatus P2pIface::cancelConnectInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpa_s->scan_res_handler == scanResJoinWrapper) { |
| wpa_printf(MSG_DEBUG, "P2P: Stop pending group scan for canceling connect"); |
| pending_scan_res_join_callback = NULL; |
| wpa_s->scan_res_handler = scanResJoinIgnore; |
| } |
| if (wpas_p2p_cancel(wpa_s)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::provisionDiscoveryInternal( |
| const std::array<uint8_t, 6>& peer_address, |
| ISupplicantP2pIface::WpsProvisionMethod provision_method) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| p2ps_provision* prov_param; |
| const char* config_method_str = nullptr; |
| switch (provision_method) { |
| case WpsProvisionMethod::PBC: |
| config_method_str = kConfigMethodStrPbc; |
| break; |
| case WpsProvisionMethod::DISPLAY: |
| config_method_str = kConfigMethodStrDisplay; |
| break; |
| case WpsProvisionMethod::KEYPAD: |
| config_method_str = kConfigMethodStrKeypad; |
| break; |
| } |
| if (wpas_p2p_prov_disc( |
| wpa_s, peer_address.data(), config_method_str, |
| WPAS_P2P_PD_FOR_GO_NEG, nullptr)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::addGroupInternal( |
| bool persistent, SupplicantNetworkId persistent_network_id) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| int vht = wpa_s->conf->p2p_go_vht; |
| int ht40 = wpa_s->conf->p2p_go_ht40 || vht; |
| struct wpa_ssid* ssid = |
| wpa_config_get_network(wpa_s->conf, persistent_network_id); |
| if (ssid == NULL) { |
| if (wpas_p2p_group_add( |
| wpa_s, persistent, 0, 0, ht40, vht, |
| VHT_CHANWIDTH_USE_HT, 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } else { |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| } else if (ssid->disabled == 2) { |
| if (wpas_p2p_group_add_persistent( |
| wpa_s, ssid, 0, 0, 0, 0, ht40, vht, |
| VHT_CHANWIDTH_USE_HT, 0, NULL, 0, 0)) { |
| return {SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, |
| ""}; |
| } else { |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| } |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| |
| SupplicantStatus P2pIface::removeGroupInternal(const std::string& group_ifname) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}; |
| } |
| if (wpas_p2p_group_remove(wpa_group_s, group_ifname.c_str())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::rejectInternal( |
| const std::array<uint8_t, 6>& peer_address) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) { |
| return {SupplicantStatusCode::FAILURE_IFACE_DISABLED, ""}; |
| } |
| if (wpas_p2p_reject(wpa_s, peer_address.data())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::inviteInternal( |
| const std::string& group_ifname, |
| const std::array<uint8_t, 6>& go_device_address, |
| const std::array<uint8_t, 6>& peer_address) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpas_p2p_invite_group( |
| wpa_s, group_ifname.c_str(), peer_address.data(), |
| go_device_address.data())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::reinvokeInternal( |
| SupplicantNetworkId persistent_network_id, |
| const std::array<uint8_t, 6>& peer_address) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| int vht = wpa_s->conf->p2p_go_vht; |
| int ht40 = wpa_s->conf->p2p_go_ht40 || vht; |
| struct wpa_ssid* ssid = |
| wpa_config_get_network(wpa_s->conf, persistent_network_id); |
| if (ssid == NULL || ssid->disabled != 2) { |
| return {SupplicantStatusCode::FAILURE_NETWORK_UNKNOWN, ""}; |
| } |
| if (wpas_p2p_invite( |
| wpa_s, peer_address.data(), ssid, NULL, 0, 0, ht40, vht, |
| VHT_CHANWIDTH_USE_HT, 0, 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::configureExtListenInternal( |
| uint32_t period_in_millis, uint32_t interval_in_millis) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpas_p2p_ext_listen(wpa_s, period_in_millis, interval_in_millis)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setListenChannelInternal( |
| uint32_t channel, uint32_t operating_class) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (p2p_set_listen_channel( |
| wpa_s->global->p2p, operating_class, channel, 1)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setDisallowedFrequenciesInternal( |
| const std::vector<FreqRange>& ranges) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| using DestT = struct wpa_freq_range_list::wpa_freq_range; |
| DestT* freq_ranges = nullptr; |
| // Empty ranges is used to enable all frequencies. |
| if (ranges.size() != 0) { |
| freq_ranges = static_cast<DestT*>( |
| os_malloc(sizeof(DestT) * ranges.size())); |
| if (!freq_ranges) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| uint32_t i = 0; |
| for (const auto& range : ranges) { |
| freq_ranges[i].min = range.min; |
| freq_ranges[i].max = range.max; |
| i++; |
| } |
| } |
| |
| os_free(wpa_s->global->p2p_disallow_freq.range); |
| wpa_s->global->p2p_disallow_freq.range = freq_ranges; |
| wpa_s->global->p2p_disallow_freq.num = ranges.size(); |
| wpas_p2p_update_channel_list(wpa_s, WPAS_P2P_CHANNEL_UPDATE_DISALLOW); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| std::pair<SupplicantStatus, std::vector<uint8_t>> P2pIface::getSsidInternal( |
| const std::array<uint8_t, 6>& peer_address) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| const struct p2p_peer_info* info = |
| p2p_get_peer_info(wpa_s->global->p2p, peer_address.data(), 0); |
| if (!info) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| const struct p2p_device* dev = |
| reinterpret_cast<const struct p2p_device*>( |
| (reinterpret_cast<const uint8_t*>(info)) - |
| offsetof(struct p2p_device, info)); |
| std::vector<uint8_t> ssid; |
| if (dev && dev->oper_ssid_len) { |
| ssid.assign( |
| dev->oper_ssid, dev->oper_ssid + dev->oper_ssid_len); |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, ssid}; |
| } |
| |
| std::pair<SupplicantStatus, uint32_t> P2pIface::getGroupCapabilityInternal( |
| const std::array<uint8_t, 6>& peer_address) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| const struct p2p_peer_info* info = |
| p2p_get_peer_info(wpa_s->global->p2p, peer_address.data(), 0); |
| if (!info) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, info->group_capab}; |
| } |
| |
| SupplicantStatus P2pIface::addBonjourServiceInternal( |
| const std::vector<uint8_t>& query, const std::vector<uint8_t>& response) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto query_buf = misc_utils::convertVectorToWpaBuf(query); |
| auto response_buf = misc_utils::convertVectorToWpaBuf(response); |
| if (!query_buf || !response_buf) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| if (wpas_p2p_service_add_bonjour( |
| wpa_s, query_buf.get(), response_buf.get())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| // If successful, the wpabuf is referenced internally and hence should |
| // not be freed. |
| query_buf.release(); |
| response_buf.release(); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::removeBonjourServiceInternal( |
| const std::vector<uint8_t>& query) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto query_buf = misc_utils::convertVectorToWpaBuf(query); |
| if (!query_buf) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| if (wpas_p2p_service_del_bonjour(wpa_s, query_buf.get())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::addUpnpServiceInternal( |
| uint32_t version, const std::string& service_name) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpas_p2p_service_add_upnp(wpa_s, version, service_name.c_str())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::removeUpnpServiceInternal( |
| uint32_t version, const std::string& service_name) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpas_p2p_service_del_upnp(wpa_s, version, service_name.c_str())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::flushServicesInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| wpas_p2p_service_flush(wpa_s); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| std::pair<SupplicantStatus, uint64_t> P2pIface::requestServiceDiscoveryInternal( |
| const std::array<uint8_t, 6>& peer_address, |
| const std::vector<uint8_t>& query) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto query_buf = misc_utils::convertVectorToWpaBuf(query); |
| if (!query_buf) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| const uint8_t* dst_addr = is_zero_ether_addr(peer_address.data()) |
| ? nullptr |
| : peer_address.data(); |
| uint64_t identifier = |
| wpas_p2p_sd_request(wpa_s, dst_addr, query_buf.get()); |
| if (identifier == 0) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, identifier}; |
| } |
| |
| SupplicantStatus P2pIface::cancelServiceDiscoveryInternal(uint64_t identifier) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (wpas_p2p_sd_cancel_request(wpa_s, identifier)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setMiracastModeInternal( |
| ISupplicantP2pIface::MiracastMode mode) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| uint8_t mode_internal = convertHidlMiracastModeToInternal(mode); |
| const std::string cmd_str = |
| kSetMiracastMode + std::to_string(mode_internal); |
| std::vector<char> cmd( |
| cmd_str.c_str(), cmd_str.c_str() + cmd_str.size() + 1); |
| char driver_cmd_reply_buf[4096] = {}; |
| if (wpa_drv_driver_cmd( |
| wpa_s, cmd.data(), driver_cmd_reply_buf, |
| sizeof(driver_cmd_reply_buf))) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::startWpsPbcInternal( |
| const std::string& group_ifname, const std::array<uint8_t, 6>& bssid) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}; |
| } |
| const uint8_t* bssid_addr = |
| is_zero_ether_addr(bssid.data()) ? nullptr : bssid.data(); |
| #ifdef CONFIG_AP |
| if (wpa_group_s->ap_iface) { |
| if (wpa_supplicant_ap_wps_pbc(wpa_group_s, bssid_addr, NULL)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| #endif /* CONFIG_AP */ |
| if (wpas_wps_start_pbc(wpa_group_s, bssid_addr, 0, 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::startWpsPinKeypadInternal( |
| const std::string& group_ifname, const std::string& pin) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}; |
| } |
| #ifdef CONFIG_AP |
| if (wpa_group_s->ap_iface) { |
| if (wpa_supplicant_ap_wps_pin( |
| wpa_group_s, nullptr, pin.c_str(), nullptr, 0, 0) < 0) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| #endif /* CONFIG_AP */ |
| if (wpas_wps_start_pin( |
| wpa_group_s, nullptr, pin.c_str(), 0, DEV_PW_DEFAULT)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| std::pair<SupplicantStatus, std::string> P2pIface::startWpsPinDisplayInternal( |
| const std::string& group_ifname, const std::array<uint8_t, 6>& bssid) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {{SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}, ""}; |
| } |
| const uint8_t* bssid_addr = |
| is_zero_ether_addr(bssid.data()) ? nullptr : bssid.data(); |
| int pin = wpas_wps_start_pin( |
| wpa_group_s, bssid_addr, nullptr, 0, DEV_PW_DEFAULT); |
| if (pin < 0) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, ""}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, |
| misc_utils::convertWpsPinToString(pin)}; |
| } |
| |
| SupplicantStatus P2pIface::cancelWpsInternal(const std::string& group_ifname) |
| { |
| struct wpa_supplicant* wpa_group_s = |
| retrieveGroupIfacePtr(group_ifname); |
| if (!wpa_group_s) { |
| return {SupplicantStatusCode::FAILURE_IFACE_UNKNOWN, ""}; |
| } |
| if (wpas_wps_cancel(wpa_group_s)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setWpsDeviceNameInternal(const std::string& name) |
| { |
| return iface_config_utils::setWpsDeviceName(retrieveIfacePtr(), name); |
| } |
| |
| SupplicantStatus P2pIface::setWpsDeviceTypeInternal( |
| const std::array<uint8_t, 8>& type) |
| { |
| return iface_config_utils::setWpsDeviceType(retrieveIfacePtr(), type); |
| } |
| |
| SupplicantStatus P2pIface::setWpsManufacturerInternal( |
| const std::string& manufacturer) |
| { |
| return iface_config_utils::setWpsManufacturer( |
| retrieveIfacePtr(), manufacturer); |
| } |
| |
| SupplicantStatus P2pIface::setWpsModelNameInternal( |
| const std::string& model_name) |
| { |
| return iface_config_utils::setWpsModelName( |
| retrieveIfacePtr(), model_name); |
| } |
| |
| SupplicantStatus P2pIface::setWpsModelNumberInternal( |
| const std::string& model_number) |
| { |
| return iface_config_utils::setWpsModelNumber( |
| retrieveIfacePtr(), model_number); |
| } |
| |
| SupplicantStatus P2pIface::setWpsSerialNumberInternal( |
| const std::string& serial_number) |
| { |
| return iface_config_utils::setWpsSerialNumber( |
| retrieveIfacePtr(), serial_number); |
| } |
| |
| SupplicantStatus P2pIface::setWpsConfigMethodsInternal(uint16_t config_methods) |
| { |
| return iface_config_utils::setWpsConfigMethods( |
| retrieveIfacePtr(), config_methods); |
| } |
| |
| SupplicantStatus P2pIface::enableWfdInternal(bool enable) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| wifi_display_enable(wpa_s->global, enable); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setWfdDeviceInfoInternal( |
| const std::array<uint8_t, 6>& info) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| std::vector<char> wfd_device_info_hex(info.size() * 2 + 1); |
| wpa_snprintf_hex( |
| wfd_device_info_hex.data(), wfd_device_info_hex.size(), info.data(), |
| info.size()); |
| // |wifi_display_subelem_set| expects the first 2 bytes |
| // to hold the lenght of the subelement. In this case it's |
| // fixed to 6, so prepend that. |
| std::string wfd_device_info_set_cmd_str = |
| std::to_string(kWfdDeviceInfoSubelemId) + " " + |
| kWfdDeviceInfoSubelemLenHexStr + wfd_device_info_hex.data(); |
| std::vector<char> wfd_device_info_set_cmd( |
| wfd_device_info_set_cmd_str.c_str(), |
| wfd_device_info_set_cmd_str.c_str() + |
| wfd_device_info_set_cmd_str.size() + 1); |
| if (wifi_display_subelem_set( |
| wpa_s->global, wfd_device_info_set_cmd.data())) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| std::pair<SupplicantStatus, std::vector<uint8_t>> |
| P2pIface::createNfcHandoverRequestMessageInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto buf = misc_utils::createWpaBufUniquePtr( |
| wpas_p2p_nfc_handover_req(wpa_s, 1)); |
| if (!buf) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, |
| misc_utils::convertWpaBufToVector(buf.get())}; |
| } |
| |
| std::pair<SupplicantStatus, std::vector<uint8_t>> |
| P2pIface::createNfcHandoverSelectMessageInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto buf = misc_utils::createWpaBufUniquePtr( |
| wpas_p2p_nfc_handover_sel(wpa_s, 1, 0)); |
| if (!buf) { |
| return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, {}}; |
| } |
| return {{SupplicantStatusCode::SUCCESS, ""}, |
| misc_utils::convertWpaBufToVector(buf.get())}; |
| } |
| |
| SupplicantStatus P2pIface::reportNfcHandoverResponseInternal( |
| const std::vector<uint8_t>& request) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto req = misc_utils::convertVectorToWpaBuf(request); |
| auto sel = misc_utils::convertVectorToWpaBuf(std::vector<uint8_t>{0}); |
| if (!req || !sel) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| |
| if (wpas_p2p_nfc_report_handover(wpa_s, 0, req.get(), sel.get(), 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::reportNfcHandoverInitiationInternal( |
| const std::vector<uint8_t>& select) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| auto req = misc_utils::convertVectorToWpaBuf(std::vector<uint8_t>{0}); |
| auto sel = misc_utils::convertVectorToWpaBuf(select); |
| if (!req || !sel) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| |
| if (wpas_p2p_nfc_report_handover(wpa_s, 1, req.get(), sel.get(), 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::saveConfigInternal() |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| if (!wpa_s->conf->update_config) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| if (wpa_config_write(wpa_s->confname, wpa_s->conf)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::addGroup_1_2Internal( |
| const std::vector<uint8_t>& ssid, const std::string& passphrase, |
| bool persistent, uint32_t freq, const std::array<uint8_t, 6>& peer_address, |
| bool joinExistingGroup) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| int vht = wpa_s->conf->p2p_go_vht; |
| int ht40 = wpa_s->conf->p2p_go_ht40 || vht; |
| |
| if (!isSsidValid(ssid)) { |
| return {SupplicantStatusCode::FAILURE_ARGS_INVALID, "SSID is invalid."}; |
| } |
| |
| if (!isPskPassphraseValid(passphrase)) { |
| return {SupplicantStatusCode::FAILURE_ARGS_INVALID, "passphrase is invalid."}; |
| } |
| |
| if (!joinExistingGroup) { |
| if (wpa_s->global->p2p == NULL) { |
| return {SupplicantStatusCode::FAILURE_IFACE_DISABLED, ""}; |
| } |
| |
| struct p2p_data *p2p = wpa_s->global->p2p; |
| os_memcpy(p2p->ssid, ssid.data(), ssid.size()); |
| p2p->ssid_len = ssid.size(); |
| p2p->ssid_set = 1; |
| |
| os_memset(p2p->passphrase, 0, sizeof(p2p->passphrase)); |
| os_memcpy(p2p->passphrase, passphrase.c_str(), passphrase.length()); |
| p2p->passphrase_set = 1; |
| |
| if (wpas_p2p_group_add( |
| wpa_s, persistent, freq, 0, ht40, vht, |
| VHT_CHANWIDTH_USE_HT, 0)) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, ""}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| // The rest is for group join. |
| wpa_printf(MSG_DEBUG, "P2P: Stop any on-going P2P FIND before group join."); |
| wpas_p2p_stop_find(wpa_s); |
| |
| struct wpa_bss *bss = findBssBySsid( |
| wpa_s, peer_address.data(), |
| ssid.data(), ssid.size()); |
| if (bss != NULL) { |
| wpa_printf(MSG_DEBUG, "P2P: Join group with Group Owner " MACSTR, |
| MAC2STR(bss->bssid)); |
| if (0 != joinGroup(wpa_s, bss->bssid, ssid, passphrase)) { |
| // no need to notify group join failure here, |
| // it will be handled by wpas_p2p_group_add_persistent |
| // called in joinGroup. |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, "Failed to join a group."}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| wpa_printf(MSG_INFO, "No matched BSS exists, try to find it by scan"); |
| |
| if (pending_scan_res_join_callback != NULL) { |
| wpa_printf(MSG_WARNING, "P2P: Renew scan result callback with new request."); |
| } |
| |
| pending_join_scan_callback = |
| [wpa_s, ssid, freq]() { |
| int ret = joinScanReq(wpa_s, ssid, freq); |
| // for BUSY case, the scan might be occupied by WiFi. |
| // Do not give up immediately, but try again later. |
| if (-EBUSY == ret) { |
| // re-schedule this join scan and don't consume retry count. |
| if (pending_scan_res_join_callback) { |
| wpa_s->p2p_join_scan_count--; |
| pending_scan_res_join_callback(); |
| } |
| } else if (0 != ret) { |
| notifyGroupJoinFailure(wpa_s); |
| pending_scan_res_join_callback = NULL; |
| } |
| }; |
| |
| pending_scan_res_join_callback = [wpa_s, ssid, passphrase, peer_address, this]() { |
| if (wpa_s->global->p2p_disabled) { |
| return; |
| } |
| |
| wpa_printf(MSG_DEBUG, "P2P: Scan results received for join (reinvoke)."); |
| |
| struct wpa_bss *bss = findBssBySsid( |
| wpa_s, peer_address.data(), ssid.data(), ssid.size()); |
| if (bss) { |
| if (0 != joinGroup(wpa_s, bss->bssid, ssid, passphrase)) { |
| wpa_printf(MSG_ERROR, "P2P: Failed to join a group."); |
| } |
| // no need to notify group join failure here, |
| // it will be handled by wpas_p2p_group_add_persistent |
| // called in joinGroup. |
| pending_scan_res_join_callback = NULL; |
| return; |
| } |
| |
| wpa_s->p2p_join_scan_count++; |
| wpa_printf(MSG_DEBUG, "P2P: Join scan attempt %d.", wpa_s->p2p_join_scan_count); |
| eloop_cancel_timeout(joinScanWrapper, wpa_s, NULL); |
| if (wpa_s->p2p_join_scan_count <= P2P_MAX_JOIN_SCAN_ATTEMPTS) { |
| wpa_printf(MSG_DEBUG, "P2P: Try join again later."); |
| eloop_register_timeout(1, 0, joinScanWrapper, wpa_s, this); |
| return; |
| } |
| |
| wpa_printf(MSG_ERROR, "P2P: Failed to find the group with " |
| "network name %s - stop join attempt", |
| ssid.data()); |
| notifyGroupJoinFailure(wpa_s); |
| pending_scan_res_join_callback = NULL; |
| }; |
| |
| wpa_s->p2p_join_scan_count = 0; |
| pending_join_scan_callback(); |
| if (pending_scan_res_join_callback == NULL) { |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, "Failed to start scan."}; |
| } |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| SupplicantStatus P2pIface::setMacRandomizationInternal(bool enable) |
| { |
| struct wpa_supplicant* wpa_s = retrieveIfacePtr(); |
| bool currentEnabledState = !!wpa_s->conf->p2p_device_random_mac_addr; |
| u8 *addr = NULL; |
| |
| // A dedicated p2p device is not managed by supplicant, |
| // supplicant could not change its MAC address. |
| if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) { |
| wpa_printf(MSG_ERROR, |
| "Dedicated P2P device don't support MAC randomization"); |
| return {SupplicantStatusCode::FAILURE_ARGS_INVALID, "NotSupported"}; |
| } |
| |
| // The same state, no change is needed. |
| if (currentEnabledState == enable) { |
| wpa_printf(MSG_DEBUG, "The random MAC is %s already.", |
| (enable) ? "enabled" : "disabled"); |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| if (enable) { |
| wpa_s->conf->p2p_device_random_mac_addr = 1; |
| wpa_s->conf->p2p_interface_random_mac_addr = 1; |
| |
| // restore config if it failed to set up MAC address. |
| if (wpas_p2p_mac_setup(wpa_s) < 0) { |
| wpa_s->conf->p2p_device_random_mac_addr = 0; |
| wpa_s->conf->p2p_interface_random_mac_addr = 0; |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, |
| "Failed to set up MAC address."}; |
| } |
| } else { |
| // disable random MAC will use original MAC address |
| // regardless of any saved persistent groups. |
| if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) { |
| wpa_printf(MSG_ERROR, "Failed to restore MAC address"); |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, |
| "Failed to restore MAC address."}; |
| } |
| |
| if (wpa_supplicant_update_mac_addr(wpa_s) < 0) { |
| wpa_printf(MSG_INFO, "Could not update MAC address information"); |
| return {SupplicantStatusCode::FAILURE_UNKNOWN, |
| "Failed to update MAC address."}; |
| } |
| wpa_s->conf->p2p_device_random_mac_addr = 0; |
| wpa_s->conf->p2p_interface_random_mac_addr = 0; |
| } |
| |
| // update internal data to send out correct device address in action frame. |
| os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN); |
| os_memcpy(wpa_s->global->p2p->cfg->dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN); |
| |
| return {SupplicantStatusCode::SUCCESS, ""}; |
| } |
| |
| /** |
| * Retrieve the underlying |wpa_supplicant| struct |
| * pointer for this iface. |
| * If the underlying iface is removed, then all RPC method calls on this object |
| * will return failure. |
| */ |
| wpa_supplicant* P2pIface::retrieveIfacePtr() |
| { |
| return wpa_supplicant_get_iface(wpa_global_, ifname_.c_str()); |
| } |
| |
| /** |
| * Retrieve the underlying |wpa_supplicant| struct |
| * pointer for this group iface. |
| */ |
| wpa_supplicant* P2pIface::retrieveGroupIfacePtr(const std::string& group_ifname) |
| { |
| return wpa_supplicant_get_iface(wpa_global_, group_ifname.c_str()); |
| } |
| |
| } // namespace implementation |
| } // namespace V1_2 |
| } // namespace supplicant |
| } // namespace wifi |
| } // namespace hardware |
| } // namespace android |