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
21namespace net {
22
23class AddressList;
24class IOBuffer;
25class IPEndPoint;
26
27class 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  // Setter/Getter methods for TCP FastOpen socket option.
79  // NOOPs since TCP FastOpen is not implemented in Windows.
80  bool UsingTCPFastOpen() const { return false; }
81  void EnableTCPFastOpenIfSupported() {}
82
83  bool IsValid() const { return socket_ != INVALID_SOCKET; }
84
85  // Marks the start/end of a series of connect attempts for logging purpose.
86  //
87  // TCPClientSocket may attempt to connect to multiple addresses until it
88  // succeeds in establishing a connection. The corresponding log will have
89  // multiple NetLog::TYPE_TCP_CONNECT_ATTEMPT entries nested within a
90  // NetLog::TYPE_TCP_CONNECT. These methods set the start/end of
91  // NetLog::TYPE_TCP_CONNECT.
92  //
93  // TODO(yzshen): Change logging format and let TCPClientSocket log the
94  // start/end of a series of connect attempts itself.
95  void StartLoggingMultipleConnectAttempts(const AddressList& addresses);
96  void EndLoggingMultipleConnectAttempts(int net_error);
97
98  const BoundNetLog& net_log() const { return net_log_; }
99
100 private:
101  class Core;
102
103  // base::ObjectWatcher::Delegate implementation.
104  virtual void OnObjectSignaled(HANDLE object) OVERRIDE;
105
106  int AcceptInternal(scoped_ptr<TCPSocketWin>* socket,
107                     IPEndPoint* address);
108
109  int DoConnect();
110  void DoConnectComplete(int result);
111
112  void LogConnectBegin(const AddressList& addresses);
113  void LogConnectEnd(int net_error);
114
115  int DoRead(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
116  void DidCompleteConnect();
117  void DidCompleteWrite();
118  void DidSignalRead();
119
120  SOCKET socket_;
121
122  HANDLE accept_event_;
123  base::win::ObjectWatcher accept_watcher_;
124
125  scoped_ptr<TCPSocketWin>* accept_socket_;
126  IPEndPoint* accept_address_;
127  CompletionCallback accept_callback_;
128
129  // The various states that the socket could be in.
130  bool waiting_connect_;
131  bool waiting_read_;
132  bool waiting_write_;
133
134  // The core of the socket that can live longer than the socket itself. We pass
135  // resources to the Windows async IO functions and we have to make sure that
136  // they are not destroyed while the OS still references them.
137  scoped_refptr<Core> core_;
138
139  // External callback; called when connect or read is complete.
140  CompletionCallback read_callback_;
141
142  // External callback; called when write is complete.
143  CompletionCallback write_callback_;
144
145  scoped_ptr<IPEndPoint> peer_address_;
146  // The OS error that a connect attempt last completed with.
147  int connect_os_error_;
148
149  bool logging_multiple_connect_attempts_;
150
151  BoundNetLog net_log_;
152
153  DISALLOW_COPY_AND_ASSIGN(TCPSocketWin);
154};
155
156}  // namespace net
157
158#endif  // NET_SOCKET_TCP_SOCKET_WIN_H_
159