blob: b4366d842301f11f6d9045f4e135d2012f8ac167 [file] [log] [blame]
// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SHILL_WIFI_ENDPOINT_
#define SHILL_WIFI_ENDPOINT_
#include <map>
#include <set>
#include <string>
#include <vector>
#include <base/memory/ref_counted.h>
#include <dbus-c++/dbus.h>
#include <gtest/gtest_prod.h> // for FRIEND_TEST
#include "shill/endpoint.h"
#include "shill/event_dispatcher.h"
#include "shill/metrics.h"
#include "shill/refptr_types.h"
namespace shill {
class ProxyFactory;
class SupplicantBSSProxyInterface;
class WiFiEndpoint : public Endpoint {
public:
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_list;
};
WiFiEndpoint(ProxyFactory *proxy_factory,
const WiFiRefPtr &device,
const std::string &rpc_id,
const std::map<std::string, ::DBus::Variant> &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 std::map<std::string, ::DBus::Variant> &properties);
// 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;
int16_t signal_strength() const;
uint16 frequency() const;
uint16 physical_mode() const;
const std::string &network_mode() const;
const std::string &security_mode() const;
const VendorInformation &vendor_information() const;
private:
friend class WiFiEndpointTest;
friend class WiFiObjectTest; // for MakeOpenEndpoint
friend class WiFiServiceTest; // for MakeOpenEndpoint
// these test cases need access to the KeyManagement enum
FRIEND_TEST(WiFiEndpointTest, DeterminePhyModeFromFrequency);
FRIEND_TEST(WiFiEndpointTest, ParseIEs);
FRIEND_TEST(WiFiEndpointTest, ParseKeyManagementMethodsEAP);
FRIEND_TEST(WiFiEndpointTest, ParseKeyManagementMethodsPSK);
FRIEND_TEST(WiFiEndpointTest, ParseKeyManagementMethodsEAPAndPSK);
FRIEND_TEST(WiFiEndpointTest, ParseVendorIEs);
FRIEND_TEST(WiFiServiceUpdateFromEndpointsTest, EndpointModified);
enum KeyManagement {
kKeyManagement802_1x,
kKeyManagementPSK
};
// Build a simple WiFiEndpoint, for testing purposes.
static WiFiEndpoint *MakeOpenEndpoint(ProxyFactory *proxy_factory,
const WiFiRefPtr &wifi,
const std::string &ssid,
const std::string &bssid,
uint16 frequency,
int16 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 approprirate flimflam
// security property value, as defined in chromeos/dbus/service_constants.h
static const char *ParseSecurity(
const std::map<std::string, ::DBus::Variant> &properties);
// Parses an Endpoint's properties' "RSN" or "WPA" sub-dictionary, to
// identify supported key management methods (802.1x or PSK).
static void ParseKeyManagementMethods(
const std::map<std::string, ::DBus::Variant> &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 std::map<std::string, ::DBus::Variant> &properties,
uint16 frequency);
// Parse information elements to determine the physical mode and vendor
// information associated with the AP. Returns true if a physical mode
// was determined from the IE elements, false otherwise.
static bool ParseIEs(const std::map<std::string, ::DBus::Variant> &properties,
Metrics::WiFiNetworkPhyMode *phy_mode,
VendorInformation *vendor_information);
// Parse a single vendor information element.
static void ParseVendorIE(std::vector<uint8_t>::const_iterator ie,
std::vector<uint8_t>::const_iterator end,
VendorInformation *vendor_information);
// 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_;
int16 signal_strength_;
uint16 frequency_;
uint16 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_;
ProxyFactory *proxy_factory_;
WiFiRefPtr device_;
std::string rpc_id_;
scoped_ptr<SupplicantBSSProxyInterface> supplicant_bss_proxy_;
DISALLOW_COPY_AND_ASSIGN(WiFiEndpoint);
};
} // namespace shill
#endif // SHILL_WIFI_ENDPOINT_