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_P2P_BASE_RELAYPORT_H_
12#define WEBRTC_P2P_BASE_RELAYPORT_H_
13
14#include <deque>
15#include <string>
16#include <utility>
17#include <vector>
18
19#include "webrtc/p2p/base/port.h"
20#include "webrtc/p2p/base/stunrequest.h"
21
22namespace cricket {
23
24class RelayEntry;
25class RelayConnection;
26
27// Communicates using an allocated port on the relay server. For each
28// remote candidate that we try to send data to a RelayEntry instance
29// is created. The RelayEntry will try to reach the remote destination
30// by connecting to all available server addresses in a pre defined
31// order with a small delay in between. When a connection is
32// successful all other connection attempts are aborted.
33class RelayPort : public Port {
34 public:
35  typedef std::pair<rtc::Socket::Option, int> OptionValue;
36
37  // RelayPort doesn't yet do anything fancy in the ctor.
38  static RelayPort* Create(rtc::Thread* thread,
39                           rtc::PacketSocketFactory* factory,
40                           rtc::Network* network,
41                           const rtc::IPAddress& ip,
42                           uint16_t min_port,
43                           uint16_t max_port,
44                           const std::string& username,
45                           const std::string& password) {
46    return new RelayPort(thread, factory, network, ip, min_port, max_port,
47                         username, password);
48  }
49  ~RelayPort() override;
50
51  void AddServerAddress(const ProtocolAddress& addr);
52  void AddExternalAddress(const ProtocolAddress& addr);
53
54  const std::vector<OptionValue>& options() const { return options_; }
55  bool HasMagicCookie(const char* data, size_t size);
56
57  void PrepareAddress() override;
58  Connection* CreateConnection(const Candidate& address,
59                               CandidateOrigin origin) override;
60  int SetOption(rtc::Socket::Option opt, int value) override;
61  int GetOption(rtc::Socket::Option opt, int* value) override;
62  int GetError() override;
63  bool SupportsProtocol(const std::string& protocol) const override {
64    // Relay port may create both TCP and UDP connections.
65    return true;
66  }
67
68  const ProtocolAddress * ServerAddress(size_t index) const;
69  bool IsReady() { return ready_; }
70
71  // Used for testing.
72  sigslot::signal1<const ProtocolAddress*> SignalConnectFailure;
73  sigslot::signal1<const ProtocolAddress*> SignalSoftTimeout;
74
75 protected:
76  RelayPort(rtc::Thread* thread,
77            rtc::PacketSocketFactory* factory,
78            rtc::Network*,
79            const rtc::IPAddress& ip,
80            uint16_t min_port,
81            uint16_t max_port,
82            const std::string& username,
83            const std::string& password);
84  bool Init();
85
86  void SetReady();
87
88  int SendTo(const void* data,
89             size_t size,
90             const rtc::SocketAddress& addr,
91             const rtc::PacketOptions& options,
92             bool payload) override;
93
94  // Dispatches the given packet to the port or connection as appropriate.
95  void OnReadPacket(const char* data, size_t size,
96                    const rtc::SocketAddress& remote_addr,
97                    ProtocolType proto,
98                    const rtc::PacketTime& packet_time);
99
100  // The OnSentPacket callback is left empty here since they are handled by
101  // RelayEntry.
102  void OnSentPacket(rtc::AsyncPacketSocket* socket,
103                    const rtc::SentPacket& sent_packet) override {}
104
105 private:
106  friend class RelayEntry;
107
108  std::deque<ProtocolAddress> server_addr_;
109  std::vector<ProtocolAddress> external_addr_;
110  bool ready_;
111  std::vector<RelayEntry*> entries_;
112  std::vector<OptionValue> options_;
113  int error_;
114};
115
116}  // namespace cricket
117
118#endif  // WEBRTC_P2P_BASE_RELAYPORT_H_
119