xref: /external/wpa_supplicant_8/wpa_supplicant/hidl/1.0/sta_iface.cpp

/*
 * 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.
 */

#include "hidl_manager.h"
#include "iface.h"

namespace wpa_supplicant_hidl {

#define RETURN_IF_IFACE_INVALID(wpa_s)                                  \
	{                                                               \
		if (!wpa_s) {                                           \
			return android::hidl::Status::                \
			    fromServiceSpecificError(                   \
				ERROR_IFACE_INVALID,                    \
				"wpa_supplicant does not control this " \
				"interface.");                          \
		}                                                       \
	}  // #define RETURN_IF_IFACE_INVALID(wpa_s)

Iface::Iface(struct wpa_global *wpa_global, const char ifname[])
    : wpa_global_(wpa_global), ifname_(ifname)
{
}

android::hidl::Status Iface::GetName(std::string *iface_name_out)
{
	// We could directly return the name we hold, but let's verify
	// if the underlying iface still exists.
	RETURN_IF_IFACE_INVALID(retrieveIfacePtr());
	*iface_name_out = ifname_;
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::AddNetwork(
    android::sp<fi::w1::wpa_supplicant::INetwork> *network_object_out)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	struct wpa_ssid *ssid = wpa_supplicant_add_network(wpa_s);
	if (!ssid) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC, "wpa_supplicant couldn't add this network.");
	}

	HidlManager *hidl_manager = HidlManager::getInstance();
	if (!hidl_manager ||
	    hidl_manager->getNetworkHidlObjectByIfnameAndNetworkId(
		wpa_s->ifname, ssid->id, network_object_out)) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC,
		    "wpa_supplicant encountered a hidl error.");
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::RemoveNetwork(int network_id)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	int result = wpa_supplicant_remove_network(wpa_s, network_id);
	if (result == -1) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_NETWORK_UNKNOWN,
		    "wpa_supplicant does not control this network.");
	}

	if (result == -2) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC,
		    "wpa_supplicant couldn't remove this network.");
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::GetNetwork(
    int network_id,
    android::sp<fi::w1::wpa_supplicant::INetwork> *network_object_out)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	struct wpa_ssid *ssid = wpa_config_get_network(wpa_s->conf, network_id);
	if (!ssid) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_NETWORK_UNKNOWN,
		    "wpa_supplicant does not control this network.");
	}

	HidlManager *hidl_manager = HidlManager::getInstance();
	if (!hidl_manager ||
	    hidl_manager->getNetworkHidlObjectByIfnameAndNetworkId(
		wpa_s->ifname, ssid->id, network_object_out)) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC,
		    "wpa_supplicant encountered a hidl error.");
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::RegisterCallback(
    const android::sp<fi::w1::wpa_supplicant::IIfaceCallback> &callback)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	HidlManager *hidl_manager = HidlManager::getInstance();
	if (!hidl_manager ||
	    hidl_manager->addIfaceCallbackHidlObject(ifname_, callback)) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC,
		    "wpa_supplicant encountered a hidl error.");
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::Reassociate()
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_IFACE_DISABLED);
	}
	wpas_request_connection(wpa_s);
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::Reconnect()
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_IFACE_DISABLED);
	}
	if (!wpa_s->disconnected) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_IFACE_NOT_DISCONNECTED);
	}
	wpas_request_connection(wpa_s);
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::Disconnect()
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_IFACE_DISABLED);
	}
	wpas_request_disconnection(wpa_s);
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::SetPowerSave(bool enable)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);
	if (wpa_drv_set_p2p_powersave(wpa_s, enable, -1, -1)) {
		const std::string error_msg = "Failed setting power save mode" +
					      std::to_string(enable) + ".";
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC, error_msg.c_str());
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::InitiateTDLSDiscover(
    const std::vector<uint8_t> &mac_address)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	if (mac_address.size() != MAC_ADDRESS_LEN) {
		const std::string error_msg =
		    "Invalid MAC address value length: " +
		    std::to_string(mac_address.size()) + ".";
		return android::hidl::Status::fromExceptionCode(
		    android::hidl::Status::EX_ILLEGAL_ARGUMENT,
		    error_msg.c_str());
	}
	int ret;
	const u8 *peer = mac_address.data();
	if (wpa_tdls_is_external_setup(wpa_s->wpa)) {
		ret = wpa_tdls_send_discovery_request(wpa_s->wpa, peer);
	} else {
		ret = wpa_drv_tdls_oper(wpa_s, TDLS_DISCOVERY_REQ, peer);
	}
	if (ret) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC, "Failed to initiate TDLS Discover.");
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::InitiateTDLSSetup(
    const std::vector<uint8_t> &mac_address)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	if (mac_address.size() != MAC_ADDRESS_LEN) {
		const std::string error_msg =
		    "Invalid MAC address value length: " +
		    std::to_string(mac_address.size()) + ".";
		return android::hidl::Status::fromExceptionCode(
		    android::hidl::Status::EX_ILLEGAL_ARGUMENT,
		    error_msg.c_str());
	}
	int ret;
	const u8 *peer = mac_address.data();
	if (wpa_tdls_is_external_setup(wpa_s->wpa) &&
	    !(wpa_s->conf->tdls_external_control)) {
		wpa_tdls_remove(wpa_s->wpa, peer);
		ret = wpa_tdls_start(wpa_s->wpa, peer);
	} else {
		ret = wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
	}
	if (ret) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC, "Failed to initiate TDLS Setup.");
	}
	return android::hidl::Status::ok();
}

android::hidl::Status Iface::InitiateTDLSTeardown(
    const std::vector<uint8_t> &mac_address)
{
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	RETURN_IF_IFACE_INVALID(wpa_s);

	if (mac_address.size() != MAC_ADDRESS_LEN) {
		const std::string error_msg =
		    "Invalid MAC address value length: " +
		    std::to_string(mac_address.size()) + ".";
		return android::hidl::Status::fromExceptionCode(
		    android::hidl::Status::EX_ILLEGAL_ARGUMENT,
		    error_msg.c_str());
	}
	int ret;
	const u8 *peer = mac_address.data();
	if (wpa_tdls_is_external_setup(wpa_s->wpa) &&
	    !(wpa_s->conf->tdls_external_control)) {
		ret = wpa_tdls_teardown_link(
		    wpa_s->wpa, peer, WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED);
	} else {
		ret = wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
	}
	if (ret) {
		return android::hidl::Status::fromServiceSpecificError(
		    ERROR_GENERIC, "Failed to initiate TDLS Teardown.");
	}
	return android::hidl::Status::ok();
}

/**
 * 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 *Iface::retrieveIfacePtr()
{
	return wpa_supplicant_get_iface(
	    (struct wpa_global *)wpa_global_, ifname_.c_str());
}
}  // namespace wpa_supplicant_hidl