OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2013 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 "net/socket/tcp_server_socket.h" |
| 6 |
| 7 #include "base/bind.h" |
| 8 #include "base/bind_helpers.h" |
| 9 #include "base/logging.h" |
| 10 #include "build/build_config.h" |
| 11 #include "net/base/net_errors.h" |
| 12 #include "net/socket/tcp_client_socket.h" |
| 13 |
| 14 namespace net { |
| 15 |
| 16 TCPServerSocket::TCPServerSocket(NetLog* net_log, const NetLog::Source& source) |
| 17 : socket_(net_log, source), |
| 18 pending_accept_(false) { |
| 19 } |
| 20 |
| 21 TCPServerSocket::~TCPServerSocket() { |
| 22 } |
| 23 |
| 24 int TCPServerSocket::Listen(const IPEndPoint& address, int backlog) { |
| 25 int result = socket_.Create(address.GetFamily()); |
| 26 if (result != OK) |
| 27 return result; |
| 28 |
| 29 result = socket_.SetDefaultOptionsForServer(); |
| 30 if (result != OK) { |
| 31 socket_.Close(); |
| 32 return result; |
| 33 } |
| 34 |
| 35 result = socket_.Bind(address); |
| 36 if (result != OK) { |
| 37 socket_.Close(); |
| 38 return result; |
| 39 } |
| 40 |
| 41 result = socket_.Listen(backlog); |
| 42 if (result != OK) { |
| 43 socket_.Close(); |
| 44 return result; |
| 45 } |
| 46 |
| 47 return OK; |
| 48 } |
| 49 |
| 50 int TCPServerSocket::GetLocalAddress(IPEndPoint* address) const { |
| 51 return socket_.GetLocalAddress(address); |
| 52 } |
| 53 |
| 54 int TCPServerSocket::Accept(scoped_ptr<StreamSocket>* socket, |
| 55 const CompletionCallback& callback) { |
| 56 DCHECK(socket); |
| 57 DCHECK(!callback.is_null()); |
| 58 |
| 59 if (pending_accept_) { |
| 60 NOTREACHED(); |
| 61 return ERR_UNEXPECTED; |
| 62 } |
| 63 |
| 64 // It is safe to use base::Unretained(this). |socket_| is owned by this class, |
| 65 // and the callback won't be run after |socket_| is destroyed. |
| 66 CompletionCallback accept_callback = |
| 67 base::Bind(&TCPServerSocket::OnAcceptCompleted, base::Unretained(this), |
| 68 socket, callback); |
| 69 int result = socket_.Accept(&accepted_socket_, &accepted_address_, |
| 70 accept_callback); |
| 71 if (result != ERR_IO_PENDING) { |
| 72 // |accept_callback| won't be called so we need to run |
| 73 // ConvertAcceptedSocket() ourselves in order to do the conversion from |
| 74 // |accepted_socket_| to |socket|. |
| 75 result = ConvertAcceptedSocket(result, socket); |
| 76 } else { |
| 77 pending_accept_ = true; |
| 78 } |
| 79 |
| 80 return result; |
| 81 } |
| 82 |
| 83 int TCPServerSocket::ConvertAcceptedSocket( |
| 84 int result, |
| 85 scoped_ptr<StreamSocket>* output_accepted_socket) { |
| 86 // Make sure the TCPSocket object is destroyed in any case. |
| 87 scoped_ptr<TCPSocket> temp_accepted_socket(accepted_socket_.Pass()); |
| 88 if (result != OK) |
| 89 return result; |
| 90 |
| 91 scoped_ptr<TCPClientSocket> client_socket(new TCPClientSocket( |
| 92 AddressList(accepted_address_), |
| 93 temp_accepted_socket->net_log().net_log(), |
| 94 temp_accepted_socket->net_log().source())); |
| 95 // TODO(yzshen): Once we switch TCPClientSocket::AdoptSocket() to take a |
| 96 // TCPSocket object, we don't need to do platform-specific handling. |
| 97 #if defined(OS_WIN) |
| 98 SOCKET raw_socket = temp_accepted_socket->Release(); |
| 99 #elif defined(OS_POSIX) |
| 100 int raw_socket = temp_accepted_socket->Release(); |
| 101 #endif |
| 102 result = client_socket->AdoptSocket(raw_socket); |
| 103 if (result != OK) { |
| 104 // |client_socket| won't take ownership of |raw_socket| on failure. |
| 105 // Therefore, we put it back into |temp_accepted_socket| to close it. |
| 106 temp_accepted_socket->Adopt(raw_socket); |
| 107 return result; |
| 108 } |
| 109 |
| 110 *output_accepted_socket = client_socket.Pass(); |
| 111 return OK; |
| 112 } |
| 113 |
| 114 void TCPServerSocket::OnAcceptCompleted( |
| 115 scoped_ptr<StreamSocket>* output_accepted_socket, |
| 116 const CompletionCallback& forward_callback, |
| 117 int result) { |
| 118 result = ConvertAcceptedSocket(result, output_accepted_socket); |
| 119 pending_accept_ = false; |
| 120 forward_callback.Run(result); |
| 121 } |
| 122 |
| 123 } // namespace net |
OLD | NEW |