1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "jingle/glue/fake_socket_factory.h" 6 7 #include "base/bind.h" 8 #include "base/message_loop/message_loop.h" 9 #include "jingle/glue/utils.h" 10 #include "third_party/libjingle/source/talk/base/asyncsocket.h" 11 12 namespace jingle_glue { 13 14 FakeUDPPacketSocket::FakeUDPPacketSocket(FakeSocketManager* fake_socket_manager, 15 const net::IPEndPoint& address) 16 : fake_socket_manager_(fake_socket_manager), 17 endpoint_(address), state_(IS_OPEN), error_(0) { 18 CHECK(IPEndPointToSocketAddress(endpoint_, &local_address_)); 19 fake_socket_manager_->AddSocket(this); 20 } 21 22 FakeUDPPacketSocket::~FakeUDPPacketSocket() { 23 fake_socket_manager_->RemoveSocket(this); 24 } 25 26 talk_base::SocketAddress FakeUDPPacketSocket::GetLocalAddress() const { 27 DCHECK(CalledOnValidThread()); 28 return local_address_; 29 } 30 31 talk_base::SocketAddress FakeUDPPacketSocket::GetRemoteAddress() const { 32 DCHECK(CalledOnValidThread()); 33 return remote_address_; 34 } 35 36 int FakeUDPPacketSocket::Send(const void *data, size_t data_size) { 37 DCHECK(CalledOnValidThread()); 38 return SendTo(data, data_size, remote_address_); 39 } 40 41 int FakeUDPPacketSocket::SendTo(const void *data, size_t data_size, 42 const talk_base::SocketAddress& address) { 43 DCHECK(CalledOnValidThread()); 44 45 if (state_ == IS_CLOSED) { 46 return ENOTCONN; 47 } 48 49 net::IPEndPoint destination; 50 if (!SocketAddressToIPEndPoint(address, &destination)) { 51 return EINVAL; 52 } 53 54 const char* data_char = reinterpret_cast<const char*>(data); 55 std::vector<char> data_vector(data_char, data_char + data_size); 56 57 fake_socket_manager_->SendPacket(endpoint_, destination, data_vector); 58 59 return data_size; 60 } 61 62 int FakeUDPPacketSocket::Close() { 63 DCHECK(CalledOnValidThread()); 64 state_ = IS_CLOSED; 65 return 0; 66 } 67 68 talk_base::AsyncPacketSocket::State FakeUDPPacketSocket::GetState() const { 69 DCHECK(CalledOnValidThread()); 70 71 switch (state_) { 72 case IS_OPEN: 73 return STATE_BOUND; 74 case IS_CLOSED: 75 return STATE_CLOSED; 76 } 77 78 NOTREACHED(); 79 return STATE_CLOSED; 80 } 81 82 int FakeUDPPacketSocket::GetOption(talk_base::Socket::Option opt, int* value) { 83 DCHECK(CalledOnValidThread()); 84 return -1; 85 } 86 87 int FakeUDPPacketSocket::SetOption(talk_base::Socket::Option opt, int value) { 88 DCHECK(CalledOnValidThread()); 89 return -1; 90 } 91 92 int FakeUDPPacketSocket::GetError() const { 93 DCHECK(CalledOnValidThread()); 94 return error_; 95 } 96 97 void FakeUDPPacketSocket::SetError(int error) { 98 DCHECK(CalledOnValidThread()); 99 error_ = error; 100 } 101 102 void FakeUDPPacketSocket::DeliverPacket(const net::IPEndPoint& from, 103 const std::vector<char>& data) { 104 DCHECK(CalledOnValidThread()); 105 106 talk_base::SocketAddress address; 107 if (!jingle_glue::IPEndPointToSocketAddress(from, &address)) { 108 // We should always be able to convert address here because we 109 // don't expect IPv6 address on IPv4 connections. 110 NOTREACHED(); 111 return; 112 } 113 114 SignalReadPacket(this, &data[0], data.size(), address); 115 } 116 117 FakeSocketManager::FakeSocketManager() 118 : message_loop_(base::MessageLoop::current()) {} 119 120 FakeSocketManager::~FakeSocketManager() { } 121 122 void FakeSocketManager::SendPacket(const net::IPEndPoint& from, 123 const net::IPEndPoint& to, 124 const std::vector<char>& data) { 125 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 126 127 message_loop_->PostTask( 128 FROM_HERE, 129 base::Bind(&FakeSocketManager::DeliverPacket, this, from, to, data)); 130 } 131 132 void FakeSocketManager::DeliverPacket(const net::IPEndPoint& from, 133 const net::IPEndPoint& to, 134 const std::vector<char>& data) { 135 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 136 137 std::map<net::IPEndPoint, FakeUDPPacketSocket*>::iterator it = 138 endpoints_.find(to); 139 if (it == endpoints_.end()) { 140 LOG(WARNING) << "Dropping packet with unknown destination: " 141 << to.ToString(); 142 return; 143 } 144 it->second->DeliverPacket(from, data); 145 } 146 147 void FakeSocketManager::AddSocket(FakeUDPPacketSocket* socket_factory) { 148 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 149 150 endpoints_[socket_factory->endpoint()] = socket_factory; 151 } 152 153 void FakeSocketManager::RemoveSocket(FakeUDPPacketSocket* socket_factory) { 154 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 155 156 endpoints_.erase(socket_factory->endpoint()); 157 } 158 159 FakeSocketFactory::FakeSocketFactory(FakeSocketManager* socket_manager, 160 const net::IPAddressNumber& address) 161 : socket_manager_(socket_manager), 162 address_(address), 163 last_allocated_port_(0) { 164 } 165 166 FakeSocketFactory::~FakeSocketFactory() { 167 } 168 169 talk_base::AsyncPacketSocket* FakeSocketFactory::CreateUdpSocket( 170 const talk_base::SocketAddress& local_address, int min_port, int max_port) { 171 CHECK_EQ(min_port, 0); 172 CHECK_EQ(max_port, 0); 173 return new FakeUDPPacketSocket( 174 socket_manager_.get(), net::IPEndPoint(address_, ++last_allocated_port_)); 175 } 176 177 talk_base::AsyncPacketSocket* FakeSocketFactory::CreateServerTcpSocket( 178 const talk_base::SocketAddress& local_address, int min_port, int max_port, 179 int opts) { 180 // TODO(sergeyu): Implement fake TCP sockets. 181 NOTIMPLEMENTED(); 182 return NULL; 183 } 184 185 talk_base::AsyncPacketSocket* FakeSocketFactory::CreateClientTcpSocket( 186 const talk_base::SocketAddress& local_address, 187 const talk_base::SocketAddress& remote_address, 188 const talk_base::ProxyInfo& proxy_info, const std::string& user_agent, 189 int opts) { 190 // TODO(sergeyu): Implement fake TCP sockets. 191 NOTIMPLEMENTED(); 192 return NULL; 193 } 194 195 } // namespace jingle_glue 196
