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
33namespace shill {
34
35class ControlInterface;
36class DeviceInfo;
37class FirewallProxyInterface;
38class RTNLHandler;
39#if !defined(__ANDROID__)
40class Resolver;
41#else
42class DNSServerProxy;
43class DNSServerProxyFactory;
44#endif  // __ANDROID__
45class RoutingTable;
46struct RoutingTableEntry;
47
48// The Conneciton maintains the implemented state of an IPConfig, e.g,
49// the IP address, routing table and DNS table entries.
50class 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
66    const std::string& name() const { return name_; }
67    bool IsBound() const { return connection_ != nullptr; }
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.
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.
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
107  virtual const std::string& interface_name() const { return interface_name_; }
108  virtual int interface_index() const { return interface_index_; }
109  virtual const std::vector<std::string>& dns_servers() const {
110    return dns_servers_;
111  }
112  virtual uint8_t table_id() const { return table_id_; }
113
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
137  virtual const IPAddress& local() const { return local_; }
138  virtual const IPAddress& gateway() const { return gateway_; }
139  virtual Technology::Identifier technology() const { return technology_; }
140  virtual const std::string& tethering() const { return 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