1/*
2 * libjingle
3 * Copyright 2004--2005, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28// P2PTransportChannel wraps up the state management of the connection between
29// two P2P clients.  Clients have candidate ports for connecting, and
30// connections which are combinations of candidates from each end (Alice and
31// Bob each have candidates, one candidate from Alice and one candidate from
32// Bob are used to make a connection, repeat to make many connections).
33//
34// When all of the available connections become invalid (non-writable), we
35// kick off a process of determining more candidates and more connections.
36//
37#ifndef TALK_P2P_BASE_P2PTRANSPORTCHANNEL_H_
38#define TALK_P2P_BASE_P2PTRANSPORTCHANNEL_H_
39
40#include <map>
41#include <vector>
42#include <string>
43#include "talk/base/sigslot.h"
44#include "talk/p2p/base/candidate.h"
45#include "talk/p2p/base/port.h"
46#include "talk/p2p/base/portallocator.h"
47#include "talk/p2p/base/transport.h"
48#include "talk/p2p/base/transportchannelimpl.h"
49#include "talk/p2p/base/p2ptransport.h"
50
51namespace cricket {
52
53// Adds the port on which the candidate originated.
54class RemoteCandidate : public Candidate {
55 public:
56  RemoteCandidate(const Candidate& c, Port* origin_port)
57    : Candidate(c), origin_port_(origin_port) {}
58
59  Port* origin_port() { return origin_port_; }
60
61 private:
62  Port* origin_port_;
63};
64
65// P2PTransportChannel manages the candidates and connection process to keep
66// two P2P clients connected to each other.
67class P2PTransportChannel : public TransportChannelImpl,
68    public talk_base::MessageHandler {
69 public:
70  P2PTransportChannel(const std::string &name,
71                      const std::string &content_type,
72                      P2PTransport* transport,
73                      PortAllocator *allocator);
74  virtual ~P2PTransportChannel();
75
76  // From TransportChannelImpl:
77  virtual Transport* GetTransport() { return transport_; }
78  virtual void Connect();
79  virtual void Reset();
80  virtual void OnSignalingReady();
81
82  // From TransportChannel:
83  virtual int SendPacket(const char *data, size_t len);
84  virtual int SetOption(talk_base::Socket::Option opt, int value);
85  virtual int GetError() { return error_; }
86
87  // This hack is here to allow the SocketMonitor to downcast to the
88  // P2PTransportChannel safely.
89  virtual P2PTransportChannel* GetP2PChannel() { return this; }
90
91  // These are used by the connection monitor.
92  sigslot::signal1<P2PTransportChannel*> SignalConnectionMonitor;
93  const std::vector<Connection *>& connections() const { return connections_; }
94  Connection* best_connection() const { return best_connection_; }
95
96  // Handler for internal messages.
97  virtual void OnMessage(talk_base::Message *pmsg);
98
99  virtual void OnCandidate(const Candidate& candidate);
100
101 private:
102  void Allocate();
103  void CancelPendingAllocate();
104  void UpdateConnectionStates();
105  void RequestSort();
106  void SortConnections();
107  void SwitchBestConnectionTo(Connection* conn);
108  void UpdateChannelState();
109  void HandleWritable();
110  void HandleNotWritable();
111  void HandleAllTimedOut();
112  Connection* GetBestConnectionOnNetwork(talk_base::Network* network);
113  bool CreateConnections(const Candidate &remote_candidate, Port* origin_port,
114                         bool readable);
115  bool CreateConnection(Port* port, const Candidate& remote_candidate,
116                        Port* origin_port, bool readable);
117  void RememberRemoteCandidate(const Candidate& remote_candidate,
118                               Port* origin_port);
119  void OnUnknownAddress(Port *port, const talk_base::SocketAddress &addr,
120                        StunMessage *stun_msg,
121                        const std::string &remote_username);
122  void OnPortReady(PortAllocatorSession *session, Port* port);
123  void OnCandidatesReady(PortAllocatorSession *session,
124                         const std::vector<Candidate>& candidates);
125  void OnConnectionStateChange(Connection *connection);
126  void OnConnectionDestroyed(Connection *connection);
127  void OnPortDestroyed(Port* port);
128  void OnReadPacket(Connection *connection, const char *data, size_t len);
129  void OnSort();
130  void OnPing();
131  bool IsPingable(Connection* conn);
132  Connection* FindNextPingableConnection();
133  uint32 NumPingableConnections();
134  PortAllocatorSession* allocator_session() {
135    return allocator_sessions_.back();
136  }
137  void AddAllocatorSession(PortAllocatorSession* session);
138
139  talk_base::Thread* thread() const { return worker_thread_; }
140
141  P2PTransport* transport_;
142  PortAllocator *allocator_;
143  talk_base::Thread *worker_thread_;
144  bool waiting_for_signaling_;
145  int error_;
146  std::vector<PortAllocatorSession*> allocator_sessions_;
147  std::vector<Port *> ports_;
148  std::vector<Connection *> connections_;
149  Connection *best_connection_;
150  std::vector<RemoteCandidate> remote_candidates_;
151  // indicates whether StartGetAllCandidates has been called
152  bool pinging_started_;
153  bool sort_dirty_;  // indicates whether another sort is needed right now
154  bool was_writable_;
155  bool was_timed_out_;
156  typedef std::map<talk_base::Socket::Option, int> OptionMap;
157  OptionMap options_;
158
159  DISALLOW_EVIL_CONSTRUCTORS(P2PTransportChannel);
160};
161
162}  // namespace cricket
163
164#endif  // TALK_P2P_BASE_P2PTRANSPORTCHANNEL_H_
165