1/*
2 *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#ifndef WEBRTC_BASE_NATSOCKETFACTORY_H_
12#define WEBRTC_BASE_NATSOCKETFACTORY_H_
13
14#include <string>
15#include <map>
16#include <set>
17
18#include "webrtc/base/natserver.h"
19#include "webrtc/base/socketaddress.h"
20#include "webrtc/base/socketserver.h"
21
22namespace rtc {
23
24const size_t kNATEncodedIPv4AddressSize = 8U;
25const size_t kNATEncodedIPv6AddressSize = 20U;
26
27// Used by the NAT socket implementation.
28class NATInternalSocketFactory {
29 public:
30  virtual ~NATInternalSocketFactory() {}
31  virtual AsyncSocket* CreateInternalSocket(int family, int type,
32      const SocketAddress& local_addr, SocketAddress* nat_addr) = 0;
33};
34
35// Creates sockets that will send all traffic through a NAT, using an existing
36// NATServer instance running at nat_addr. The actual data is sent using sockets
37// from a socket factory, given to the constructor.
38class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
39 public:
40  NATSocketFactory(SocketFactory* factory, const SocketAddress& nat_udp_addr,
41                   const SocketAddress& nat_tcp_addr);
42
43  // SocketFactory implementation
44  Socket* CreateSocket(int type) override;
45  Socket* CreateSocket(int family, int type) override;
46  AsyncSocket* CreateAsyncSocket(int type) override;
47  AsyncSocket* CreateAsyncSocket(int family, int type) override;
48
49  // NATInternalSocketFactory implementation
50  AsyncSocket* CreateInternalSocket(int family,
51                                    int type,
52                                    const SocketAddress& local_addr,
53                                    SocketAddress* nat_addr) override;
54
55 private:
56  SocketFactory* factory_;
57  SocketAddress nat_udp_addr_;
58  SocketAddress nat_tcp_addr_;
59  RTC_DISALLOW_COPY_AND_ASSIGN(NATSocketFactory);
60};
61
62// Creates sockets that will send traffic through a NAT depending on what
63// address they bind to. This can be used to simulate a client on a NAT sending
64// to a client that is not behind a NAT.
65// Note that the internal addresses of clients must be unique. This is because
66// there is only one socketserver per thread, and the Bind() address is used to
67// figure out which NAT (if any) the socket should talk to.
68//
69// Example with 3 NATs (2 cascaded), and 3 clients.
70// ss->AddTranslator("1.2.3.4", "192.168.0.1", NAT_ADDR_RESTRICTED);
71// ss->AddTranslator("99.99.99.99", "10.0.0.1", NAT_SYMMETRIC)->
72//     AddTranslator("10.0.0.2", "192.168.1.1", NAT_OPEN_CONE);
73// ss->GetTranslator("1.2.3.4")->AddClient("1.2.3.4", "192.168.0.2");
74// ss->GetTranslator("99.99.99.99")->AddClient("10.0.0.3");
75// ss->GetTranslator("99.99.99.99")->GetTranslator("10.0.0.2")->
76//     AddClient("192.168.1.2");
77class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
78 public:
79  class Translator;
80  // holds a list of NATs
81  class TranslatorMap : private std::map<SocketAddress, Translator*> {
82   public:
83    ~TranslatorMap();
84    Translator* Get(const SocketAddress& ext_ip);
85    Translator* Add(const SocketAddress& ext_ip, Translator*);
86    void Remove(const SocketAddress& ext_ip);
87    Translator* FindClient(const SocketAddress& int_ip);
88  };
89
90  // a specific NAT
91  class Translator {
92   public:
93    Translator(NATSocketServer* server, NATType type,
94               const SocketAddress& int_addr, SocketFactory* ext_factory,
95               const SocketAddress& ext_addr);
96    ~Translator();
97
98    SocketFactory* internal_factory() { return internal_factory_.get(); }
99    SocketAddress internal_udp_address() const {
100      return nat_server_->internal_udp_address();
101    }
102    SocketAddress internal_tcp_address() const {
103      return SocketAddress();  // nat_server_->internal_tcp_address();
104    }
105
106    Translator* GetTranslator(const SocketAddress& ext_ip);
107    Translator* AddTranslator(const SocketAddress& ext_ip,
108                              const SocketAddress& int_ip, NATType type);
109    void RemoveTranslator(const SocketAddress& ext_ip);
110
111    bool AddClient(const SocketAddress& int_ip);
112    void RemoveClient(const SocketAddress& int_ip);
113
114    // Looks for the specified client in this or a child NAT.
115    Translator* FindClient(const SocketAddress& int_ip);
116
117   private:
118    NATSocketServer* server_;
119    scoped_ptr<SocketFactory> internal_factory_;
120    scoped_ptr<NATServer> nat_server_;
121    TranslatorMap nats_;
122    std::set<SocketAddress> clients_;
123  };
124
125  explicit NATSocketServer(SocketServer* ss);
126
127  SocketServer* socketserver() { return server_; }
128  MessageQueue* queue() { return msg_queue_; }
129
130  Translator* GetTranslator(const SocketAddress& ext_ip);
131  Translator* AddTranslator(const SocketAddress& ext_ip,
132                            const SocketAddress& int_ip, NATType type);
133  void RemoveTranslator(const SocketAddress& ext_ip);
134
135  // SocketServer implementation
136  Socket* CreateSocket(int type) override;
137  Socket* CreateSocket(int family, int type) override;
138
139  AsyncSocket* CreateAsyncSocket(int type) override;
140  AsyncSocket* CreateAsyncSocket(int family, int type) override;
141
142  void SetMessageQueue(MessageQueue* queue) override;
143  bool Wait(int cms, bool process_io) override;
144  void WakeUp() override;
145
146  // NATInternalSocketFactory implementation
147  AsyncSocket* CreateInternalSocket(int family,
148                                    int type,
149                                    const SocketAddress& local_addr,
150                                    SocketAddress* nat_addr) override;
151
152 private:
153  SocketServer* server_;
154  MessageQueue* msg_queue_;
155  TranslatorMap nats_;
156  RTC_DISALLOW_COPY_AND_ASSIGN(NATSocketServer);
157};
158
159// Free-standing NAT helper functions.
160size_t PackAddressForNAT(char* buf, size_t buf_size,
161                         const SocketAddress& remote_addr);
162size_t UnpackAddressFromNAT(const char* buf, size_t buf_size,
163                            SocketAddress* remote_addr);
164}  // namespace rtc
165
166#endif  // WEBRTC_BASE_NATSOCKETFACTORY_H_
167