| /* |
| * hidl interface for wpa_supplicant daemon |
| * Copyright (c) 2004-2016, Jouni Malinen <j@w1.fi> |
| * Copyright (c) 2004-2016, Roshan Pius <rpius@google.com> |
| * |
| * This software may be distributed under the terms of the BSD license. |
| * See README for more details. |
| */ |
| |
| #ifndef WPA_SUPPLICANT_HIDL_HIDL_MANAGER_H |
| #define WPA_SUPPLICANT_HIDL_HIDL_MANAGER_H |
| |
| #include <map> |
| #include <string> |
| |
| #include <android/hardware/wifi/supplicant/1.0/ISupplicantCallback.h> |
| #include <android/hardware/wifi/supplicant/1.0/ISupplicantP2pIfaceCallback.h> |
| #include <android/hardware/wifi/supplicant/1.0/ISupplicantP2pNetworkCallback.h> |
| #include <android/hardware/wifi/supplicant/1.0/ISupplicantStaIfaceCallback.h> |
| #include <android/hardware/wifi/supplicant/1.0/ISupplicantStaNetworkCallback.h> |
| |
| #include "p2p_iface.h" |
| #include "p2p_network.h" |
| #include "rsn_supp/pmksa_cache.h" |
| #include "sta_iface.h" |
| #include "sta_network.h" |
| #include "supplicant.h" |
| |
| extern "C" |
| { |
| #include "utils/common.h" |
| #include "utils/includes.h" |
| #include "wpa_supplicant_i.h" |
| #include "driver_i.h" |
| } |
| |
| namespace android { |
| namespace hardware { |
| namespace wifi { |
| namespace supplicant { |
| namespace V1_3 { |
| namespace implementation { |
| using V1_0::ISupplicant; |
| using V1_0::ISupplicantP2pIface; |
| using V1_0::ISupplicantStaIface; |
| using V1_0::ISupplicantStaIfaceCallback; |
| using V1_0::P2pGroupCapabilityMask; |
| using V1_0::WpsConfigMethods; |
| |
| /** |
| * HidlManager is responsible for managing the lifetime of all |
| * hidl objects created by wpa_supplicant. This is a singleton |
| * class which is created by the supplicant core and can be used |
| * to get references to the hidl objects. |
| */ |
| class HidlManager |
| { |
| public: |
| static HidlManager *getInstance(); |
| static void destroyInstance(); |
| |
| // Methods called from wpa_supplicant core. |
| int registerHidlService(struct wpa_global *global); |
| int registerInterface(struct wpa_supplicant *wpa_s); |
| int unregisterInterface(struct wpa_supplicant *wpa_s); |
| int registerNetwork( |
| struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid); |
| int unregisterNetwork( |
| struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid); |
| int notifyStateChange(struct wpa_supplicant *wpa_s); |
| int notifyNetworkRequest( |
| struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, int type, |
| const char *param); |
| void notifyAnqpQueryDone( |
| struct wpa_supplicant *wpa_s, const u8 *bssid, const char *result, |
| const struct wpa_bss_anqp *anqp); |
| void notifyHs20IconQueryDone( |
| struct wpa_supplicant *wpa_s, const u8 *bssid, |
| const char *file_name, const u8 *image, u32 image_length); |
| void notifyHs20RxSubscriptionRemediation( |
| struct wpa_supplicant *wpa_s, const char *url, u8 osu_method); |
| void notifyHs20RxDeauthImminentNotice( |
| struct wpa_supplicant *wpa_s, u8 code, u16 reauth_delay, |
| const char *url); |
| void notifyDisconnectReason(struct wpa_supplicant *wpa_s); |
| void notifyAssocReject(struct wpa_supplicant *wpa_s); |
| void notifyAuthTimeout(struct wpa_supplicant *wpa_s); |
| void notifyBssidChanged(struct wpa_supplicant *wpa_s); |
| void notifyWpsEventFail( |
| struct wpa_supplicant *wpa_s, uint8_t *peer_macaddr, |
| uint16_t config_error, uint16_t error_indication); |
| void notifyWpsEventSuccess(struct wpa_supplicant *wpa_s); |
| void notifyWpsEventPbcOverlap(struct wpa_supplicant *wpa_s); |
| void notifyP2pDeviceFound( |
| struct wpa_supplicant *wpa_s, const u8 *addr, |
| const struct p2p_peer_info *info, const u8 *peer_wfd_device_info, |
| u8 peer_wfd_device_info_len); |
| void notifyP2pDeviceLost( |
| struct wpa_supplicant *wpa_s, const u8 *p2p_device_addr); |
| void notifyP2pFindStopped(struct wpa_supplicant *wpa_s); |
| void notifyP2pGoNegReq( |
| struct wpa_supplicant *wpa_s, const u8 *src_addr, u16 dev_passwd_id, |
| u8 go_intent); |
| void notifyP2pGoNegCompleted( |
| struct wpa_supplicant *wpa_s, const struct p2p_go_neg_results *res); |
| void notifyP2pGroupFormationFailure( |
| struct wpa_supplicant *wpa_s, const char *reason); |
| void notifyP2pGroupStarted( |
| struct wpa_supplicant *wpa_group_s, const struct wpa_ssid *ssid, |
| int persistent, int client); |
| void notifyP2pGroupRemoved( |
| struct wpa_supplicant *wpa_group_s, const struct wpa_ssid *ssid, |
| const char *role); |
| void notifyP2pInvitationReceived( |
| struct wpa_supplicant *wpa_s, const u8 *sa, const u8 *go_dev_addr, |
| const u8 *bssid, int id, int op_freq); |
| void notifyP2pInvitationResult( |
| struct wpa_supplicant *wpa_s, int status, const u8 *bssid); |
| void notifyP2pProvisionDiscovery( |
| struct wpa_supplicant *wpa_s, const u8 *dev_addr, int request, |
| enum p2p_prov_disc_status status, u16 config_methods, |
| unsigned int generated_pin); |
| void notifyP2pSdResponse( |
| struct wpa_supplicant *wpa_s, const u8 *sa, u16 update_indic, |
| const u8 *tlvs, size_t tlvs_len); |
| void notifyApStaAuthorized( |
| struct wpa_supplicant *wpa_s, const u8 *sta, |
| const u8 *p2p_dev_addr); |
| void notifyApStaDeauthorized( |
| struct wpa_supplicant *wpa_s, const u8 *sta, |
| const u8 *p2p_dev_addr); |
| void notifyEapError(struct wpa_supplicant *wpa_s, int error_code); |
| void notifyDppConfigReceived(struct wpa_supplicant *wpa_s, |
| struct wpa_ssid *config); |
| void notifyDppConfigSent(struct wpa_supplicant *wpa_s); |
| void notifyDppSuccess(struct wpa_supplicant *wpa_s, DppSuccessCode code); |
| void notifyDppFailure(struct wpa_supplicant *wpa_s, |
| android::hardware::wifi::supplicant::V1_3::DppFailureCode code); |
| void notifyDppFailure(struct wpa_supplicant *wpa_s, |
| android::hardware::wifi::supplicant::V1_3::DppFailureCode code, |
| const char *ssid, const char *channel_list, unsigned short band_list[], |
| int size); |
| void notifyDppProgress(struct wpa_supplicant *wpa_s, |
| android::hardware::wifi::supplicant::V1_3::DppProgressCode code); |
| void notifyPmkCacheAdded(struct wpa_supplicant *wpa_s, |
| struct rsn_pmksa_cache_entry *pmksa_entry); |
| void notifyBssTmStatus(struct wpa_supplicant *wpa_s); |
| |
| // Methods called from hidl objects. |
| void notifyExtRadioWorkStart(struct wpa_supplicant *wpa_s, uint32_t id); |
| void notifyExtRadioWorkTimeout( |
| struct wpa_supplicant *wpa_s, uint32_t id); |
| |
| int getP2pIfaceHidlObjectByIfname( |
| const std::string &ifname, |
| android::sp<ISupplicantP2pIface> *iface_object); |
| int getStaIfaceHidlObjectByIfname( |
| const std::string &ifname, |
| android::sp<V1_1::ISupplicantStaIface> *iface_object); |
| int getP2pNetworkHidlObjectByIfnameAndNetworkId( |
| const std::string &ifname, int network_id, |
| android::sp<ISupplicantP2pNetwork> *network_object); |
| int getStaNetworkHidlObjectByIfnameAndNetworkId( |
| const std::string &ifname, int network_id, |
| android::sp<ISupplicantStaNetwork> *network_object); |
| int addSupplicantCallbackHidlObject( |
| const android::sp<ISupplicantCallback> &callback); |
| int addP2pIfaceCallbackHidlObject( |
| const std::string &ifname, |
| const android::sp<ISupplicantP2pIfaceCallback> &callback); |
| int addStaIfaceCallbackHidlObject( |
| const std::string &ifname, |
| const android::sp<ISupplicantStaIfaceCallback> &callback); |
| int addP2pNetworkCallbackHidlObject( |
| const std::string &ifname, int network_id, |
| const android::sp<ISupplicantP2pNetworkCallback> &callback); |
| int addStaNetworkCallbackHidlObject( |
| const std::string &ifname, int network_id, |
| const android::sp<ISupplicantStaNetworkCallback> &callback); |
| |
| private: |
| HidlManager() = default; |
| ~HidlManager() = default; |
| HidlManager(const HidlManager &) = default; |
| HidlManager &operator=(const HidlManager &) = default; |
| |
| void removeSupplicantCallbackHidlObject( |
| const android::sp<ISupplicantCallback> &callback); |
| void removeP2pIfaceCallbackHidlObject( |
| const std::string &ifname, |
| const android::sp<ISupplicantP2pIfaceCallback> &callback); |
| void removeStaIfaceCallbackHidlObject( |
| const std::string &ifname, |
| const android::sp<ISupplicantStaIfaceCallback> &callback); |
| void removeP2pNetworkCallbackHidlObject( |
| const std::string &ifname, int network_id, |
| const android::sp<ISupplicantP2pNetworkCallback> &callback); |
| void removeStaNetworkCallbackHidlObject( |
| const std::string &ifname, int network_id, |
| const android::sp<ISupplicantStaNetworkCallback> &callback); |
| |
| void callWithEachSupplicantCallback( |
| const std::function<android::hardware::Return<void>( |
| android::sp<ISupplicantCallback>)> &method); |
| void callWithEachP2pIfaceCallback( |
| const std::string &ifname, |
| const std::function<android::hardware::Return<void>( |
| android::sp<ISupplicantP2pIfaceCallback>)> &method); |
| void callWithEachStaIfaceCallback( |
| const std::string &ifname, |
| const std::function<android::hardware::Return<void>( |
| android::sp<ISupplicantStaIfaceCallback>)> &method); |
| void callWithEachStaIfaceCallback_1_1( |
| const std::string &ifname, |
| const std::function<android::hardware::Return<void>( |
| android::sp<V1_1::ISupplicantStaIfaceCallback>)> &method); |
| void callWithEachStaIfaceCallback_1_2( |
| const std::string &ifname, |
| const std::function<android::hardware::Return<void>( |
| android::sp<V1_2::ISupplicantStaIfaceCallback>)> &method); |
| void callWithEachStaIfaceCallback_1_3( |
| const std::string &ifname, |
| const std::function<android::hardware::Return<void>( |
| android::sp<V1_3::ISupplicantStaIfaceCallback>)> &method); |
| template <class CallbackTypeDerived> |
| void callWithEachStaIfaceCallbackDerived( |
| const std::string &ifname, |
| const std::function< |
| Return<void>(android::sp<CallbackTypeDerived>)> &method); |
| void callWithEachP2pNetworkCallback( |
| const std::string &ifname, int network_id, |
| const std::function<android::hardware::Return<void>( |
| android::sp<ISupplicantP2pNetworkCallback>)> &method); |
| void callWithEachStaNetworkCallback( |
| const std::string &ifname, int network_id, |
| const std::function<android::hardware::Return<void>( |
| android::sp<ISupplicantStaNetworkCallback>)> &method); |
| |
| // Singleton instance of this class. |
| static HidlManager *instance_; |
| // The main hidl service object. |
| android::sp<Supplicant> supplicant_object_; |
| // Map of all the P2P interface specific hidl objects controlled by |
| // wpa_supplicant. This map is keyed in by the corresponding |
| // |ifname|. |
| std::map<const std::string, android::sp<P2pIface>> |
| p2p_iface_object_map_; |
| // Map of all the STA interface specific hidl objects controlled by |
| // wpa_supplicant. This map is keyed in by the corresponding |
| // |ifname|. |
| std::map<const std::string, android::sp<StaIface>> |
| sta_iface_object_map_; |
| // Map of all the P2P network specific hidl objects controlled by |
| // wpa_supplicant. This map is keyed in by the corresponding |
| // |ifname| & |network_id|. |
| std::map<const std::string, android::sp<P2pNetwork>> |
| p2p_network_object_map_; |
| // Map of all the STA network specific hidl objects controlled by |
| // wpa_supplicant. This map is keyed in by the corresponding |
| // |ifname| & |network_id|. |
| std::map<const std::string, android::sp<StaNetwork>> |
| sta_network_object_map_; |
| |
| // Callback registered for the main hidl service object. |
| std::vector<android::sp<ISupplicantCallback>> supplicant_callbacks_; |
| // Map of all the callbacks registered for P2P interface specific |
| // hidl objects controlled by wpa_supplicant. This map is keyed in by |
| // the corresponding |ifname|. |
| std::map< |
| const std::string, |
| std::vector<android::sp<ISupplicantP2pIfaceCallback>>> |
| p2p_iface_callbacks_map_; |
| // Map of all the callbacks registered for STA interface specific |
| // hidl objects controlled by wpa_supplicant. This map is keyed in by |
| // the corresponding |ifname|. |
| std::map< |
| const std::string, |
| std::vector<android::sp<ISupplicantStaIfaceCallback>>> |
| sta_iface_callbacks_map_; |
| // Map of all the callbacks registered for P2P network specific |
| // hidl objects controlled by wpa_supplicant. This map is keyed in by |
| // the corresponding |ifname| & |network_id|. |
| std::map< |
| const std::string, |
| std::vector<android::sp<ISupplicantP2pNetworkCallback>>> |
| p2p_network_callbacks_map_; |
| // Map of all the callbacks registered for STA network specific |
| // hidl objects controlled by wpa_supplicant. This map is keyed in by |
| // the corresponding |ifname| & |network_id|. |
| std::map< |
| const std::string, |
| std::vector<android::sp<ISupplicantStaNetworkCallback>>> |
| sta_network_callbacks_map_; |
| |
| #if 0 // TODO(b/31632518): HIDL object death notifications. |
| /** |
| * Helper class used to deregister the callback object reference from |
| * our callback list on the death of the hidl object. |
| * This class stores a reference of the callback hidl object and a |
| * function to be called to indicate the death of the hidl object. |
| */ |
| template <class CallbackType> |
| class CallbackObjectDeathNotifier |
| : public android::hardware::IBinder::DeathRecipient |
| { |
| public: |
| CallbackObjectDeathNotifier( |
| const android::sp<CallbackType> &callback, |
| const std::function<void(const android::sp<CallbackType> &)> |
| &on_hidl_died) |
| : callback_(callback), on_hidl_died_(on_hidl_died) |
| { |
| } |
| void binderDied(const android::wp<android::hardware::IBinder> |
| & /* who */) override |
| { |
| on_hidl_died_(callback_); |
| } |
| |
| private: |
| // The callback hidl object reference. |
| const android::sp<CallbackType> callback_; |
| // Callback function to be called when the hidl dies. |
| const std::function<void(const android::sp<CallbackType> &)> |
| on_hidl_died_; |
| }; |
| #endif |
| }; |
| |
| // The hidl interface uses some values which are the same as internal ones to |
| // avoid nasty runtime conversion functions. So, adding compile time asserts |
| // to guard against any internal changes breaking the hidl interface. |
| static_assert( |
| static_cast<uint32_t>(ISupplicant::DebugLevel::EXCESSIVE) == MSG_EXCESSIVE, |
| "Debug level value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicant::DebugLevel::ERROR) == MSG_ERROR, |
| "Debug level value mismatch"); |
| |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::NONE) == |
| WPA_KEY_MGMT_NONE, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::WPA_PSK) == |
| WPA_KEY_MGMT_PSK, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::WPA_EAP) == |
| WPA_KEY_MGMT_IEEE8021X, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::IEEE8021X) == |
| WPA_KEY_MGMT_IEEE8021X_NO_WPA, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::FT_EAP) == |
| WPA_KEY_MGMT_FT_IEEE8021X, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::FT_PSK) == |
| WPA_KEY_MGMT_FT_PSK, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::OSEN) == |
| WPA_KEY_MGMT_OSEN, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::SAE) == |
| WPA_KEY_MGMT_SAE, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::SUITE_B_192) == |
| WPA_KEY_MGMT_IEEE8021X_SUITE_B_192, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::OWE) == |
| WPA_KEY_MGMT_OWE, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::WPA_PSK_SHA256) == |
| WPA_KEY_MGMT_PSK_SHA256, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::KeyMgmtMask::WPA_EAP_SHA256) == |
| WPA_KEY_MGMT_IEEE8021X_SHA256, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(V1_3::ISupplicantStaNetwork::KeyMgmtMask::WAPI_PSK) == |
| WPA_KEY_MGMT_WAPI_PSK, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(V1_3::ISupplicantStaNetwork::KeyMgmtMask::WAPI_CERT) == |
| WPA_KEY_MGMT_WAPI_CERT, |
| "KeyMgmt value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::ProtoMask::WPA) == |
| WPA_PROTO_WPA, |
| "Proto value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::ProtoMask::RSN) == |
| WPA_PROTO_RSN, |
| "Proto value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::ProtoMask::OSEN) == |
| WPA_PROTO_OSEN, |
| "Proto value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(V1_3::ISupplicantStaNetwork::ProtoMask::WAPI) == |
| WPA_PROTO_WAPI, |
| "Proto value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::AuthAlgMask::OPEN) == |
| WPA_AUTH_ALG_OPEN, |
| "AuthAlg value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::AuthAlgMask::SHARED) == |
| WPA_AUTH_ALG_SHARED, |
| "AuthAlg value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::AuthAlgMask::LEAP) == |
| WPA_AUTH_ALG_LEAP, |
| "AuthAlg value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::WEP40) == |
| WPA_CIPHER_WEP40, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::WEP104) == |
| WPA_CIPHER_WEP104, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::TKIP) == |
| WPA_CIPHER_TKIP, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::CCMP) == |
| WPA_CIPHER_CCMP, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::GroupCipherMask::GCMP_256) == |
| WPA_CIPHER_GCMP_256, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(V1_3::ISupplicantStaNetwork::GroupCipherMask::SMS4) == |
| WPA_CIPHER_SMS4, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaNetwork::GroupCipherMask::GTK_NOT_USED) == |
| WPA_CIPHER_GTK_NOT_USED, |
| "GroupCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::PairwiseCipherMask::NONE) == |
| WPA_CIPHER_NONE, |
| "PairwiseCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::PairwiseCipherMask::TKIP) == |
| WPA_CIPHER_TKIP, |
| "PairwiseCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaNetwork::PairwiseCipherMask::CCMP) == |
| WPA_CIPHER_CCMP, |
| "PairwiseCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaNetwork::PairwiseCipherMask::GCMP_256) == |
| WPA_CIPHER_GCMP_256, |
| "PairwiseCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| V1_3::ISupplicantStaNetwork::PairwiseCipherMask::SMS4) == |
| WPA_CIPHER_SMS4, |
| "PairwiseCipher value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaIfaceCallback::State::DISCONNECTED) == |
| WPA_DISCONNECTED, |
| "State value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaIfaceCallback::State::COMPLETED) == |
| WPA_COMPLETED, |
| "State value mismatch"); |
| |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaIface::AnqpInfoId::VENUE_NAME) == |
| ANQP_VENUE_NAME, |
| "ANQP ID value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaIface::AnqpInfoId::ROAMING_CONSORTIUM) == |
| ANQP_ROAMING_CONSORTIUM, |
| "ANQP ID value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaIface::AnqpInfoId::NAI_REALM) == |
| ANQP_NAI_REALM, |
| "ANQP ID value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaIface::AnqpInfoId::IP_ADDR_TYPE_AVAILABILITY) == |
| ANQP_IP_ADDR_TYPE_AVAILABILITY, |
| "ANQP ID value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaIface::AnqpInfoId::ANQP_3GPP_CELLULAR_NETWORK) == |
| ANQP_3GPP_CELLULAR_NETWORK, |
| "ANQP ID value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaIface::AnqpInfoId::DOMAIN_NAME) == |
| ANQP_DOMAIN_NAME, |
| "ANQP ID value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaIface::Hs20AnqpSubtypes::OPERATOR_FRIENDLY_NAME) == |
| HS20_STYPE_OPERATOR_FRIENDLY_NAME, |
| "HS Subtype value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(ISupplicantStaIface::Hs20AnqpSubtypes::WAN_METRICS) == |
| HS20_STYPE_WAN_METRICS, |
| "HS Subtype value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaIface::Hs20AnqpSubtypes::CONNECTION_CAPABILITY) == |
| HS20_STYPE_CONNECTION_CAPABILITY, |
| "HS Subtype value mismatch"); |
| static_assert( |
| static_cast<uint32_t>( |
| ISupplicantStaIface::Hs20AnqpSubtypes::OSU_PROVIDERS_LIST) == |
| HS20_STYPE_OSU_PROVIDERS_LIST, |
| "HS Subtype value mismatch"); |
| |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantStaIfaceCallback::WpsConfigError::NO_ERROR) == |
| WPS_CFG_NO_ERROR, |
| "Wps config error value mismatch"); |
| static_assert( |
| static_cast<uint16_t>(ISupplicantStaIfaceCallback::WpsConfigError:: |
| PUBLIC_KEY_HASH_MISMATCH) == |
| WPS_CFG_PUBLIC_KEY_HASH_MISMATCH, |
| "Wps config error value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantStaIfaceCallback::WpsErrorIndication::NO_ERROR) == |
| WPS_EI_NO_ERROR, |
| "Wps error indication value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantStaIfaceCallback::WpsErrorIndication::AUTH_FAILURE) == |
| WPS_EI_AUTH_FAILURE, |
| "Wps error indication value mismatch"); |
| |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::USBA) == WPS_CONFIG_USBA, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::ETHERNET) == WPS_CONFIG_ETHERNET, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::LABEL) == WPS_CONFIG_LABEL, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::DISPLAY) == WPS_CONFIG_DISPLAY, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::INT_NFC_TOKEN) == |
| WPS_CONFIG_INT_NFC_TOKEN, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::EXT_NFC_TOKEN) == |
| WPS_CONFIG_EXT_NFC_TOKEN, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::NFC_INTERFACE) == |
| WPS_CONFIG_NFC_INTERFACE, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::PUSHBUTTON) == |
| WPS_CONFIG_PUSHBUTTON, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::KEYPAD) == WPS_CONFIG_KEYPAD, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::VIRT_PUSHBUTTON) == |
| WPS_CONFIG_VIRT_PUSHBUTTON, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::PHY_PUSHBUTTON) == |
| WPS_CONFIG_PHY_PUSHBUTTON, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::P2PS) == WPS_CONFIG_P2PS, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::VIRT_DISPLAY) == |
| WPS_CONFIG_VIRT_DISPLAY, |
| "Wps config value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(WpsConfigMethods::PHY_DISPLAY) == |
| WPS_CONFIG_PHY_DISPLAY, |
| "Wps config value mismatch"); |
| |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::GROUP_OWNER) == |
| P2P_GROUP_CAPAB_GROUP_OWNER, |
| "P2P capability value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::PERSISTENT_GROUP) == |
| P2P_GROUP_CAPAB_PERSISTENT_GROUP, |
| "P2P capability value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::GROUP_LIMIT) == |
| P2P_GROUP_CAPAB_GROUP_LIMIT, |
| "P2P capability value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::INTRA_BSS_DIST) == |
| P2P_GROUP_CAPAB_INTRA_BSS_DIST, |
| "P2P capability value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::CROSS_CONN) == |
| P2P_GROUP_CAPAB_CROSS_CONN, |
| "P2P capability value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::PERSISTENT_RECONN) == |
| P2P_GROUP_CAPAB_PERSISTENT_RECONN, |
| "P2P capability value mismatch"); |
| static_assert( |
| static_cast<uint32_t>(P2pGroupCapabilityMask::GROUP_FORMATION) == |
| P2P_GROUP_CAPAB_GROUP_FORMATION, |
| "P2P capability value mismatch"); |
| |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::DEFAULT) == |
| DEV_PW_DEFAULT, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::USER_SPECIFIED) == |
| DEV_PW_USER_SPECIFIED, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::MACHINE_SPECIFIED) == |
| DEV_PW_MACHINE_SPECIFIED, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::REKEY) == DEV_PW_REKEY, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::PUSHBUTTON) == |
| DEV_PW_PUSHBUTTON, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::REGISTRAR_SPECIFIED) == |
| DEV_PW_REGISTRAR_SPECIFIED, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>(ISupplicantP2pIfaceCallback::WpsDevPasswordId:: |
| NFC_CONNECTION_HANDOVER) == |
| DEV_PW_NFC_CONNECTION_HANDOVER, |
| "Wps dev password id value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::WpsDevPasswordId::P2PS_DEFAULT) == |
| DEV_PW_P2PS_DEFAULT, |
| "Wps dev password id value mismatch"); |
| |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::SUCCESS) == P2P_SC_SUCCESS, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>(ISupplicantP2pIfaceCallback::P2pStatusCode:: |
| FAIL_INFO_CURRENTLY_UNAVAILABLE) == |
| P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_INCOMPATIBLE_PARAMS) == |
| P2P_SC_FAIL_INCOMPATIBLE_PARAMS, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_LIMIT_REACHED) == |
| P2P_SC_FAIL_LIMIT_REACHED, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_INVALID_PARAMS) == |
| P2P_SC_FAIL_INVALID_PARAMS, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>(ISupplicantP2pIfaceCallback::P2pStatusCode:: |
| FAIL_UNABLE_TO_ACCOMMODATE) == |
| P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_PREV_PROTOCOL_ERROR) == |
| P2P_SC_FAIL_PREV_PROTOCOL_ERROR, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_NO_COMMON_CHANNELS) == |
| P2P_SC_FAIL_NO_COMMON_CHANNELS, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_UNKNOWN_GROUP) == |
| P2P_SC_FAIL_UNKNOWN_GROUP, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_BOTH_GO_INTENT_15) == |
| P2P_SC_FAIL_BOTH_GO_INTENT_15, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>(ISupplicantP2pIfaceCallback::P2pStatusCode:: |
| FAIL_INCOMPATIBLE_PROV_METHOD) == |
| P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::FAIL_REJECTED_BY_USER) == |
| P2P_SC_FAIL_REJECTED_BY_USER, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pStatusCode::SUCCESS_DEFERRED) == |
| P2P_SC_SUCCESS_DEFERRED, |
| "P2P status code value mismatch"); |
| |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode::SUCCESS) == |
| P2P_PROV_DISC_SUCCESS, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode::TIMEOUT) == |
| P2P_PROV_DISC_TIMEOUT, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode::REJECTED) == |
| P2P_PROV_DISC_REJECTED, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode::TIMEOUT_JOIN) == |
| P2P_PROV_DISC_TIMEOUT_JOIN, |
| "P2P status code value mismatch"); |
| static_assert( |
| static_cast<uint16_t>( |
| ISupplicantP2pIfaceCallback::P2pProvDiscStatusCode::INFO_UNAVAILABLE) == |
| P2P_PROV_DISC_INFO_UNAVAILABLE, |
| "P2P status code value mismatch"); |
| } // namespace implementation |
| } // namespace V1_3 |
| } // namespace supplicant |
| } // namespace wifi |
| } // namespace hardware |
| } // namespace android |
| #endif // WPA_SUPPLICANT_HIDL_HIDL_MANAGER_H |
