Home | History | Annotate | Download | only in base 
      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 #include "talk/p2p/base/tcpport.h"
     29 
     30 #include "talk/base/common.h"
     31 #include "talk/base/logging.h"
     32 #include "talk/p2p/base/common.h"
     33 
     34 namespace cricket {
     35 
     36 TCPPort::TCPPort(talk_base::Thread* thread,
     37                  talk_base::PacketSocketFactory* factory,
     38                  talk_base::Network* network, const talk_base::IPAddress& ip,
     39                  int min_port, int max_port, const std::string& username,
     40                  const std::string& password, bool allow_listen)
     41     : Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port,
     42            username, password),
     43       incoming_only_(false),
     44       allow_listen_(allow_listen),
     45       socket_(NULL),
     46       error_(0) {
     47   // TODO(mallinath) - Set preference value as per RFC 6544.
     48   // http://b/issue?id=7141794
     49 }
     50 
     51 bool TCPPort::Init() {
     52   if (allow_listen_) {
     53     // Treat failure to create or bind a TCP socket as fatal.  This
     54     // should never happen.
     55     socket_ = socket_factory()->CreateServerTcpSocket(
     56         talk_base::SocketAddress(ip(), 0), min_port(), max_port(),
     57         false /* ssl */);
     58     if (!socket_) {
     59       LOG_J(LS_ERROR, this) << "TCP socket creation failed.";
     60       return false;
     61     }
     62     socket_->SignalNewConnection.connect(this, &TCPPort::OnNewConnection);
     63     socket_->SignalAddressReady.connect(this, &TCPPort::OnAddressReady);
     64   }
     65   return true;
     66 }
     67 
     68 TCPPort::~TCPPort() {
     69   delete socket_;
     70   std::list<Incoming>::iterator it;
     71   for (it = incoming_.begin(); it != incoming_.end(); ++it)
     72     delete it->socket;
     73   incoming_.clear();
     74 }
     75 
     76 Connection* TCPPort::CreateConnection(const Candidate& address,
     77                                       CandidateOrigin origin) {
     78   // We only support TCP protocols
     79   if ((address.protocol() != TCP_PROTOCOL_NAME) &&
     80       (address.protocol() != SSLTCP_PROTOCOL_NAME)) {
     81     return NULL;
     82   }
     83 
     84   // We can't accept TCP connections incoming on other ports
     85   if (origin == ORIGIN_OTHER_PORT)
     86     return NULL;
     87 
     88   // Check if we are allowed to make outgoing TCP connections
     89   if (incoming_only_ && (origin == ORIGIN_MESSAGE))
     90     return NULL;
     91 
     92   // We don't know how to act as an ssl server yet
     93   if ((address.protocol() == SSLTCP_PROTOCOL_NAME) &&
     94       (origin == ORIGIN_THIS_PORT)) {
     95     return NULL;
     96   }
     97 
     98   if (!IsCompatibleAddress(address.address())) {
     99     return NULL;
    100   }
    101 
    102   TCPConnection* conn = NULL;
    103   if (talk_base::AsyncPacketSocket* socket =
    104       GetIncoming(address.address(), true)) {
    105     socket->SignalReadPacket.disconnect(this);
    106     conn = new TCPConnection(this, address, socket);
    107   } else {
    108     conn = new TCPConnection(this, address);
    109   }
    110   AddConnection(conn);
    111   return conn;
    112 }
    113 
    114 void TCPPort::PrepareAddress() {
    115   if (socket_) {
    116     // If socket isn't bound yet the address will be added in
    117     // OnAddressReady(). Socket may be in the CLOSED state if Listen()
    118     // failed, we still want ot add the socket address.
    119     LOG(LS_VERBOSE) << "Preparing TCP address, current state: "
    120                     << socket_->GetState();
    121     if (socket_->GetState() == talk_base::AsyncPacketSocket::STATE_BOUND ||
    122         socket_->GetState() == talk_base::AsyncPacketSocket::STATE_CLOSED)
    123       AddAddress(socket_->GetLocalAddress(), socket_->GetLocalAddress(),
    124                  talk_base::SocketAddress(),
    125                  TCP_PROTOCOL_NAME, LOCAL_PORT_TYPE,
    126                  ICE_TYPE_PREFERENCE_HOST_TCP, true);
    127   } else {
    128     LOG_J(LS_INFO, this) << "Not listening due to firewall restrictions.";
    129     // Note: We still add the address, since otherwise the remote side won't
    130     // recognize our incoming TCP connections.
    131     AddAddress(talk_base::SocketAddress(ip(), 0),
    132                talk_base::SocketAddress(ip(), 0), talk_base::SocketAddress(),
    133                TCP_PROTOCOL_NAME, LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST_TCP,
    134                true);
    135   }
    136 }
    137 
    138 int TCPPort::SendTo(const void* data, size_t size,
    139                     const talk_base::SocketAddress& addr,
    140                     const talk_base::PacketOptions& options,
    141                     bool payload) {
    142   talk_base::AsyncPacketSocket * socket = NULL;
    143   if (TCPConnection * conn = static_cast<TCPConnection*>(GetConnection(addr))) {
    144     socket = conn->socket();
    145   } else {
    146     socket = GetIncoming(addr);
    147   }
    148   if (!socket) {
    149     LOG_J(LS_ERROR, this) << "Attempted to send to an unknown destination, "
    150                           << addr.ToSensitiveString();
    151     return -1;  // TODO: Set error_
    152   }
    153 
    154   int sent = socket->Send(data, size, options);
    155   if (sent < 0) {
    156     error_ = socket->GetError();
    157     LOG_J(LS_ERROR, this) << "TCP send of " << size
    158                           << " bytes failed with error " << error_;
    159   }
    160   return sent;
    161 }
    162 
    163 int TCPPort::GetOption(talk_base::Socket::Option opt, int* value) {
    164   if (socket_) {
    165     return socket_->GetOption(opt, value);
    166   } else {
    167     return SOCKET_ERROR;
    168   }
    169 }
    170 
    171 int TCPPort::SetOption(talk_base::Socket::Option opt, int value) {
    172   if (socket_) {
    173     return socket_->SetOption(opt, value);
    174   } else {
    175     return SOCKET_ERROR;
    176   }
    177 }
    178 
    179 int TCPPort::GetError() {
    180   return error_;
    181 }
    182 
    183 void TCPPort::OnNewConnection(talk_base::AsyncPacketSocket* socket,
    184                               talk_base::AsyncPacketSocket* new_socket) {
    185   ASSERT(socket == socket_);
    186 
    187   Incoming incoming;
    188   incoming.addr = new_socket->GetRemoteAddress();
    189   incoming.socket = new_socket;
    190   incoming.socket->SignalReadPacket.connect(this, &TCPPort::OnReadPacket);
    191   incoming.socket->SignalReadyToSend.connect(this, &TCPPort::OnReadyToSend);
    192 
    193   LOG_J(LS_VERBOSE, this) << "Accepted connection from "
    194                           << incoming.addr.ToSensitiveString();
    195   incoming_.push_back(incoming);
    196 }
    197 
    198 talk_base::AsyncPacketSocket* TCPPort::GetIncoming(
    199     const talk_base::SocketAddress& addr, bool remove) {
    200   talk_base::AsyncPacketSocket* socket = NULL;
    201   for (std::list<Incoming>::iterator it = incoming_.begin();
    202        it != incoming_.end(); ++it) {
    203     if (it->addr == addr) {
    204       socket = it->socket;
    205       if (remove)
    206         incoming_.erase(it);
    207       break;
    208     }
    209   }
    210   return socket;
    211 }
    212 
    213 void TCPPort::OnReadPacket(talk_base::AsyncPacketSocket* socket,
    214                            const char* data, size_t size,
    215                            const talk_base::SocketAddress& remote_addr,
    216                            const talk_base::PacketTime& packet_time) {
    217   Port::OnReadPacket(data, size, remote_addr, PROTO_TCP);
    218 }
    219 
    220 void TCPPort::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
    221   Port::OnReadyToSend();
    222 }
    223 
    224 void TCPPort::OnAddressReady(talk_base::AsyncPacketSocket* socket,
    225                              const talk_base::SocketAddress& address) {
    226   AddAddress(address, address, talk_base::SocketAddress(), "tcp",
    227              LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST_TCP,
    228              true);
    229 }
    230 
    231 TCPConnection::TCPConnection(TCPPort* port, const Candidate& candidate,
    232                              talk_base::AsyncPacketSocket* socket)
    233     : Connection(port, 0, candidate), socket_(socket), error_(0) {
    234   bool outgoing = (socket_ == NULL);
    235   if (outgoing) {
    236     // TODO: Handle failures here (unlikely since TCP).
    237     int opts = (candidate.protocol() == SSLTCP_PROTOCOL_NAME) ?
    238         talk_base::PacketSocketFactory::OPT_SSLTCP : 0;
    239     socket_ = port->socket_factory()->CreateClientTcpSocket(
    240         talk_base::SocketAddress(port->ip(), 0),
    241         candidate.address(), port->proxy(), port->user_agent(), opts);
    242     if (socket_) {
    243       LOG_J(LS_VERBOSE, this) << "Connecting from "
    244                               << socket_->GetLocalAddress().ToSensitiveString()
    245                               << " to "
    246                               << candidate.address().ToSensitiveString();
    247       set_connected(false);
    248       socket_->SignalConnect.connect(this, &TCPConnection::OnConnect);
    249     } else {
    250       LOG_J(LS_WARNING, this) << "Failed to create connection to "
    251                               << candidate.address().ToSensitiveString();
    252     }
    253   } else {
    254     // Incoming connections should match the network address.
    255     ASSERT(socket_->GetLocalAddress().ipaddr() == port->ip());
    256   }
    257 
    258   if (socket_) {
    259     socket_->SignalReadPacket.connect(this, &TCPConnection::OnReadPacket);
    260     socket_->SignalReadyToSend.connect(this, &TCPConnection::OnReadyToSend);
    261     socket_->SignalClose.connect(this, &TCPConnection::OnClose);
    262   }
    263 }
    264 
    265 TCPConnection::~TCPConnection() {
    266   delete socket_;
    267 }
    268 
    269 int TCPConnection::Send(const void* data, size_t size,
    270                         const talk_base::PacketOptions& options) {
    271   if (!socket_) {
    272     error_ = ENOTCONN;
    273     return SOCKET_ERROR;
    274   }
    275 
    276   if (write_state() != STATE_WRITABLE) {
    277     // TODO: Should STATE_WRITE_TIMEOUT return a non-blocking error?
    278     error_ = EWOULDBLOCK;
    279     return SOCKET_ERROR;
    280   }
    281   int sent = socket_->Send(data, size, options);
    282   if (sent < 0) {
    283     error_ = socket_->GetError();
    284   } else {
    285     send_rate_tracker_.Update(sent);
    286   }
    287   return sent;
    288 }
    289 
    290 int TCPConnection::GetError() {
    291   return error_;
    292 }
    293 
    294 void TCPConnection::OnConnect(talk_base::AsyncPacketSocket* socket) {
    295   ASSERT(socket == socket_);
    296   // Do not use this connection if the socket bound to a different address than
    297   // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
    298   // given a binding address, and the platform is expected to pick the
    299   // correct local address.
    300   if (socket->GetLocalAddress().ipaddr() == port()->ip()) {
    301     LOG_J(LS_VERBOSE, this) << "Connection established to "
    302                             << socket->GetRemoteAddress().ToSensitiveString();
    303     set_connected(true);
    304   } else {
    305     LOG_J(LS_WARNING, this) << "Dropping connection as TCP socket bound to a "
    306                             << "different address from the local candidate.";
    307     socket_->Close();
    308   }
    309 }
    310 
    311 void TCPConnection::OnClose(talk_base::AsyncPacketSocket* socket, int error) {
    312   ASSERT(socket == socket_);
    313   LOG_J(LS_VERBOSE, this) << "Connection closed with error " << error;
    314   set_connected(false);
    315   set_write_state(STATE_WRITE_TIMEOUT);
    316 }
    317 
    318 void TCPConnection::OnReadPacket(
    319   talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
    320   const talk_base::SocketAddress& remote_addr,
    321   const talk_base::PacketTime& packet_time) {
    322   ASSERT(socket == socket_);
    323   Connection::OnReadPacket(data, size, packet_time);
    324 }
    325 
    326 void TCPConnection::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
    327   ASSERT(socket == socket_);
    328   Connection::OnReadyToSend();
    329 }
    330 
    331 }  // namespace cricket
    332