path: root/wpa_supplicant/aidl/aidl_manager.h

/*
 * WPA Supplicant - Manager for Aidl interface objects
 * Copyright (c) 2021, Google Inc. All rights reserved.
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#ifndef WPA_SUPPLICANT_AIDL_AIDL_MANAGER_H
#define WPA_SUPPLICANT_AIDL_AIDL_MANAGER_H

#include <map>
#include <string>

#include <aidl/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.h>
#include <aidl/android/hardware/wifi/supplicant/ISupplicantStaIfaceCallback.h>
#include <aidl/android/hardware/wifi/supplicant/ISupplicantStaNetworkCallback.h>

#include "certificate_utils.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 aidl {
namespace android {
namespace hardware {
namespace wifi {
namespace supplicant {

/**
 * AidlManager is responsible for managing the lifetime of all
 * aidl 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 aidl objects.
 */
class AidlManager
{
public:
	static AidlManager *getInstance();
	static void destroyInstance();

	// Methods called from wpa_supplicant core.
	int registerAidlService(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 notifyPermanentIdReqDenied(
		struct wpa_supplicant *wpa_s);
	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 notifyHs20RxTermsAndConditionsAcceptance(
			struct wpa_supplicant *wpa_s, const char *url);
	void notifyDisconnectReason(struct wpa_supplicant *wpa_s);
	void notifyAssocReject(struct wpa_supplicant *wpa_s, const u8 *bssid,
		u8 timed_out, const u8 *assoc_resp_ie, size_t assoc_resp_ie_len);
	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, const u8 *peer_wfd_r2_device_info,
		u8 peer_wfd_r2_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, const u8 *ip);
	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, const u8 *ip);
	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,
		bool conn_status_requested);
	void notifyDppConfigSent(struct wpa_supplicant *wpa_s);
	void notifyDppConnectionStatusSent(struct wpa_supplicant *wpa_s,
		enum dpp_status_error result);
	void notifyDppSuccess(struct wpa_supplicant *wpa_s, DppEventType code);
	void notifyDppFailure(struct wpa_supplicant *wpa_s,
			DppFailureCode code);
	void notifyDppFailure(struct wpa_supplicant *wpa_s,
			DppFailureCode code,
			const char *ssid, const char *channel_list, unsigned short band_list[],
			int size);
	void notifyDppProgress(struct wpa_supplicant *wpa_s,
			DppProgressCode code);
	void notifyPmkCacheAdded(struct wpa_supplicant *wpa_s,
			struct rsn_pmksa_cache_entry *pmksa_entry);
	void notifyBssTmStatus(struct wpa_supplicant *wpa_s);
	void notifyTransitionDisable(struct wpa_supplicant *wpa_s,
			struct wpa_ssid *ssid,
			u8 bitmap);
	void notifyNetworkNotFound(struct wpa_supplicant *wpa_s);
	void notifyFrequencyChanged(struct wpa_supplicant *wpa_s, int frequency);
	void notifyCertification(struct wpa_supplicant *wpa_s,
			int depth, const char *subject,
			const char *altsubject[],
			int num_altsubject,
			const char *cert_hash,
			const struct wpabuf *cert);
	void notifyAuxiliaryEvent(struct wpa_supplicant *wpa_s,
			AuxiliarySupplicantEventCode event_code,
			const char *reason_string);
	void notifyQosPolicyReset(struct wpa_supplicant *wpa_s);
	void notifyQosPolicyRequest(struct wpa_supplicant *wpa_s,
			struct dscp_policy_data *policies,
			int num_policies);
	ssize_t getCertificate(const char* alias, uint8_t** value);
	ssize_t listAliases(const char *prefix, char ***aliases);
	void notifyQosPolicyScsResponse(struct wpa_supplicant *wpa_s,
			unsigned int count, int **scs_resp);
	void notifyMloLinksInfoChanged(struct wpa_supplicant *wpa_s,
				       enum mlo_info_change_reason reason);

	// Methods called from aidl objects.
	void notifyExtRadioWorkStart(struct wpa_supplicant *wpa_s, uint32_t id);
	void notifyExtRadioWorkTimeout(
		struct wpa_supplicant *wpa_s, uint32_t id);

	int getP2pIfaceAidlObjectByIfname(
		const std::string &ifname,
		std::shared_ptr<ISupplicantP2pIface> *iface_object);
	int getStaIfaceAidlObjectByIfname(
		const std::string &ifname,
		std::shared_ptr<ISupplicantStaIface> *iface_object);
	int getP2pNetworkAidlObjectByIfnameAndNetworkId(
		const std::string &ifname, int network_id,
		std::shared_ptr<ISupplicantP2pNetwork> *network_object);
	int getStaNetworkAidlObjectByIfnameAndNetworkId(
		const std::string &ifname, int network_id,
		std::shared_ptr<ISupplicantStaNetwork> *network_object);
	int addSupplicantCallbackAidlObject(
		const std::shared_ptr<ISupplicantCallback> &callback);
	int addP2pIfaceCallbackAidlObject(
		const std::string &ifname,
		const std::shared_ptr<ISupplicantP2pIfaceCallback> &callback);
	int addStaIfaceCallbackAidlObject(
		const std::string &ifname,
		const std::shared_ptr<ISupplicantStaIfaceCallback> &callback);
	int addStaNetworkCallbackAidlObject(
		const std::string &ifname, int network_id,
		const std::shared_ptr<ISupplicantStaNetworkCallback> &callback);
	int registerNonStandardCertCallbackAidlObject(
		const std::shared_ptr<INonStandardCertCallback> &callback);

private:
	AidlManager() = default;
	~AidlManager() = default;
	AidlManager(const AidlManager &) = default;
	AidlManager &operator=(const AidlManager &) = default;

	struct wpa_supplicant *getTargetP2pIfaceForGroup(
		struct wpa_supplicant *wpa_s);
	void removeSupplicantCallbackAidlObject(
		const std::shared_ptr<ISupplicantCallback> &callback);
	void removeP2pIfaceCallbackAidlObject(
		const std::string &ifname,
		const std::shared_ptr<ISupplicantP2pIfaceCallback> &callback);
	void removeStaIfaceCallbackAidlObject(
		const std::string &ifname,
		const std::shared_ptr<ISupplicantStaIfaceCallback> &callback);
	void removeStaNetworkCallbackAidlObject(
		const std::string &ifname, int network_id,
		const std::shared_ptr<ISupplicantStaNetworkCallback> &callback);

	void callWithEachSupplicantCallback(
		const std::function<ndk::ScopedAStatus(
		std::shared_ptr<ISupplicantCallback>)> &method);
	void callWithEachP2pIfaceCallback(
		const std::string &ifname,
		const std::function<ndk::ScopedAStatus(
		std::shared_ptr<ISupplicantP2pIfaceCallback>)> &method);
	void callWithEachStaIfaceCallback(
		const std::string &ifname,
		const std::function<ndk::ScopedAStatus(
		std::shared_ptr<ISupplicantStaIfaceCallback>)> &method);
	void callWithEachStaNetworkCallback(
		const std::string &ifname, int network_id,
		const std::function<::ndk::ScopedAStatus(
		std::shared_ptr<ISupplicantStaNetworkCallback>)> &method);

	// Singleton instance of this class.
	static AidlManager *instance_;
	// Death notifier.
	AIBinder_DeathRecipient* death_notifier_;
	// The main aidl service object.
	std::shared_ptr<Supplicant> supplicant_object_;
	// Map of all the P2P interface specific aidl objects controlled by
	// wpa_supplicant. This map is keyed in by the corresponding
	// |ifname|.
	std::map<const std::string, std::shared_ptr<P2pIface>>
		p2p_iface_object_map_;
	// Map of all the STA interface specific aidl objects controlled by
	// wpa_supplicant. This map is keyed in by the corresponding
	// |ifname|.
	std::map<const std::string, std::shared_ptr<StaIface>>
		sta_iface_object_map_;
	// Map of all the P2P network specific aidl objects controlled by
	// wpa_supplicant. This map is keyed in by the corresponding
	// |ifname| & |network_id|.
	std::map<const std::string, std::shared_ptr<P2pNetwork>>
		p2p_network_object_map_;
	// Map of all the STA network specific aidl objects controlled by
	// wpa_supplicant. This map is keyed in by the corresponding
	// |ifname| & |network_id|.
	std::map<const std::string, std::shared_ptr<StaNetwork>>
		sta_network_object_map_;

	// Callbacks registered for the main aidl service object.
	std::vector<std::shared_ptr<ISupplicantCallback>> supplicant_callbacks_;
	// Map of all the callbacks registered for P2P interface specific
	// aidl objects controlled by wpa_supplicant.  This map is keyed in by
	// the corresponding |ifname|.
	std::map<
		const std::string,
		std::vector<std::shared_ptr<ISupplicantP2pIfaceCallback>>>
		p2p_iface_callbacks_map_;
	// Map of all the callbacks registered for STA interface specific
	// aidl objects controlled by wpa_supplicant.  This map is keyed in by
	// the corresponding |ifname|.
	std::map<
		const std::string,
		std::vector<std::shared_ptr<ISupplicantStaIfaceCallback>>>
		sta_iface_callbacks_map_;
	// Map of all the callbacks registered for STA network specific
	// aidl objects controlled by wpa_supplicant.  This map is keyed in by
	// the corresponding |ifname| & |network_id|.
	std::map<
		const std::string,
		std::vector<std::shared_ptr<ISupplicantStaNetworkCallback>>>
		sta_network_callbacks_map_;
	// NonStandardCertCallback registered by the client.
	std::shared_ptr<INonStandardCertCallback> non_standard_cert_callback_;
};

// The aidl 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 aidl interface.
static_assert(
	static_cast<uint32_t>(DebugLevel::EXCESSIVE) == MSG_EXCESSIVE,
	"Debug level value mismatch");
static_assert(
	static_cast<uint32_t>(DebugLevel::ERROR) == MSG_ERROR,
	"Debug level value mismatch");

static_assert(
	static_cast<uint32_t>(KeyMgmtMask::NONE) ==
	WPA_KEY_MGMT_NONE,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::WPA_PSK) ==
	WPA_KEY_MGMT_PSK,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::WPA_EAP) ==
	WPA_KEY_MGMT_IEEE8021X,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::IEEE8021X) ==
	WPA_KEY_MGMT_IEEE8021X_NO_WPA,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::FT_EAP) ==
	WPA_KEY_MGMT_FT_IEEE8021X,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::FT_PSK) ==
	WPA_KEY_MGMT_FT_PSK,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::OSEN) ==
	WPA_KEY_MGMT_OSEN,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::SAE) ==
	WPA_KEY_MGMT_SAE,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::SUITE_B_192) ==
	WPA_KEY_MGMT_IEEE8021X_SUITE_B_192,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::OWE) ==
	WPA_KEY_MGMT_OWE,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::WPA_PSK_SHA256) ==
	WPA_KEY_MGMT_PSK_SHA256,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::WPA_EAP_SHA256) ==
	WPA_KEY_MGMT_IEEE8021X_SHA256,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::WAPI_PSK) ==
	WPA_KEY_MGMT_WAPI_PSK,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(KeyMgmtMask::WAPI_CERT) ==
	WPA_KEY_MGMT_WAPI_CERT,
	"KeyMgmt value mismatch");
static_assert(
	static_cast<uint32_t>(ProtoMask::WPA) ==
	WPA_PROTO_WPA,
	"Proto value mismatch");
static_assert(
	static_cast<uint32_t>(ProtoMask::RSN) ==
	WPA_PROTO_RSN,
	"Proto value mismatch");
static_assert(
	static_cast<uint32_t>(ProtoMask::OSEN) ==
	WPA_PROTO_OSEN,
	"Proto value mismatch");
static_assert(
	static_cast<uint32_t>(ProtoMask::WAPI) ==
	WPA_PROTO_WAPI,
	"Proto value mismatch");
static_assert(
	static_cast<uint32_t>(AuthAlgMask::OPEN) ==
	WPA_AUTH_ALG_OPEN,
	"AuthAlg value mismatch");
static_assert(
	static_cast<uint32_t>(AuthAlgMask::SHARED) ==
	WPA_AUTH_ALG_SHARED,
	"AuthAlg value mismatch");
static_assert(
	static_cast<uint32_t>(AuthAlgMask::LEAP) ==
	WPA_AUTH_ALG_LEAP,
	"AuthAlg value mismatch");
static_assert(
	static_cast<uint32_t>(GroupCipherMask::WEP40) ==
	WPA_CIPHER_WEP40,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(GroupCipherMask::WEP104) ==
	WPA_CIPHER_WEP104,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(GroupCipherMask::TKIP) ==
	WPA_CIPHER_TKIP,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(GroupCipherMask::CCMP) ==
	WPA_CIPHER_CCMP,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(GroupCipherMask::GCMP_256) ==
	WPA_CIPHER_GCMP_256,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(GroupCipherMask::SMS4) ==
	WPA_CIPHER_SMS4,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(
	GroupCipherMask::GTK_NOT_USED) ==
	WPA_CIPHER_GTK_NOT_USED,
	"GroupCipher value mismatch");
static_assert(
	static_cast<uint32_t>(PairwiseCipherMask::NONE) ==
	WPA_CIPHER_NONE,
	"PairwiseCipher value mismatch");
static_assert(
	static_cast<uint32_t>(PairwiseCipherMask::TKIP) ==
	WPA_CIPHER_TKIP,
	"PairwiseCipher value mismatch");
static_assert(
	static_cast<uint32_t>(PairwiseCipherMask::CCMP) ==
	WPA_CIPHER_CCMP,
	"PairwiseCipher value mismatch");
static_assert(
	static_cast<uint32_t>(
	PairwiseCipherMask::GCMP_256) ==
	WPA_CIPHER_GCMP_256,
	"PairwiseCipher value mismatch");
static_assert(
	static_cast<uint32_t>(
	PairwiseCipherMask::SMS4) ==
	WPA_CIPHER_SMS4,
	"PairwiseCipher value mismatch");
static_assert(
	static_cast<uint32_t>(StaIfaceCallbackState::DISCONNECTED) ==
	WPA_DISCONNECTED,
	"State value mismatch");
static_assert(
	static_cast<uint32_t>(StaIfaceCallbackState::COMPLETED) ==
	WPA_COMPLETED,
	"State value mismatch");

static_assert(
	static_cast<uint32_t>(AnqpInfoId::VENUE_NAME) ==
	ANQP_VENUE_NAME,
	"ANQP ID value mismatch");
static_assert(
	static_cast<uint32_t>(
	AnqpInfoId::ROAMING_CONSORTIUM) ==
	ANQP_ROAMING_CONSORTIUM,
	"ANQP ID value mismatch");
static_assert(
	static_cast<uint32_t>(AnqpInfoId::NAI_REALM) ==
	ANQP_NAI_REALM,
	"ANQP ID value mismatch");
static_assert(
	static_cast<uint32_t>(
	AnqpInfoId::IP_ADDR_TYPE_AVAILABILITY) ==
	ANQP_IP_ADDR_TYPE_AVAILABILITY,
	"ANQP ID value mismatch");
static_assert(
	static_cast<uint32_t>(
	AnqpInfoId::ANQP_3GPP_CELLULAR_NETWORK) ==
	ANQP_3GPP_CELLULAR_NETWORK,
	"ANQP ID value mismatch");
static_assert(
	static_cast<uint32_t>(AnqpInfoId::DOMAIN_NAME) ==
	ANQP_DOMAIN_NAME,
	"ANQP ID value mismatch");
static_assert(
	static_cast<uint32_t>(
	Hs20AnqpSubtypes::OPERATOR_FRIENDLY_NAME) ==
	HS20_STYPE_OPERATOR_FRIENDLY_NAME,
	"HS Subtype value mismatch");
static_assert(
	static_cast<uint32_t>(Hs20AnqpSubtypes::WAN_METRICS) ==
	HS20_STYPE_WAN_METRICS,
	"HS Subtype value mismatch");
static_assert(
	static_cast<uint32_t>(
	Hs20AnqpSubtypes::CONNECTION_CAPABILITY) ==
	HS20_STYPE_CONNECTION_CAPABILITY,
	"HS Subtype value mismatch");
static_assert(
	static_cast<uint32_t>(
	Hs20AnqpSubtypes::OSU_PROVIDERS_LIST) ==
	HS20_STYPE_OSU_PROVIDERS_LIST,
	"HS Subtype value mismatch");

static_assert(
	static_cast<uint16_t>(
	WpsConfigError::NO_ERROR) ==
	WPS_CFG_NO_ERROR,
	"Wps config error value mismatch");
static_assert(
	static_cast<uint16_t>(WpsConfigError::
				  PUBLIC_KEY_HASH_MISMATCH) ==
	WPS_CFG_PUBLIC_KEY_HASH_MISMATCH,
	"Wps config error value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsErrorIndication::NO_ERROR) ==
	WPS_EI_NO_ERROR,
	"Wps error indication value mismatch");
static_assert(
	static_cast<uint16_t>(
	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>(
	WpsDevPasswordId::DEFAULT) ==
	DEV_PW_DEFAULT,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsDevPasswordId::USER_SPECIFIED) ==
	DEV_PW_USER_SPECIFIED,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsDevPasswordId::MACHINE_SPECIFIED) ==
	DEV_PW_MACHINE_SPECIFIED,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsDevPasswordId::REKEY) == DEV_PW_REKEY,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsDevPasswordId::PUSHBUTTON) ==
	DEV_PW_PUSHBUTTON,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsDevPasswordId::REGISTRAR_SPECIFIED) ==
	DEV_PW_REGISTRAR_SPECIFIED,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(WpsDevPasswordId::
				  NFC_CONNECTION_HANDOVER) ==
	DEV_PW_NFC_CONNECTION_HANDOVER,
	"Wps dev password id value mismatch");
static_assert(
	static_cast<uint16_t>(
	WpsDevPasswordId::P2PS_DEFAULT) ==
	DEV_PW_P2PS_DEFAULT,
	"Wps dev password id value mismatch");

static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::SUCCESS) == P2P_SC_SUCCESS,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(P2pStatusCode::
				  FAIL_INFO_CURRENTLY_UNAVAILABLE) ==
	P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_INCOMPATIBLE_PARAMS) ==
	P2P_SC_FAIL_INCOMPATIBLE_PARAMS,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_LIMIT_REACHED) ==
	P2P_SC_FAIL_LIMIT_REACHED,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_INVALID_PARAMS) ==
	P2P_SC_FAIL_INVALID_PARAMS,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(P2pStatusCode::
				  FAIL_UNABLE_TO_ACCOMMODATE) ==
	P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_PREV_PROTOCOL_ERROR) ==
	P2P_SC_FAIL_PREV_PROTOCOL_ERROR,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_NO_COMMON_CHANNELS) ==
	P2P_SC_FAIL_NO_COMMON_CHANNELS,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_UNKNOWN_GROUP) ==
	P2P_SC_FAIL_UNKNOWN_GROUP,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_BOTH_GO_INTENT_15) ==
	P2P_SC_FAIL_BOTH_GO_INTENT_15,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(P2pStatusCode::
				  FAIL_INCOMPATIBLE_PROV_METHOD) ==
	P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::FAIL_REJECTED_BY_USER) ==
	P2P_SC_FAIL_REJECTED_BY_USER,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pStatusCode::SUCCESS_DEFERRED) ==
	P2P_SC_SUCCESS_DEFERRED,
	"P2P status code value mismatch");

static_assert(
	static_cast<uint16_t>(
	P2pProvDiscStatusCode::SUCCESS) ==
	P2P_PROV_DISC_SUCCESS,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pProvDiscStatusCode::TIMEOUT) ==
	P2P_PROV_DISC_TIMEOUT,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pProvDiscStatusCode::REJECTED) ==
	P2P_PROV_DISC_REJECTED,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pProvDiscStatusCode::TIMEOUT_JOIN) ==
	P2P_PROV_DISC_TIMEOUT_JOIN,
	"P2P status code value mismatch");
static_assert(
	static_cast<uint16_t>(
	P2pProvDiscStatusCode::INFO_UNAVAILABLE) ==
	P2P_PROV_DISC_INFO_UNAVAILABLE,
	"P2P status code value mismatch");
}  // namespace supplicant
}  // namespace wifi
}  // namespace hardware
}  // namespace android
}  // namespace aidl
#endif  // WPA_SUPPLICANT_AIDL_AIDL_MANAGER_H