1 // Copyright 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 #ifndef NET_SOCKET_TCP_SOCKET_WIN_H_ 6 #define NET_SOCKET_TCP_SOCKET_WIN_H_ 7 8 #include <winsock2.h> 9 10 #include "base/basictypes.h" 11 #include "base/compiler_specific.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/threading/non_thread_safe.h" 15 #include "base/win/object_watcher.h" 16 #include "net/base/address_family.h" 17 #include "net/base/completion_callback.h" 18 #include "net/base/net_export.h" 19 #include "net/base/net_log.h" 20 21 namespace net { 22 23 class AddressList; 24 class IOBuffer; 25 class IPEndPoint; 26 27 class NET_EXPORT TCPSocketWin : NON_EXPORTED_BASE(public base::NonThreadSafe), 28 public base::win::ObjectWatcher::Delegate { 29 public: 30 TCPSocketWin(NetLog* net_log, const NetLog::Source& source); 31 virtual ~TCPSocketWin(); 32 33 int Open(AddressFamily family); 34 35 // Both AdoptConnectedSocket and AdoptListenSocket take ownership of an 36 // existing socket. AdoptConnectedSocket takes an already connected 37 // socket. AdoptListenSocket takes a socket that is intended to accept 38 // connection. In some sense, AdoptListenSocket is more similar to Open. 39 int AdoptConnectedSocket(SOCKET socket, const IPEndPoint& peer_address); 40 int AdoptListenSocket(SOCKET socket); 41 42 int Bind(const IPEndPoint& address); 43 44 int Listen(int backlog); 45 int Accept(scoped_ptr<TCPSocketWin>* socket, 46 IPEndPoint* address, 47 const CompletionCallback& callback); 48 49 int Connect(const IPEndPoint& address, const CompletionCallback& callback); 50 bool IsConnected() const; 51 bool IsConnectedAndIdle() const; 52 53 // Multiple outstanding requests are not supported. 54 // Full duplex mode (reading and writing at the same time) is supported. 55 int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback); 56 int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback); 57 58 int GetLocalAddress(IPEndPoint* address) const; 59 int GetPeerAddress(IPEndPoint* address) const; 60 61 // Sets various socket options. 62 // The commonly used options for server listening sockets: 63 // - SetExclusiveAddrUse(). 64 int SetDefaultOptionsForServer(); 65 // The commonly used options for client sockets and accepted sockets: 66 // - Increase the socket buffer sizes for WinXP; 67 // - SetNoDelay(true); 68 // - SetKeepAlive(true, 45). 69 void SetDefaultOptionsForClient(); 70 int SetExclusiveAddrUse(); 71 int SetReceiveBufferSize(int32 size); 72 int SetSendBufferSize(int32 size); 73 bool SetKeepAlive(bool enable, int delay); 74 bool SetNoDelay(bool no_delay); 75 76 void Close(); 77 78 bool UsingTCPFastOpen() const; 79 bool IsValid() const { return socket_ != INVALID_SOCKET; } 80 81 // Marks the start/end of a series of connect attempts for logging purpose. 82 // 83 // TCPClientSocket may attempt to connect to multiple addresses until it 84 // succeeds in establishing a connection. The corresponding log will have 85 // multiple NetLog::TYPE_TCP_CONNECT_ATTEMPT entries nested within a 86 // NetLog::TYPE_TCP_CONNECT. These methods set the start/end of 87 // NetLog::TYPE_TCP_CONNECT. 88 // 89 // TODO(yzshen): Change logging format and let TCPClientSocket log the 90 // start/end of a series of connect attempts itself. 91 void StartLoggingMultipleConnectAttempts(const AddressList& addresses); 92 void EndLoggingMultipleConnectAttempts(int net_error); 93 94 const BoundNetLog& net_log() const { return net_log_; } 95 96 private: 97 class Core; 98 99 // base::ObjectWatcher::Delegate implementation. 100 virtual void OnObjectSignaled(HANDLE object) OVERRIDE; 101 102 int AcceptInternal(scoped_ptr<TCPSocketWin>* socket, 103 IPEndPoint* address); 104 105 int DoConnect(); 106 void DoConnectComplete(int result); 107 108 void LogConnectBegin(const AddressList& addresses); 109 void LogConnectEnd(int net_error); 110 111 int DoRead(IOBuffer* buf, int buf_len, const CompletionCallback& callback); 112 void DidCompleteConnect(); 113 void DidCompleteWrite(); 114 void DidSignalRead(); 115 116 SOCKET socket_; 117 118 HANDLE accept_event_; 119 base::win::ObjectWatcher accept_watcher_; 120 121 scoped_ptr<TCPSocketWin>* accept_socket_; 122 IPEndPoint* accept_address_; 123 CompletionCallback accept_callback_; 124 125 // The various states that the socket could be in. 126 bool waiting_connect_; 127 bool waiting_read_; 128 bool waiting_write_; 129 130 // The core of the socket that can live longer than the socket itself. We pass 131 // resources to the Windows async IO functions and we have to make sure that 132 // they are not destroyed while the OS still references them. 133 scoped_refptr<Core> core_; 134 135 // External callback; called when connect or read is complete. 136 CompletionCallback read_callback_; 137 138 // External callback; called when write is complete. 139 CompletionCallback write_callback_; 140 141 scoped_ptr<IPEndPoint> peer_address_; 142 // The OS error that a connect attempt last completed with. 143 int connect_os_error_; 144 145 bool logging_multiple_connect_attempts_; 146 147 BoundNetLog net_log_; 148 149 DISALLOW_COPY_AND_ASSIGN(TCPSocketWin); 150 }; 151 152 } // namespace net 153 154 #endif // NET_SOCKET_TCP_SOCKET_WIN_H_ 155 156
