1 //
2 // Copyright (C) 2012 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #ifndef SHILL_CONNECTION_H_
18 #define SHILL_CONNECTION_H_
19 
20 #include <deque>
21 #include <string>
22 #include <vector>
23 
24 #include <base/memory/ref_counted.h>
25 #include <base/memory/weak_ptr.h>
26 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
27 
28 #include "shill/ipconfig.h"
29 #include "shill/net/ip_address.h"
30 #include "shill/refptr_types.h"
31 #include "shill/technology.h"
32 
33 namespace shill {
34 
35 class ControlInterface;
36 class DeviceInfo;
37 class FirewallProxyInterface;
38 class RTNLHandler;
39 #if !defined(__ANDROID__)
40 class Resolver;
41 #else
42 class DNSServerProxy;
43 class DNSServerProxyFactory;
44 #endif  // __ANDROID__
45 class RoutingTable;
46 struct RoutingTableEntry;
47 
48 // The Conneciton maintains the implemented state of an IPConfig, e.g,
49 // the IP address, routing table and DNS table entries.
50 class Connection : public base::RefCounted<Connection> {
51  public:
52   // Clients can instantiate and use Binder to bind to a Connection and get
53   // notified when the bound Connection disconnects. Note that the client's
54   // disconnect callback will be executed at most once, and only if the bound
55   // Connection is destroyed or signals disconnect. The Binder unbinds itself
56   // from the underlying Connection when the Binder instance is destructed.
57   class Binder {
58    public:
59     Binder(const std::string& name, const base::Closure& disconnect_callback);
60     ~Binder();
61 
62     // Binds to |to_connection|. Unbinds the previous bound connection, if
63     // any. Pass nullptr to just unbind this Binder.
64     void Attach(const ConnectionRefPtr& to_connection);
65 
name()66     const std::string& name() const { return name_; }
IsBound()67     bool IsBound() const { return connection_ != nullptr; }
connection()68     ConnectionRefPtr connection() const { return connection_.get(); }
69 
70    private:
71     friend class Connection;
72     FRIEND_TEST(ConnectionTest, Binder);
73 
74     // Invoked by |connection_|.
75     void OnDisconnect();
76 
77     const std::string name_;
78     base::WeakPtr<Connection> connection_;
79     const base::Closure client_disconnect_callback_;
80 
81     DISALLOW_COPY_AND_ASSIGN(Binder);
82   };
83 
84   Connection(int interface_index,
85              const std::string& interface_name,
86              Technology::Identifier technology_,
87              const DeviceInfo* device_info,
88              ControlInterface* control_interface);
89 
90   // Add the contents of an IPConfig reference to the list of managed state.
91   // This will replace all previous state for this address family.
92   virtual void UpdateFromIPConfig(const IPConfigRefPtr& config);
93 
94   // Return the connection used by the lower binder.
GetLowerConnection()95   virtual ConnectionRefPtr GetLowerConnection() const {
96     return lower_binder_.connection();
97   }
98 
99   // Sets the current connection as "default", i.e., routes and DNS entries
100   // should be used by all system components that don't select explicitly.
is_default()101   virtual bool is_default() const { return is_default_; }
102   virtual void SetIsDefault(bool is_default);
103 
104   // Update and apply the new DNS servers setting to this connection.
105   virtual void UpdateDNSServers(const std::vector<std::string>& dns_servers);
106 
interface_name()107   virtual const std::string& interface_name() const { return interface_name_; }
interface_index()108   virtual int interface_index() const { return interface_index_; }
dns_servers()109   virtual const std::vector<std::string>& dns_servers() const {
110     return dns_servers_;
111   }
table_id()112   virtual uint8_t table_id() const { return table_id_; }
113 
ipconfig_rpc_identifier()114   virtual const std::string& ipconfig_rpc_identifier() const {
115     return ipconfig_rpc_identifier_;
116   }
117 
118   virtual bool SetupIptableEntries();
119   virtual bool TearDownIptableEntries();
120 
121   // Request to accept traffic routed to this connection even if it is not
122   // the default.  This request is ref-counted so the caller must call
123   // ReleaseRouting() when they no longer need this facility.
124   virtual void RequestRouting();
125   virtual void ReleaseRouting();
126 
127   // Request a host route through this connection.
128   virtual bool RequestHostRoute(const IPAddress& destination);
129 
130   // Request a host route through this connection for a list of IPs in CIDR
131   // notation (|excluded_ips_cidr_|).
132   virtual bool PinPendingRoutes(int interface_index, RoutingTableEntry entry);
133 
134   // Return the subnet name for this connection.
135   virtual std::string GetSubnetName() const;
136 
local()137   virtual const IPAddress& local() const { return local_; }
gateway()138   virtual const IPAddress& gateway() const { return gateway_; }
technology()139   virtual Technology::Identifier technology() const { return technology_; }
tethering()140   virtual const std::string& tethering() const { return tethering_; }
set_tethering(const std::string & tethering)141   void set_tethering(const std::string& tethering) { tethering_ = tethering; }
142 
143   // Return the lowest connection on which this connection depends. In case of
144   // error, a nullptr is returned.
145   virtual ConnectionRefPtr GetCarrierConnection();
146 
147   // Return true if this is an IPv6 connection.
148   virtual bool IsIPv6();
149 
150  protected:
151   friend class base::RefCounted<Connection>;
152 
153   virtual ~Connection();
154   virtual bool CreateGatewayRoute();
155 
156  private:
157   friend class ConnectionTest;
158   FRIEND_TEST(ConnectionTest, AddConfig);
159   FRIEND_TEST(ConnectionTest, AddConfigUserTrafficOnly);
160   FRIEND_TEST(ConnectionTest, Binder);
161   FRIEND_TEST(ConnectionTest, Binders);
162   FRIEND_TEST(ConnectionTest, BlackholeIPv6);
163   FRIEND_TEST(ConnectionTest, Destructor);
164   FRIEND_TEST(ConnectionTest, FixGatewayReachability);
165   FRIEND_TEST(ConnectionTest, GetCarrierConnection);
166   FRIEND_TEST(ConnectionTest, InitState);
167   FRIEND_TEST(ConnectionTest, OnRouteQueryResponse);
168   FRIEND_TEST(ConnectionTest, RequestHostRoute);
169   FRIEND_TEST(ConnectionTest, SetMTU);
170   FRIEND_TEST(ConnectionTest, UpdateDNSServers);
171   FRIEND_TEST(VPNServiceTest, OnConnectionDisconnected);
172 
173   static const uint32_t kDefaultMetric;
174   static const uint32_t kNonDefaultMetricBase;
175   static const uint32_t kMarkForUserTraffic;
176   static const uint8_t kSecondaryTableId;
177 
178   // Work around misconfigured servers which provide a gateway address that
179   // is unreachable with the provided netmask.
180   bool FixGatewayReachability(const IPAddress& local,
181                               IPAddress* peer,
182                               IPAddress* gateway,
183                               const IPAddress& trusted_ip);
184   uint32_t GetMetric(bool is_default);
185   bool PinHostRoute(const IPAddress& trusted_ip, const IPAddress& gateway);
186   void SetMTU(int32_t mtu);
187 
188   void OnRouteQueryResponse(int interface_index,
189                             const RoutingTableEntry& entry);
190 
191   void AttachBinder(Binder* binder);
192   void DetachBinder(Binder* binder);
193   void NotifyBindersOnDisconnect();
194 
195   void OnLowerDisconnect();
196 
197   // Send our DNS configuration to the resolver.
198   void PushDNSConfig();
199 
200   base::WeakPtrFactory<Connection> weak_ptr_factory_;
201 
202   bool is_default_;
203   bool has_broadcast_domain_;
204   int routing_request_count_;
205   int interface_index_;
206   const std::string interface_name_;
207   Technology::Identifier technology_;
208   std::vector<std::string> dns_servers_;
209   std::vector<std::string> dns_domain_search_;
210   std::vector<std::string> excluded_ips_cidr_;
211   std::string dns_domain_name_;
212   std::string ipconfig_rpc_identifier_;
213   bool user_traffic_only_;
214   uint8_t table_id_;
215   IPAddress local_;
216   IPAddress gateway_;
217 
218   // Track the tethering status of the Service associated with this connection.
219   // This property is set by a service as it takes ownership of a connection,
220   // and is read by services that are bound through this connection.
221   std::string tethering_;
222 
223   // A binder to a lower Connection that this Connection depends on, if any.
224   Binder lower_binder_;
225 
226   // Binders to clients -- usually to upper connections or related services and
227   // devices.
228   std::deque<Binder*> binders_;
229 
230   // Store cached copies of singletons for speed/ease of testing
231   const DeviceInfo* device_info_;
232 #if !defined(__ANDROID__)
233   Resolver* resolver_;
234 #else
235   DNSServerProxyFactory* dns_server_proxy_factory_;
236   std::unique_ptr<DNSServerProxy> dns_server_proxy_;
237 #endif  // __ANDROID__;
238   RoutingTable* routing_table_;
239   RTNLHandler* rtnl_handler_;
240 
241   ControlInterface* control_interface_;
242   std::unique_ptr<FirewallProxyInterface> firewall_proxy_;
243 
244   DISALLOW_COPY_AND_ASSIGN(Connection);
245 };
246 
247 }  // namespace shill
248 
249 #endif  // SHILL_CONNECTION_H_
250