226 lines
8.9 KiB
C++
226 lines
8.9 KiB
C++
//
|
|
// Copyright (C) 2012 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#ifndef SHILL_WIFI_WIFI_ENDPOINT_H_
|
|
#define SHILL_WIFI_WIFI_ENDPOINT_H_
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <base/memory/ref_counted.h>
|
|
#include <gtest/gtest_prod.h> // for FRIEND_TEST
|
|
|
|
#include "shill/event_dispatcher.h"
|
|
#include "shill/key_value_store.h"
|
|
#include "shill/metrics.h"
|
|
#include "shill/refptr_types.h"
|
|
|
|
namespace shill {
|
|
|
|
class ControlInterface;
|
|
class SupplicantBSSProxyInterface;
|
|
|
|
class WiFiEndpoint : public base::RefCounted<WiFiEndpoint> {
|
|
public:
|
|
struct SecurityFlags {
|
|
SecurityFlags()
|
|
: rsn_8021x(false),
|
|
rsn_psk(false),
|
|
wpa_8021x(false),
|
|
wpa_psk(false),
|
|
privacy(false) {}
|
|
bool rsn_8021x;
|
|
bool rsn_psk;
|
|
bool wpa_8021x;
|
|
bool wpa_psk;
|
|
bool privacy;
|
|
};
|
|
struct VendorInformation {
|
|
std::string wps_manufacturer;
|
|
std::string wps_model_name;
|
|
std::string wps_model_number;
|
|
std::string wps_device_name;
|
|
std::set<uint32_t> oui_set;
|
|
};
|
|
WiFiEndpoint(ControlInterface* control_interface,
|
|
const WiFiRefPtr& device,
|
|
const std::string& rpc_id,
|
|
const KeyValueStore& properties);
|
|
virtual ~WiFiEndpoint();
|
|
|
|
// Set up RPC channel. Broken out from the ctor, so that WiFi can
|
|
// look over the Endpoint details before commiting to setting up
|
|
// RPC.
|
|
virtual void Start();
|
|
|
|
// Called by SupplicantBSSProxy, in response to events from
|
|
// wpa_supplicant.
|
|
void PropertiesChanged(const KeyValueStore& properties);
|
|
|
|
// Called by WiFi when it polls for signal strength from the kernel.
|
|
void UpdateSignalStrength(int16_t strength);
|
|
|
|
// Maps mode strings from flimflam's nomenclature, as defined
|
|
// in chromeos/dbus/service_constants.h, to uints used by supplicant
|
|
static uint32_t ModeStringToUint(const std::string& mode_string);
|
|
|
|
// Returns a stringmap containing information gleaned about the
|
|
// vendor of this AP.
|
|
std::map<std::string, std::string> GetVendorInformation() const;
|
|
|
|
const std::vector<uint8_t>& ssid() const;
|
|
const std::string& ssid_string() const;
|
|
const std::string& ssid_hex() const;
|
|
const std::string& bssid_string() const;
|
|
const std::string& bssid_hex() const;
|
|
const std::string& country_code() const;
|
|
const WiFiRefPtr& device() const;
|
|
int16_t signal_strength() const;
|
|
uint16_t frequency() const;
|
|
uint16_t physical_mode() const;
|
|
const std::string& network_mode() const;
|
|
const std::string& security_mode() const;
|
|
bool ieee80211w_required() const;
|
|
bool has_rsn_property() const;
|
|
bool has_wpa_property() const;
|
|
bool has_tethering_signature() const;
|
|
|
|
private:
|
|
friend class WiFiEndpointTest;
|
|
friend class WiFiObjectTest; // for MakeOpenEndpoint
|
|
friend class WiFiProviderTest; // for MakeOpenEndpoint
|
|
friend class WiFiServiceTest; // for MakeOpenEndpoint
|
|
// these test cases need access to the KeyManagement enum
|
|
FRIEND_TEST(WiFiEndpointTest, DeterminePhyModeFromFrequency);
|
|
FRIEND_TEST(WiFiEndpointTest, ParseKeyManagementMethodsEAP);
|
|
FRIEND_TEST(WiFiEndpointTest, ParseKeyManagementMethodsPSK);
|
|
FRIEND_TEST(WiFiEndpointTest, ParseKeyManagementMethodsEAPAndPSK);
|
|
FRIEND_TEST(WiFiEndpointTest, HasTetheringSignature);
|
|
FRIEND_TEST(WiFiProviderTest, OnEndpointAddedWithSecurity);
|
|
FRIEND_TEST(WiFiProviderTest, OnEndpointUpdated);
|
|
FRIEND_TEST(WiFiServiceTest, ConnectTaskWPA80211w);
|
|
FRIEND_TEST(WiFiServiceTest, GetTethering);
|
|
FRIEND_TEST(WiFiServiceUpdateFromEndpointsTest, EndpointModified);
|
|
FRIEND_TEST(WiFiServiceUpdateFromEndpointsTest, Ieee80211w);
|
|
// for physical_mode_
|
|
FRIEND_TEST(WiFiServiceUpdateFromEndpointsTest, PhysicalMode);
|
|
|
|
enum KeyManagement {
|
|
kKeyManagement802_1x,
|
|
kKeyManagementPSK
|
|
};
|
|
|
|
// Build a simple WiFiEndpoint, for testing purposes.
|
|
static WiFiEndpoint* MakeEndpoint(ControlInterface* control_interface,
|
|
const WiFiRefPtr& wifi,
|
|
const std::string& ssid,
|
|
const std::string& bssid,
|
|
const std::string& network_mode,
|
|
uint16_t frequency,
|
|
int16_t signal_dbm,
|
|
bool has_wpa_property,
|
|
bool has_rsn_property);
|
|
// As above, but with the last two parameters false.
|
|
static WiFiEndpoint* MakeOpenEndpoint(ControlInterface* control_interface,
|
|
const WiFiRefPtr& wifi,
|
|
const std::string& ssid,
|
|
const std::string& bssid,
|
|
const std::string& network_mode,
|
|
uint16_t frequency,
|
|
int16_t signal_dbm);
|
|
// Maps mode strings from supplicant into flimflam's nomenclature, as defined
|
|
// in chromeos/dbus/service_constants.h.
|
|
static const char* ParseMode(const std::string& mode_string);
|
|
// Parses an Endpoint's properties to identify an approprirate flimflam
|
|
// security property value, as defined in chromeos/dbus/service_constants.h.
|
|
// The stored data in the |flags| parameter is merged with the provided
|
|
// properties, and the security value returned is the result of the
|
|
// merger.
|
|
static const char* ParseSecurity(const KeyValueStore& properties,
|
|
SecurityFlags* flags);
|
|
// Parses an Endpoint's properties' "RSN" or "WPA" sub-dictionary, to
|
|
// identify supported key management methods (802.1x or PSK).
|
|
static void ParseKeyManagementMethods(
|
|
const KeyValueStore& security_method_properties,
|
|
std::set<KeyManagement>* key_management_methods);
|
|
// Determine the negotiated operating mode for the channel by looking at
|
|
// the information elements, frequency and data rates. The information
|
|
// elements and data rates live in |properties|.
|
|
static Metrics::WiFiNetworkPhyMode DeterminePhyModeFromFrequency(
|
|
const KeyValueStore& properties,
|
|
uint16_t frequency);
|
|
// Parse information elements to determine the physical mode, vendor
|
|
// information and IEEE 802.11w requirement information associated
|
|
// with the AP. Returns true if a physical mode was determined from
|
|
// the IE elements, false otherwise.
|
|
static bool ParseIEs(const KeyValueStore& properties,
|
|
Metrics::WiFiNetworkPhyMode* phy_mode,
|
|
VendorInformation* vendor_information,
|
|
bool* ieee80211w_required, std::string* country_code);
|
|
// Parse a WPA information element and set *|ieee80211w_required| to true
|
|
// if IEEE 802.11w is required by this AP.
|
|
static void ParseWPACapabilities(std::vector<uint8_t>::const_iterator ie,
|
|
std::vector<uint8_t>::const_iterator end,
|
|
bool* ieee80211w_required);
|
|
// Parse a single vendor information element. If this is a WPA vendor
|
|
// element, call ParseWPACapabilites with |ieee80211w_required|.
|
|
static void ParseVendorIE(std::vector<uint8_t>::const_iterator ie,
|
|
std::vector<uint8_t>::const_iterator end,
|
|
VendorInformation* vendor_information,
|
|
bool* ieee80211w_required);
|
|
|
|
// Assigns a value to |has_tethering_signature_|.
|
|
void CheckForTetheringSignature();
|
|
|
|
// Private setter used in unit tests.
|
|
void set_security_mode(const std::string& mode) { security_mode_ = mode; }
|
|
|
|
// TODO(quiche): make const?
|
|
std::vector<uint8_t> ssid_;
|
|
std::vector<uint8_t> bssid_;
|
|
std::string ssid_string_;
|
|
std::string ssid_hex_;
|
|
std::string bssid_string_;
|
|
std::string bssid_hex_;
|
|
std::string country_code_;
|
|
int16_t signal_strength_;
|
|
uint16_t frequency_;
|
|
uint16_t physical_mode_;
|
|
// network_mode_ and security_mode_ are represented as flimflam names
|
|
// (not necessarily the same as wpa_supplicant names)
|
|
std::string network_mode_;
|
|
std::string security_mode_;
|
|
VendorInformation vendor_information_;
|
|
bool ieee80211w_required_;
|
|
bool has_rsn_property_;
|
|
bool has_wpa_property_;
|
|
bool has_tethering_signature_;
|
|
SecurityFlags security_flags_;
|
|
|
|
ControlInterface* control_interface_;
|
|
WiFiRefPtr device_;
|
|
std::string rpc_id_;
|
|
std::unique_ptr<SupplicantBSSProxyInterface> supplicant_bss_proxy_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(WiFiEndpoint);
|
|
};
|
|
|
|
} // namespace shill
|
|
|
|
#endif // SHILL_WIFI_WIFI_ENDPOINT_H_
|